From 195d1ae3b0bac1b7686cb326b82b0cde8e8c7e40 Mon Sep 17 00:00:00 2001 From: Tobias Lindaaker Date: Fri, 12 Jan 2018 12:44:12 +0100 Subject: [PATCH] Rename Neo4jValue to DefaultParameterValue Since that was how it was used. --- .../v3_1/TransactionBoundPlanContext.scala | 4 +- .../v3_3/TransactionBoundPlanContext.scala | 4 +- .../TransactionBoundPlanContext.scala | 4 +- .../neo4j/kernel/api/proc/FieldSignature.java | 10 +- .../kernel/impl/factory/DataSourceModule.java | 12 +- ...jValue.java => DefaultParameterValue.java} | 38 ++--- .../neo4j/kernel/impl/proc/ListConverter.java | 6 +- .../neo4j/kernel/impl/proc/MapConverter.java | 6 +- .../impl/proc/MethodSignatureCompiler.java | 9 +- .../neo4j/kernel/impl/proc/OutputMappers.java | 14 +- .../neo4j/kernel/impl/proc/Procedures.java | 14 +- .../proc/ReflectiveProcedureCompiler.java | 26 ++-- .../neo4j/kernel/impl/proc/TypeMappers.java | 144 +++++++++--------- .../kernel/api/proc/FieldSignatureTest.java | 2 +- .../builtinprocs/BuiltInProceduresTest.java | 6 +- .../kernel/impl/proc/ListConverterTest.java | 26 ++-- .../kernel/impl/proc/MapConverterTest.java | 44 +++--- .../kernel/impl/proc/TypeMappersTest.java | 20 +-- 18 files changed, 199 insertions(+), 190 deletions(-) rename community/kernel/src/main/java/org/neo4j/kernel/impl/proc/{Neo4jValue.java => DefaultParameterValue.java} (63%) diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundPlanContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundPlanContext.scala index 58516ea0df166..4f2cffbc2c118 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundPlanContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundPlanContext.scala @@ -38,7 +38,7 @@ import org.neo4j.kernel.api.proc.{Neo4jTypes, QualifiedName => KernelQualifiedNa import org.neo4j.kernel.api.schema.SchemaDescriptorFactory import org.neo4j.kernel.api.schema.constaints.ConstraintDescriptor import org.neo4j.kernel.api.schema.index.{IndexDescriptor => KernelIndexDescriptor} -import org.neo4j.kernel.impl.proc.Neo4jValue +import org.neo4j.kernel.impl.proc.DefaultParameterValue import org.neo4j.procedure.Mode import scala.collection.JavaConverters._ @@ -179,7 +179,7 @@ class TransactionBoundPlanContext(tc: TransactionalContextWrapper, logger: Inter "Unable to execute procedure, because it requires an unrecognized execution mode: " + mode.name(), null ) } - private def asCypherValue(neo4jValue: Neo4jValue) = CypherValue(neo4jValue.value, asCypherType(neo4jValue.neo4jType())) + private def asCypherValue(neo4jValue: DefaultParameterValue) = CypherValue(neo4jValue.value, asCypherType(neo4jValue.neo4jType())) private def asCypherType(neoType: AnyType): CypherType = neoType match { case Neo4jTypes.NTString => symbols.CTString diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_3/TransactionBoundPlanContext.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_3/TransactionBoundPlanContext.scala index f2bb6d9554ba0..ad410f3e89d7e 100644 --- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_3/TransactionBoundPlanContext.scala +++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_3/TransactionBoundPlanContext.scala @@ -35,7 +35,7 @@ import org.neo4j.kernel.api.proc.Neo4jTypes.AnyType import org.neo4j.kernel.api.proc.{Neo4jTypes, QualifiedName => KernelQualifiedName} import org.neo4j.kernel.api.schema.SchemaDescriptorFactory import org.neo4j.kernel.api.schema.index.{IndexDescriptor => KernelIndexDescriptor} -import org.neo4j.kernel.impl.proc.Neo4jValue +import org.neo4j.kernel.impl.proc.DefaultParameterValue import org.neo4j.procedure.Mode import scala.collection.JavaConverters._ @@ -172,7 +172,7 @@ class TransactionBoundPlanContext(readOperationsSupplier: () => ReadOperations, "Unable to execute procedure, because it requires an unrecognized execution mode: " + mode.name(), null) } - private def asCypherValue(neo4jValue: Neo4jValue) = CypherValue(neo4jValue.value, + private def asCypherValue(neo4jValue: DefaultParameterValue) = CypherValue(neo4jValue.value, asCypherType(neo4jValue.neo4jType())) private def asCypherType(neoType: AnyType): CypherType = neoType match { diff --git a/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/TransactionBoundPlanContext.scala b/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/TransactionBoundPlanContext.scala index 1137335a5c09c..c783b1709c807 100644 --- a/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/TransactionBoundPlanContext.scala +++ b/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/TransactionBoundPlanContext.scala @@ -33,7 +33,7 @@ import org.neo4j.kernel.api.proc.Neo4jTypes.AnyType import org.neo4j.kernel.api.proc.{Neo4jTypes, QualifiedName => KernelQualifiedName} import org.neo4j.kernel.api.schema.SchemaDescriptorFactory import org.neo4j.kernel.api.schema.index.{IndexDescriptor => KernelIndexDescriptor} -import org.neo4j.kernel.impl.proc.Neo4jValue +import org.neo4j.kernel.impl.proc.DefaultParameterValue import org.neo4j.procedure.Mode import scala.collection.JavaConverters._ @@ -175,7 +175,7 @@ class TransactionBoundPlanContext(tc: TransactionalContextWrapper, logger: Inter "Unable to execute procedure, because it requires an unrecognized execution mode: " + mode.name(), null) } - private def asCypherValue(neo4jValue: Neo4jValue) = CypherValue(neo4jValue.value, + private def asCypherValue(neo4jValue: DefaultParameterValue) = CypherValue(neo4jValue.value, asCypherType(neo4jValue.neo4jType())) private def asCypherType(neoType: AnyType): CypherType = neoType match { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/api/proc/FieldSignature.java b/community/kernel/src/main/java/org/neo4j/kernel/api/proc/FieldSignature.java index 3f7606443c6d2..2a3a993d66f53 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/api/proc/FieldSignature.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/api/proc/FieldSignature.java @@ -22,7 +22,7 @@ import java.util.Objects; import java.util.Optional; -import org.neo4j.kernel.impl.proc.Neo4jValue; +import org.neo4j.kernel.impl.proc.DefaultParameterValue; import static java.util.Objects.requireNonNull; @@ -34,7 +34,7 @@ public static FieldSignature inputField( String name, Neo4jTypes.AnyType type ) return new FieldSignature( name, type, null, false ); } - public static FieldSignature inputField( String name, Neo4jTypes.AnyType type, Neo4jValue defaultValue ) + public static FieldSignature inputField( String name, Neo4jTypes.AnyType type, DefaultParameterValue defaultValue ) { return new FieldSignature( name, type, requireNonNull( defaultValue, "defaultValue" ), false ); } @@ -51,10 +51,10 @@ public static FieldSignature outputField( String name, Neo4jTypes.AnyType type, private final String name; private final Neo4jTypes.AnyType type; - private final Neo4jValue defaultValue; + private final DefaultParameterValue defaultValue; private final boolean deprecated; - private FieldSignature( String name, Neo4jTypes.AnyType type, Neo4jValue defaultValue, boolean deprecated ) + private FieldSignature( String name, Neo4jTypes.AnyType type, DefaultParameterValue defaultValue, boolean deprecated ) { this.name = requireNonNull( name, "name" ); this.type = requireNonNull( type, "type" ); @@ -81,7 +81,7 @@ public Neo4jTypes.AnyType neo4jType() return type; } - public Optional defaultValue() + public Optional defaultValue() { return Optional.ofNullable( defaultValue ); } diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java index 2c8b8145ec2dc..46fc1901027b6 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java @@ -62,7 +62,7 @@ import org.neo4j.kernel.impl.proc.ProcedureTransactionProvider; import org.neo4j.kernel.impl.proc.Procedures; import org.neo4j.kernel.impl.proc.TerminationGuardProvider; -import org.neo4j.kernel.impl.proc.TypeMappers.SimpleConverter; +import org.neo4j.kernel.impl.proc.TypeMappers.DefaultValueConverter; import org.neo4j.kernel.impl.query.QueryExecutionEngine; import org.neo4j.kernel.impl.store.StoreId; import org.neo4j.kernel.impl.transaction.log.files.LogFileCreationMonitor; @@ -249,11 +249,11 @@ private Procedures setupProcedures( PlatformModule platform, EditionModule editi platform.life.add( procedures ); platform.dependencies.satisfyDependency( procedures ); - procedures.registerType( Node.class, new SimpleConverter( NTNode, Node.class ) ); - procedures.registerType( Relationship.class, new SimpleConverter( NTRelationship, Relationship.class ) ); - procedures.registerType( Path.class, new SimpleConverter( NTPath, Path.class ) ); - procedures.registerType( Geometry.class, new SimpleConverter( NTGeometry, Geometry.class ) ); - procedures.registerType( Point.class, new SimpleConverter( NTPoint, Point.class ) ); + procedures.registerType( Node.class, NTNode ); + procedures.registerType( Relationship.class, NTRelationship ); + procedures.registerType( Path.class, NTPath ); + procedures.registerType( Geometry.class, NTGeometry ); + procedures.registerType( Point.class, NTPoint ); // Register injected public API components Log proceduresLog = platform.logging.getUserLog( Procedures.class ); diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Neo4jValue.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/DefaultParameterValue.java similarity index 63% rename from community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Neo4jValue.java rename to community/kernel/src/main/java/org/neo4j/kernel/impl/proc/DefaultParameterValue.java index 46dc24bef7c62..a13da9bc3e6e6 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Neo4jValue.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/DefaultParameterValue.java @@ -24,12 +24,12 @@ import org.neo4j.kernel.api.proc.Neo4jTypes; -public class Neo4jValue +public class DefaultParameterValue { private final Object value; private final Neo4jTypes.AnyType type; - public Neo4jValue( Object value, Neo4jTypes.AnyType type ) + public DefaultParameterValue( Object value, Neo4jTypes.AnyType type ) { this.value = value; this.type = type; @@ -45,40 +45,45 @@ public Neo4jTypes.AnyType neo4jType() return type; } - public static Neo4jValue ntString( String value ) + public static DefaultParameterValue ntString( String value ) { - return new Neo4jValue( value, Neo4jTypes.NTString ); + return new DefaultParameterValue( value, Neo4jTypes.NTString ); } - public static Neo4jValue ntInteger( long value ) + static DefaultParameterValue ntInteger( long value ) { - return new Neo4jValue( value, Neo4jTypes.NTInteger ); + return new DefaultParameterValue( value, Neo4jTypes.NTInteger ); } - public static Neo4jValue ntFloat( double value ) + static DefaultParameterValue ntFloat( double value ) { - return new Neo4jValue( value, Neo4jTypes.NTFloat ); + return new DefaultParameterValue( value, Neo4jTypes.NTFloat ); } - public static Neo4jValue ntBoolean( boolean value ) + static DefaultParameterValue ntBoolean( boolean value ) { - return new Neo4jValue( value, Neo4jTypes.NTBoolean ); + return new DefaultParameterValue( value, Neo4jTypes.NTBoolean ); } - public static Neo4jValue ntMap( Map value ) + static DefaultParameterValue ntMap( Map value ) { - return new Neo4jValue( value, Neo4jTypes.NTMap ); + return new DefaultParameterValue( value, Neo4jTypes.NTMap ); } - public static Neo4jValue ntList( List value, Neo4jTypes.AnyType inner ) + static DefaultParameterValue ntList( List value, Neo4jTypes.AnyType inner ) { - return new Neo4jValue( value, Neo4jTypes.NTList( inner ) ); + return new DefaultParameterValue( value, Neo4jTypes.NTList( inner ) ); + } + + static DefaultParameterValue nullValue( Neo4jTypes.AnyType type ) + { + return new DefaultParameterValue( null, type ); } @Override public String toString() { - return "Neo4jValue{" + + return "DefaultParameterValue{" + "value=" + value + ", type=" + type + '}'; @@ -96,14 +101,13 @@ public boolean equals( Object o ) return false; } - Neo4jValue that = (Neo4jValue) o; + DefaultParameterValue that = (DefaultParameterValue) o; if ( value != null ? !value.equals( that.value ) : that.value != null ) { return false; } return type.equals( that.type ); - } @Override diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ListConverter.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ListConverter.java index d075424bc40a0..ad4c9a1a86220 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ListConverter.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ListConverter.java @@ -24,11 +24,11 @@ import org.neo4j.kernel.api.proc.Neo4jTypes; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntList; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntList; import static org.neo4j.kernel.impl.proc.ParseUtil.parseList; -public class ListConverter implements Function +public class ListConverter implements Function { private final Type type; private final Neo4jTypes.AnyType neoType; @@ -40,7 +40,7 @@ public ListConverter( Type type, Neo4jTypes.AnyType neoType ) } @Override - public Neo4jValue apply( String s ) + public DefaultParameterValue apply( String s ) { String value = s.trim(); if ( value.equalsIgnoreCase( "null" ) ) diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MapConverter.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MapConverter.java index be50bd5c8d8ec..feebb75a6ef9e 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MapConverter.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MapConverter.java @@ -21,7 +21,7 @@ import java.util.function.Function; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntMap; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntMap; import static org.neo4j.kernel.impl.proc.ParseUtil.parseMap; /** @@ -29,10 +29,10 @@ * for parsing huge json-document in a place where performance matters - you probably need * to rethink your decision. */ -public class MapConverter implements Function +public class MapConverter implements Function { @Override - public Neo4jValue apply( String s ) + public DefaultParameterValue apply( String s ) { String value = s.trim(); if ( value.equalsIgnoreCase( "null" ) ) diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MethodSignatureCompiler.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MethodSignatureCompiler.java index 03498d147e475..4c697913ead8c 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MethodSignatureCompiler.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MethodSignatureCompiler.java @@ -30,7 +30,7 @@ import org.neo4j.kernel.api.exceptions.Status; import org.neo4j.kernel.api.proc.FieldSignature; import org.neo4j.kernel.api.proc.Neo4jTypes; -import org.neo4j.kernel.impl.proc.TypeMappers.NeoValueConverter; +import org.neo4j.kernel.impl.proc.TypeMappers.DefaultValueConverter; import org.neo4j.procedure.Name; import static org.neo4j.kernel.api.proc.FieldSignature.inputField; @@ -54,8 +54,7 @@ public List inputTypesFor( Method method ) throws ProcedureE List neoTypes = new ArrayList<>( types.length ); for ( Type type : types ) { - NeoValueConverter valueConverter = typeMappers.converterFor( type ); - neoTypes.add( valueConverter.type() ); + neoTypes.add( typeMappers.toNeo4jType( type ) ); } return neoTypes; @@ -92,8 +91,8 @@ public List signatureFor( Method method ) throws ProcedureExcept try { - NeoValueConverter valueConverter = typeMappers.converterFor( type ); - Optional defaultValue = valueConverter.defaultValue( parameter ); + DefaultValueConverter valueConverter = typeMappers.converterFor( type ); + Optional defaultValue = valueConverter.defaultValue( parameter ); //it is not allowed to have holes in default values if ( seenDefault && !defaultValue.isPresent() ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/OutputMappers.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/OutputMappers.java index a2f0d0677f78a..16164d1f00e74 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/OutputMappers.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/OutputMappers.java @@ -98,18 +98,18 @@ public List signature() private static class FieldMapper { private final MethodHandle getter; - private final TypeMappers.NeoValueConverter mapper; + private final TypeMappers.TypeChecker checker; - FieldMapper( MethodHandle getter, TypeMappers.NeoValueConverter mapper ) + FieldMapper( MethodHandle getter, TypeMappers.TypeChecker checker ) { this.getter = getter; - this.mapper = mapper; + this.checker = checker; } Object apply( Object record ) throws ProcedureException { Object invoke = getValue( record ); - return mapper.toNeoValue( invoke ); + return checker.typeCheck( invoke ); } private Object getValue( Object record ) throws ProcedureException @@ -196,12 +196,12 @@ public OutputMapper mapper( Class userClass ) throws ProcedureException try { - TypeMappers.NeoValueConverter mapper = typeMappers.converterFor( field.getGenericType() ); + TypeMappers.TypeChecker checker = typeMappers.checkerFor( field.getGenericType() ); MethodHandle getter = lookup.unreflectGetter( field ); - FieldMapper fieldMapper = new FieldMapper( getter, mapper ); + FieldMapper fieldMapper = new FieldMapper( getter, checker ); fieldMappers[i] = fieldMapper; - signature[i] = FieldSignature.outputField( field.getName(), mapper.type(), field.isAnnotationPresent( Deprecated.class ) ); + signature[i] = FieldSignature.outputField( field.getName(), checker.type(), field.isAnnotationPresent( Deprecated.class ) ); } catch ( ProcedureException e ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Procedures.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Procedures.java index b258d0c8a582e..00f05e422cb35 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Procedures.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/Procedures.java @@ -31,6 +31,7 @@ import org.neo4j.kernel.api.proc.CallableUserAggregationFunction; import org.neo4j.kernel.api.proc.CallableUserFunction; import org.neo4j.kernel.api.proc.Context; +import org.neo4j.kernel.api.proc.Neo4jTypes; import org.neo4j.kernel.api.proc.ProcedureSignature; import org.neo4j.kernel.api.proc.QualifiedName; import org.neo4j.kernel.api.proc.UserFunctionSignature; @@ -213,13 +214,16 @@ public void registerFunction( Class func, boolean overrideCurrentImplementati } /** - * Registers a type and how to convert it to a Neo4jType - * @param javaClass the class of the native type - * @param toNeo the conversion to Neo4jTypes + * Registers a type and its mapping to Neo4jTypes + * + * @param javaClass + * the class of the native type + * @param type + * the mapping to Neo4jTypes */ - public void registerType( Class javaClass, TypeMappers.NeoValueConverter toNeo ) + public void registerType( Class javaClass, Neo4jTypes.AnyType type ) { - typeMappers.registerType( javaClass, toNeo ); + typeMappers.registerType( javaClass, new TypeMappers.DefaultValueConverter( type, javaClass ) ); } /** diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ReflectiveProcedureCompiler.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ReflectiveProcedureCompiler.java index 89755d2d0517a..e092248dab7cb 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ReflectiveProcedureCompiler.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/ReflectiveProcedureCompiler.java @@ -325,7 +325,7 @@ private CallableUserFunction compileFunction( Class procDefinition, MethodHan List inputSignature = inputSignatureDeterminer.signatureFor( method ); Class returnType = method.getReturnType(); - TypeMappers.NeoValueConverter valueConverter = typeMappers.converterFor( returnType ); + TypeMappers.TypeChecker typeChecker = typeMappers.checkerFor( returnType ); MethodHandle procedureMethod = lookup.unreflect( method ); Optional description = description( method ); UserFunction function = method.getAnnotation( UserFunction.class ); @@ -343,17 +343,17 @@ private CallableUserFunction compileFunction( Class procDefinition, MethodHan { description = describeAndLogLoadFailure( procName ); UserFunctionSignature signature = - new UserFunctionSignature( procName, inputSignature, valueConverter.type(), deprecated, + new UserFunctionSignature( procName, inputSignature, typeChecker.type(), deprecated, config.rolesFor( procName.toString() ), description ); return new FailedLoadFunction( signature ); } } UserFunctionSignature signature = - new UserFunctionSignature( procName, inputSignature, valueConverter.type(), deprecated, + new UserFunctionSignature( procName, inputSignature, typeChecker.type(), deprecated, config.rolesFor( procName.toString() ), description ); - return new ReflectiveUserFunction( signature, constructor, procedureMethod, valueConverter, setters ); + return new ReflectiveUserFunction( signature, constructor, procedureMethod, typeChecker, setters ); } private CallableUserAggregationFunction compileAggregationFunction( Class definition, MethodHandle constructor, @@ -428,7 +428,7 @@ private CallableUserAggregationFunction compileAggregationFunction( Class def List inputSignature = inputSignatureDeterminer.signatureFor( update ); Class returnType = result.getReturnType(); - TypeMappers.NeoValueConverter valueConverter = typeMappers.converterFor( returnType ); + TypeMappers.TypeChecker valueConverter = typeMappers.checkerFor( returnType ); MethodHandle creator = lookup.unreflect( method ); MethodHandle updateMethod = lookup.unreflect( update ); MethodHandle resultMethod = lookup.unreflect( result ); @@ -710,20 +710,20 @@ public void close() throws Exception private static class ReflectiveUserFunction extends ReflectiveBase implements CallableUserFunction { - private final TypeMappers.NeoValueConverter valueConverter; + private final TypeMappers.TypeChecker typeChecker; private final UserFunctionSignature signature; private final MethodHandle constructor; private final MethodHandle udfMethod; ReflectiveUserFunction( UserFunctionSignature signature, MethodHandle constructor, - MethodHandle procedureMethod, TypeMappers.NeoValueConverter outputMapper, + MethodHandle procedureMethod, TypeMappers.TypeChecker typeChecker, List fieldSetters ) { super( fieldSetters ); this.constructor = constructor; this.udfMethod = procedureMethod; this.signature = signature; - this.valueConverter = outputMapper; + this.typeChecker = typeChecker; } @Override @@ -758,7 +758,7 @@ public Object apply( Context ctx, Object[] input ) throws ProcedureException Object rs = udfMethod.invokeWithArguments( args ); - return valueConverter.toNeoValue( rs ); + return typeChecker.typeCheck( rs ); } catch ( Throwable throwable ) { @@ -780,7 +780,7 @@ private static class ReflectiveUserAggregationFunction extends ReflectiveBase im CallableUserAggregationFunction { - private final TypeMappers.NeoValueConverter valueConverter; + private final TypeMappers.TypeChecker typeChecker; private final UserFunctionSignature signature; private final MethodHandle constructor; private final MethodHandle creator; @@ -789,7 +789,7 @@ private static class ReflectiveUserAggregationFunction extends ReflectiveBase im ReflectiveUserAggregationFunction( UserFunctionSignature signature, MethodHandle constructor, MethodHandle creator, MethodHandle updateMethod, MethodHandle resultMethod, - TypeMappers.NeoValueConverter outputMapper, + TypeMappers.TypeChecker typeChecker, List fieldSetters ) { super( fieldSetters ); @@ -798,7 +798,7 @@ private static class ReflectiveUserAggregationFunction extends ReflectiveBase im this.updateMethod = updateMethod; this.resultMethod = resultMethod; this.signature = signature; - this.valueConverter = outputMapper; + this.typeChecker = typeChecker; } @Override @@ -862,7 +862,7 @@ public Object result() throws ProcedureException { try { - return valueConverter.toNeoValue( resultMethod.invoke(aggregator) ); + return typeChecker.typeCheck( resultMethod.invoke(aggregator) ); } catch ( Throwable throwable ) { diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/TypeMappers.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/TypeMappers.java index 3817571f8536d..30640c2e26010 100644 --- a/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/TypeMappers.java +++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/proc/TypeMappers.java @@ -46,27 +46,42 @@ import static org.neo4j.kernel.api.proc.Neo4jTypes.NTMap; import static org.neo4j.kernel.api.proc.Neo4jTypes.NTNumber; import static org.neo4j.kernel.api.proc.Neo4jTypes.NTString; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntBoolean; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntFloat; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntInteger; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntBoolean; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntFloat; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntInteger; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.nullValue; public class TypeMappers { - /** - * Converts a java object to the specified {@link #type() neo4j type}. In practice, this is - * often the same java object - but this gives a guarantee that only java objects Neo4j can - * digest are outputted. - */ - interface NeoValueConverter + public abstract static class TypeChecker { - AnyType type(); + final AnyType type; + final Class javaClass; - Object toNeoValue( Object javaValue ) throws ProcedureException; + private TypeChecker( AnyType type, Class javaClass ) + { + this.type = type; + this.javaClass = javaClass; + } + + public AnyType type() + { + return type; + } - Optional defaultValue( Name parameter ) throws ProcedureException; + public Object typeCheck( Object javaValue ) throws ProcedureException + { + if ( javaValue == null || javaClass.isInstance( javaValue ) ) + { + return javaValue; + } + throw new ProcedureException( Status.Procedure.ProcedureCallFailed, + "Expected `%s` to be a `%s`, found `%s`.", javaValue, javaClass.getSimpleName(), + javaValue.getClass() ); + } } - private final Map javaToNeo = new HashMap<>(); + private final Map javaToNeo = new HashMap<>(); public TypeMappers() { @@ -95,14 +110,19 @@ private void registerScalarsAndCollections() registerType( Object.class, TO_ANY ); } - public AnyType neoTypeFor( Type javaType ) throws ProcedureException + public AnyType toNeo4jType( Type type ) throws ProcedureException { - return converterFor( javaType ).type(); + return converterFor( type ).type; } - public NeoValueConverter converterFor( Type javaType ) throws ProcedureException + public TypeChecker checkerFor( Type javaType ) throws ProcedureException { - NeoValueConverter converter = javaToNeo.get( javaType ); + return converterFor( javaType ); + } + + DefaultValueConverter converterFor( Type javaType ) throws ProcedureException + { + DefaultValueConverter converter = javaToNeo.get( javaType ); if ( converter != null ) { return converter; @@ -123,45 +143,49 @@ else if ( rawType == Map.class ) Type type = pt.getActualTypeArguments()[0]; if ( type != String.class ) { - throw new ProcedureException( Status.Procedure.ProcedureRegistrationFailed, + throw new ProcedureException( + Status.Procedure.ProcedureRegistrationFailed, "Maps are required to have `String` keys - but this map has `%s` keys.", type.getTypeName() ); } return TO_MAP; } } - throw javaToNeoMappingError( javaType ); } - public void registerType( Class javaClass, NeoValueConverter toNeo ) + void registerType( Class javaClass, DefaultValueConverter toNeo ) { javaToNeo.put( javaClass, toNeo ); } - private final NeoValueConverter TO_ANY = new SimpleConverter( NTAny, Object.class ); - private final NeoValueConverter TO_STRING = new SimpleConverter( NTString, String.class, Neo4jValue::ntString ); - private final NeoValueConverter TO_INTEGER = new SimpleConverter( NTInteger, Long.class, s -> ntInteger( parseLong(s) ) ); - private final NeoValueConverter TO_FLOAT = new SimpleConverter( NTFloat, Double.class, s -> ntFloat( parseDouble( s ) ) ); - private final NeoValueConverter TO_NUMBER = new SimpleConverter( NTNumber, Number.class, s -> + private static final DefaultValueConverter TO_ANY = new DefaultValueConverter( NTAny, Object.class ); + private static final DefaultValueConverter TO_STRING = new DefaultValueConverter( NTString, String.class, + DefaultParameterValue::ntString ); + private static final DefaultValueConverter TO_INTEGER = new DefaultValueConverter( NTInteger, Long.class, s -> + ntInteger( parseLong( s ) ) ); + private static final DefaultValueConverter TO_FLOAT = new DefaultValueConverter( NTFloat, Double.class, s -> + ntFloat( parseDouble( s ) ) ); + private static final DefaultValueConverter TO_NUMBER = new DefaultValueConverter( NTNumber, Number.class, s -> { try { - return ntInteger( parseLong(s) ); + return ntInteger( parseLong( s ) ); } catch ( NumberFormatException e ) { return ntFloat( parseDouble( s ) ); } } ); - private final NeoValueConverter TO_BOOLEAN = - new SimpleConverter( NTBoolean, Boolean.class, s -> ntBoolean( parseBoolean( s ) ) ); - private final NeoValueConverter TO_MAP = new SimpleConverter( NTMap, Map.class, new MapConverter() ); - private final NeoValueConverter TO_LIST = toList( TO_ANY, Object.class ); + private static final DefaultValueConverter TO_BOOLEAN = new DefaultValueConverter( NTBoolean, Boolean.class, s -> + ntBoolean( parseBoolean( s ) ) ); + private static final DefaultValueConverter TO_MAP = + new DefaultValueConverter( NTMap, Map.class, new MapConverter() ); + private static final DefaultValueConverter TO_LIST = toList( TO_ANY, Object.class ); - private NeoValueConverter toList( NeoValueConverter inner, Type type ) + private static DefaultValueConverter toList( DefaultValueConverter inner, Type type ) { - return new SimpleConverter( NTList( inner.type() ), List.class, new ListConverter( type, inner.type() ) ); + return new DefaultValueConverter( NTList( inner.type() ), List.class, new ListConverter( type, inner.type() ) ); } private ProcedureException javaToNeoMappingError( Type cls ) @@ -169,35 +193,31 @@ private ProcedureException javaToNeoMappingError( Type cls ) List types = Iterables.asList( javaToNeo.keySet() ) .stream() .map( Type::getTypeName ) - .collect( Collectors.toList()); - types.sort( String::compareTo ); + .sorted( String::compareTo ) + .collect( Collectors.toList() ); return new ProcedureException( Status.Statement.TypeError, "Don't know how to map `%s` to the Neo4j Type System.%n" + - "Please refer to to the documentation for full details.%n" + - "For your reference, known types are: %s", cls.getTypeName(), types ); + "Please refer to to the documentation for full details.%n" + + "For your reference, known types are: %s", cls.getTypeName(), types ); } - public static class SimpleConverter implements NeoValueConverter + public static final class DefaultValueConverter extends TypeChecker { - private final AnyType type; - private final Class javaClass; - private final Function defaultConverter; + private final Function parser; - public SimpleConverter( AnyType type, Class javaClass ) + public DefaultValueConverter( AnyType type, Class javaClass ) { - this( type, javaClass, nullParser(javaClass, type) ); + this( type, javaClass, nullParser( javaClass, type ) ); } - public SimpleConverter( AnyType type, Class javaClass, Function defaultConverter ) + private DefaultValueConverter( AnyType type, Class javaClass, Function parser ) { - this.type = type; - this.javaClass = javaClass; - this.defaultConverter = defaultConverter; + super( type, javaClass ); + this.parser = parser; } - @Override - public Optional defaultValue( Name parameter ) throws ProcedureException + public Optional defaultValue( Name parameter ) throws ProcedureException { String defaultValue = parameter.defaultValue(); if ( defaultValue.equals( Name.DEFAULT_VALUE ) ) @@ -208,7 +228,7 @@ public Optional defaultValue( Name parameter ) throws ProcedureExcep { try { - return Optional.of( defaultConverter.apply( defaultValue ) ); + return Optional.of( parser.apply( defaultValue ) ); } catch ( Exception e ) { @@ -219,38 +239,20 @@ public Optional defaultValue( Name parameter ) throws ProcedureExcep } } - @Override - public AnyType type() - { - return type; - } - - @Override - public Object toNeoValue( Object javaValue ) throws ProcedureException - { - if ( javaValue == null || javaClass.isInstance( javaValue ) ) - { - return javaValue; - } - throw new ProcedureException( Status.Procedure.ProcedureCallFailed, - "Expected `%s` to be a `%s`, found `%s`.", javaValue, javaClass.getSimpleName(), - javaValue.getClass() ); - } - - private static Function nullParser( Class javaType, Neo4jTypes.AnyType neoType ) + private static Function nullParser( Class javaType, Neo4jTypes.AnyType neoType ) { return s -> { if ( s.equalsIgnoreCase( "null" ) ) { - return new Neo4jValue( null, neoType ); + return nullValue( neoType ); } else { - throw new IllegalArgumentException( String.format( "A %s can only have a `defaultValue = \"null\"", + throw new IllegalArgumentException( String.format( + "A %s can only have a `defaultValue = \"null\"", javaType.getSimpleName() ) ); } - }; } } diff --git a/community/kernel/src/test/java/org/neo4j/kernel/api/proc/FieldSignatureTest.java b/community/kernel/src/test/java/org/neo4j/kernel/api/proc/FieldSignatureTest.java index a04fddff7b6e6..3117e0316f289 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/api/proc/FieldSignatureTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/api/proc/FieldSignatureTest.java @@ -26,7 +26,7 @@ import static org.junit.Assert.fail; import static org.neo4j.kernel.api.proc.FieldSignature.inputField; import static org.neo4j.kernel.api.proc.FieldSignature.outputField; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntString; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntString; public class FieldSignatureTest { diff --git a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java index 6a35400073ed5..d33ca9eda0e8c 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/builtinprocs/BuiltInProceduresTest.java @@ -471,9 +471,9 @@ public void setup() throws Exception procs.registerComponent( GraphDatabaseAPI.class, ctx -> ctx.get( GRAPHDATABASEAPI ), false ); procs.registerComponent( SecurityContext.class, ctx -> ctx.get( SECURITY_CONTEXT ), true ); - procs.registerType( Node.class, new TypeMappers.SimpleConverter( NTNode, Node.class ) ); - procs.registerType( Relationship.class, new TypeMappers.SimpleConverter( NTRelationship, Relationship.class ) ); - procs.registerType( Path.class, new TypeMappers.SimpleConverter( NTPath, Path.class ) ); + procs.registerType( Node.class, NTNode ); + procs.registerType( Relationship.class, NTRelationship ); + procs.registerType( Path.class, NTPath ); new SpecialBuiltInProcedures( "1.3.37", Edition.enterprise.toString() ).accept( procs ); procs.registerProcedure( BuiltInProcedures.class ); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/ListConverterTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/ListConverterTest.java index a4d84c19acf5d..0589d9433e4c6 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/ListConverterTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/ListConverterTest.java @@ -43,7 +43,7 @@ import static org.neo4j.kernel.api.proc.Neo4jTypes.NTList; import static org.neo4j.kernel.api.proc.Neo4jTypes.NTMap; import static org.neo4j.kernel.api.proc.Neo4jTypes.NTString; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntList; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntList; public class ListConverterTest { @@ -59,7 +59,7 @@ public void shouldHandleNullString() String listString = "null"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( null, NTString ) ) ); @@ -73,7 +73,7 @@ public void shouldHandleEmptyList() String listString = "[]"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( emptyList(), NTString ) ) ); @@ -87,7 +87,7 @@ public void shouldHandleEmptyListWithSpaces() String listString = " [ ] "; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( emptyList(), NTString ) ) ); @@ -101,7 +101,7 @@ public void shouldHandleSingleQuotedValue() String listString = "['foo', 'bar']"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( asList( "foo", "bar" ), NTString ) ) ); @@ -115,7 +115,7 @@ public void shouldHandleDoubleQuotedValue() String listString = "[\"foo\", \"bar\"]"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( asList( "foo", "bar" ), NTString ) ) ); @@ -129,7 +129,7 @@ public void shouldHandleIntegerValue() String listString = "[1337, 42]"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( asList( 1337L, 42L ), NTInteger ) ) ); @@ -143,7 +143,7 @@ public void shouldHandleFloatValue() String listSting = "[2.718281828, 3.14]"; // When - Neo4jValue converted = converter.apply( listSting ); + DefaultParameterValue converted = converter.apply( listSting ); // Then assertThat( converted, equalTo( ntList( asList( 2.718281828, 3.14 ), NTFloat ) ) ); @@ -157,7 +157,7 @@ public void shouldHandleNullValue() String listString = "[null]"; // When - Neo4jValue converted = converter.apply( listString ); + DefaultParameterValue converted = converter.apply( listString ); // Then assertThat( converted, equalTo( ntList( singletonList( null ), NTFloat ) ) ); @@ -171,7 +171,7 @@ public void shouldHandleBooleanValues() String mapString = "[false, true]"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntList( asList( false, true ), NTBoolean ) ) ); @@ -188,7 +188,7 @@ public void shouldHandleNestedLists() String mapString = "[42, [42, 1337]]"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then List list = (List) converted.value(); @@ -219,7 +219,7 @@ public void shouldPassOnValidMixedTyoes() String listString = "[1337, 'forty-two']"; // When - Neo4jValue value = converter.apply( listString ); + DefaultParameterValue value = converter.apply( listString ); // Then assertThat( value, equalTo( ntList( asList( 1337L, "forty-two" ), NTAny ) ) ); @@ -234,7 +234,7 @@ public void shouldHandleListsOfMaps() String mapString = "[{k1: 42}, {k1: 1337}]"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then List list = (List) converted.value(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/MapConverterTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/MapConverterTest.java index 309504bbe2919..91ce20cfeb89e 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/MapConverterTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/MapConverterTest.java @@ -30,7 +30,7 @@ import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.Assert.assertThat; import static org.neo4j.helpers.collection.MapUtil.map; -import static org.neo4j.kernel.impl.proc.Neo4jValue.ntMap; +import static org.neo4j.kernel.impl.proc.DefaultParameterValue.ntMap; public class MapConverterTest { @@ -46,7 +46,7 @@ public void shouldHandleNullString() String mapString = "null"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( null ) ) ); @@ -59,7 +59,7 @@ public void shouldHandleEmptyMap() String mapString = "{}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( emptyMap() ) ) ); @@ -72,7 +72,7 @@ public void shouldHandleEmptyMapWithSpaces() String mapString = " { } "; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( emptyMap() ) ) ); @@ -85,7 +85,7 @@ public void shouldHandleSingleQuotedValue() String mapString = "{key: 'value'}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "value" ) ) ) ); @@ -98,7 +98,7 @@ public void shouldHandleEscapedSingleQuotedInValue1() String mapString = "{key: 'va\'lue'}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "va\'lue" ) ) ) ); @@ -111,7 +111,7 @@ public void shouldHandleEscapedSingleQuotedInValue2() String mapString = "{key: \"va\'lue\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "va\'lue" ) ) ) ); @@ -124,7 +124,7 @@ public void shouldHandleEscapedDoubleQuotedInValue1() String mapString = "{key: \"va\"lue\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "va\"lue" ) ) ) ); @@ -137,7 +137,7 @@ public void shouldHandleEscapedDoubleQuotedInValue2() String mapString = "{key: 'va\"lue'}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "va\"lue" ) ) ) ); @@ -150,7 +150,7 @@ public void shouldHandleDoubleQuotedValue() String mapString = "{key: \"value\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "value" ) ) ) ); @@ -163,7 +163,7 @@ public void shouldHandleSingleQuotedKey() String mapString = "{'key;: 'value'}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "value" ) ) ) ); @@ -176,7 +176,7 @@ public void shouldHandleDoubleQuotedKey() String mapString = "{\"key\": \"value\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", "value" ) ) ) ); @@ -189,7 +189,7 @@ public void shouldHandleKeyWithEscapedSingleQuote() String mapString = "{\"k\'ey\": \"value\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "k\'ey", "value" ) ) ) ); @@ -202,7 +202,7 @@ public void shouldHandleKeyWithEscapedDoubleQuote() String mapString = "{\"k\"ey\": \"value\"}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "k\"ey", "value" ) ) ) ); @@ -215,7 +215,7 @@ public void shouldHandleIntegerValue() String mapString = "{key: 1337}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", 1337L ) ) ) ); @@ -228,7 +228,7 @@ public void shouldHandleFloatValue() String mapString = "{key: 2.718281828}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", 2.718281828 ) ) ) ); @@ -241,7 +241,7 @@ public void shouldHandleNullValue() String mapString = "{key: null}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", null ) ) ) ); @@ -254,7 +254,7 @@ public void shouldHandleFalseValue() String mapString = "{key: false}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", false ) ) ) ); @@ -267,7 +267,7 @@ public void shouldHandleTrueValue() String mapString = "{key: true}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "key", true ) ) ) ); @@ -280,7 +280,7 @@ public void shouldHandleMultipleKeys() String mapString = "{k1: 2.718281828, k2: 'e'}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then assertThat( converted, equalTo( ntMap( map( "k1", 2.718281828, "k2", "e" ) ) ) ); @@ -308,7 +308,7 @@ public void shouldHandleNestedMaps() String mapString = "{k1: 1337, k2: { k1 : 1337, k2: {k1: 1337}}}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then Map map1 = (Map) converted.value(); @@ -341,7 +341,7 @@ public void shouldHandleMapsWithLists() String mapString = "{k1: [1337, 42]}"; // When - Neo4jValue converted = converter.apply( mapString ); + DefaultParameterValue converted = converter.apply( mapString ); // Then Map map1 = (Map) converted.value(); diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/TypeMappersTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/TypeMappersTest.java index 4315600d2532d..e86bbb226e1a1 100644 --- a/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/TypeMappersTest.java +++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/proc/TypeMappersTest.java @@ -19,19 +19,19 @@ */ package org.neo4j.kernel.impl.proc; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.HashMap; import java.util.List; import java.util.Map; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + import org.neo4j.kernel.api.proc.Neo4jTypes; -import org.neo4j.kernel.impl.proc.TypeMappers.NeoValueConverter; +import org.neo4j.kernel.impl.proc.TypeMappers.TypeChecker; import static java.util.Arrays.asList; import static java.util.Collections.emptyList; @@ -141,20 +141,20 @@ private static HashMap getKMap() public void shouldDetectCorrectType() throws Throwable { // When - NeoValueConverter mapper = new TypeMappers().converterFor( javaClass ); + Neo4jTypes.AnyType type = new TypeMappers().toNeo4jType( javaClass ); // Then - assertEquals( neoType, mapper.type() ); + assertEquals( neoType, type ); } @Test public void shouldMapCorrectly() throws Throwable { // Given - NeoValueConverter mapper = new TypeMappers().converterFor( javaClass ); + TypeChecker mapper = new TypeMappers().checkerFor( javaClass ); // When - Object converted = mapper.toNeoValue( javaValue ); + Object converted = mapper.typeCheck( javaValue ); // Then Assert.assertEquals( expectedNeoValue, converted );