HSEARCH-5021 Make dimension "optional" in IndexFieldTypeFactory

marko-bekhta · yrodiere · commit b08e96e22e4d · 2023-12-21T16:39:40.000+01:00
diff --git a/backend/elasticsearch/src/main/java/org/hibernate/search/backend/elasticsearch/types/dsl/impl/ElasticsearchIndexFieldTypeFactoryImpl.java b/backend/elasticsearch/src/main/java/org/hibernate/search/backend/elasticsearch/types/dsl/impl/ElasticsearchIndexFieldTypeFactoryImpl.java
@@ -236,17 +236,17 @@ public ScaledNumberIndexFieldTypeOptionsStep<?, BigInteger> asBigInteger() {
 	}
 
 	@Override
-	public <F> VectorFieldTypeOptionsStep<?, F> asVector(int dimension, Class<F> valueType) {
+	public <F> VectorFieldTypeOptionsStep<?, F> asVector(Class<F> valueType) {
 		throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );
 	}
 
 	@Override
-	public VectorFieldTypeOptionsStep<?, byte[]> asByteVector(int dimension) {
+	public VectorFieldTypeOptionsStep<?, byte[]> asByteVector() {
 		throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );
 	}
 
 	@Override
-	public VectorFieldTypeOptionsStep<?, float[]> asFloatVector(int dimension) {
+	public VectorFieldTypeOptionsStep<?, float[]> asFloatVector() {
 		throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );
 	}
 
diff --git a/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/logging/impl/Log.java b/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/logging/impl/Log.java
@@ -727,4 +727,8 @@ SearchException vectorKnnMatchVectorTypeDiffersFromField(String absoluteFieldPat
 			+ " Matching against an array with length of '%3$s' is unsupported."
 			+ " Use the array of the same size as the vector field.")
 	SearchException vectorKnnMatchVectorDimensionDiffersFromField(String absoluteFieldPath, int expected, int actual);
+
+	@Message(id = ID_OFFSET + 179, value = "Invalid index field type: missing vector dimension."
+			+ " Define the vector dimension explicitly. %1$s")
+	SearchException nullVectorDimension(String hint, @Param EventContext eventContext);
 }
diff --git a/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/AbstractLuceneVectorFieldTypeOptionsStep.java b/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/AbstractLuceneVectorFieldTypeOptionsStep.java
@@ -43,19 +43,15 @@ abstract class AbstractLuceneVectorFieldTypeOptionsStep<S extends AbstractLucene
 	private static final int MAX_MAX_CONNECTIONS = 512;
 
 	protected VectorSimilarity vectorSimilarity = VectorSimilarity.DEFAULT;
-	protected final int dimension;
+	protected Integer dimension;
 	protected int beamWidth = MAX_MAX_CONNECTIONS;
 	protected int maxConnections = 16;
 	private Projectable projectable = Projectable.DEFAULT;
 	private Searchable searchable = Searchable.DEFAULT;
 	private F indexNullAsValue = null;
 
-	AbstractLuceneVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext, Class<F> valueType, int dimension) {
+	AbstractLuceneVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext, Class<F> valueType) {
 		super( buildContext, valueType );
-		if ( dimension < 1 || dimension > DEFAULT_MAX_DIMENSIONS ) {
-			throw log.vectorPropertyUnsupportedValue( "dimension", dimension, DEFAULT_MAX_DIMENSIONS );
-		}
-		this.dimension = dimension;
 	}
 
 	@Override
@@ -94,6 +90,15 @@ public S maxConnections(int maxConnections) {
 		return thisAsS();
 	}
 
+	@Override
+	public S dimension(int dimension) {
+		if ( dimension < 1 || dimension > DEFAULT_MAX_DIMENSIONS ) {
+			throw log.vectorPropertyUnsupportedValue( "dimension", dimension, DEFAULT_MAX_DIMENSIONS );
+		}
+		this.dimension = dimension;
+		return thisAsS();
+	}
+
 	@Override
 	public S indexNullAs(F indexNullAsValue) {
 		this.indexNullAsValue = indexNullAsValue;
@@ -102,6 +107,9 @@ public S indexNullAs(F indexNullAsValue) {
 
 	@Override
 	public LuceneIndexValueFieldType<F> toIndexFieldType() {
+		if ( dimension == null ) {
+			throw log.nullVectorDimension( buildContext.hints().missingVectorDimension(), buildContext.getEventContext() );
+		}
 		VectorSimilarityFunction resolvedVectorSimilarity = resolveDefault( vectorSimilarity );
 		boolean resolvedProjectable = resolveDefault( projectable );
 		boolean resolvedSearchable = resolveDefault( searchable );
diff --git a/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneByteVectorFieldTypeOptionsStep.java b/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneByteVectorFieldTypeOptionsStep.java
@@ -17,8 +17,8 @@
 class LuceneByteVectorFieldTypeOptionsStep
 		extends AbstractLuceneVectorFieldTypeOptionsStep<LuceneByteVectorFieldTypeOptionsStep, byte[]> {
 
-	LuceneByteVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext, int dimension) {
-		super( buildContext, byte[].class, dimension );
+	LuceneByteVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext) {
+		super( buildContext, byte[].class );
 	}
 
 	@Override
diff --git a/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneFloatVectorFieldTypeOptionsStep.java b/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneFloatVectorFieldTypeOptionsStep.java
@@ -17,8 +17,8 @@
 class LuceneFloatVectorFieldTypeOptionsStep
 		extends AbstractLuceneVectorFieldTypeOptionsStep<LuceneFloatVectorFieldTypeOptionsStep, float[]> {
 
-	LuceneFloatVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext, int dimension) {
-		super( buildContext, float[].class, dimension );
+	LuceneFloatVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext) {
+		super( buildContext, float[].class );
 	}
 
 	@Override
diff --git a/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneIndexFieldTypeFactoryImpl.java b/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/types/dsl/impl/LuceneIndexFieldTypeFactoryImpl.java
@@ -128,12 +128,12 @@ else if ( BigInteger.class.equals( valueType ) ) {
 	}
 
 	@SuppressWarnings("unchecked")
-	public <F> VectorFieldTypeOptionsStep<?, F> asVector(int dimension, Class<F> valueType) {
+	public <F> VectorFieldTypeOptionsStep<?, F> asVector(Class<F> valueType) {
 		if ( byte[].class.equals( valueType ) ) {
-			return (VectorFieldTypeOptionsStep<?, F>) asByteVector( dimension );
+			return (VectorFieldTypeOptionsStep<?, F>) asByteVector();
 		}
 		else if ( float[].class.equals( valueType ) ) {
-			return (VectorFieldTypeOptionsStep<?, F>) asFloatVector( dimension );
+			return (VectorFieldTypeOptionsStep<?, F>) asFloatVector();
 		}
 		else {
 			throw log.cannotGuessVectorFieldType( valueType, getEventContext() );
@@ -246,13 +246,13 @@ public ScaledNumberIndexFieldTypeOptionsStep<?, BigInteger> asBigInteger() {
 	}
 
 	@Override
-	public VectorFieldTypeOptionsStep<?, byte[]> asByteVector(int dimension) {
-		return new LuceneByteVectorFieldTypeOptionsStep( this, dimension );
+	public VectorFieldTypeOptionsStep<?, byte[]> asByteVector() {
+		return new LuceneByteVectorFieldTypeOptionsStep( this );
 	}
 
 	@Override
-	public VectorFieldTypeOptionsStep<?, float[]> asFloatVector(int dimension) {
-		return new LuceneFloatVectorFieldTypeOptionsStep( this, dimension );
+	public VectorFieldTypeOptionsStep<?, float[]> asFloatVector() {
+		return new LuceneFloatVectorFieldTypeOptionsStep( this );
 	}
 
 	@Override
diff --git a/engine/src/main/java/org/hibernate/search/engine/backend/reporting/spi/BackendMappingHints.java b/engine/src/main/java/org/hibernate/search/engine/backend/reporting/spi/BackendMappingHints.java
@@ -23,4 +23,7 @@ public interface BackendMappingHints {
 	@Message("")
 	String missingDecimalScale();
 
+	@Message("")
+	String missingVectorDimension();
+
 }
diff --git a/engine/src/main/java/org/hibernate/search/engine/backend/types/dsl/IndexFieldTypeFactory.java b/engine/src/main/java/org/hibernate/search/engine/backend/types/dsl/IndexFieldTypeFactory.java
@@ -44,15 +44,15 @@ public interface IndexFieldTypeFactory {
 	/**
 	 * Define a vector field type whose values are represented as a given type in Hibernate Search.
 	 * <p>
-	 * When possible, prefer the other methods such as {@link #asByteVector(int)} or {@link #asFloatVector(int)}
+	 * When possible, prefer the other methods such as {@link #asByteVector()} or {@link #asFloatVector()}
 	 * to avoid unnecessary type checks.
 	 *
 	 * @param <F> The type of values for this field type.
-	 * @param dimension The number of dimensions (array length) of vectors to be indexed.
 	 * @param valueType The type of values for this field type. Should be an array type like {@code byte[]} or {@code float[]}.
 	 * @return A DSL step where the index vector field type can be defined in more details.
 	 */
-	<F> VectorFieldTypeOptionsStep<?, F> asVector(int dimension, Class<F> valueType);
+	@Incubating
+	<F> VectorFieldTypeOptionsStep<?, F> asVector(Class<F> valueType);
 
 	/**
 	 * Define a field type whose values are represented as a {@link String} in Hibernate Search.
@@ -180,26 +180,23 @@ public interface IndexFieldTypeFactory {
 	 */
 	ScaledNumberIndexFieldTypeOptionsStep<?, BigInteger> asBigInteger();
 
-
 	/**
 	 * Define a field type intended for use in vector search
 	 * and whose values are represented as a {@code byte[]} in Hibernate Search.
 	 *
-	 * @param dimension The number of dimensions (array length) of vectors to be indexed.
 	 * @return A DSL step where the index field type can be defined in more details.
 	 */
 	@Incubating
-	VectorFieldTypeOptionsStep<?, byte[]> asByteVector(int dimension);
+	VectorFieldTypeOptionsStep<?, byte[]> asByteVector();
 
 	/**
 	 * Define a field type intended for use in vector search
 	 * and whose values are represented as a {@code float[]} in Hibernate Search.
 	 *
-	 * @param dimension The number of dimensions (array length) of vectors to be indexed.
 	 * @return A DSL step where the index field type can be defined in more details.
 	 */
 	@Incubating
-	VectorFieldTypeOptionsStep<?, float[]> asFloatVector(int dimension);
+	VectorFieldTypeOptionsStep<?, float[]> asFloatVector();
 
 	/**
 	 * Extend the current factory with the given extension,
diff --git a/engine/src/main/java/org/hibernate/search/engine/backend/types/dsl/VectorFieldTypeOptionsStep.java b/engine/src/main/java/org/hibernate/search/engine/backend/types/dsl/VectorFieldTypeOptionsStep.java
@@ -37,4 +37,10 @@ public interface VectorFieldTypeOptionsStep<S extends VectorFieldTypeOptionsStep
 	 */
 	S maxConnections(int maxConnections);
 
+	/**
+	 * @param dimension The number of dimensions (array length) of vectors to be indexed.
+	 * @return {@code this}, for method chaining.
+	 */
+	S dimension(int dimension);
+
 }
diff --git a/integrationtest/backend/lucene/src/test/java/org/hibernate/search/integrationtest/backend/lucene/lowlevel/reader/LuceneIndexReaderCodecLoadingIT.java b/integrationtest/backend/lucene/src/test/java/org/hibernate/search/integrationtest/backend/lucene/lowlevel/reader/LuceneIndexReaderCodecLoadingIT.java
@@ -89,7 +89,7 @@ private static class IndexBinding {
 		final IndexFieldReference<byte[]> vectorField;
 
 		IndexBinding(IndexSchemaElement root) {
-			vectorField = root.field( "vector", c -> c.asByteVector( 2 ).maxConnections( 10 ) ).toReference();
+			vectorField = root.field( "vector", c -> c.asByteVector().dimension( 2 ).maxConnections( 10 ) ).toReference();
 		}
 	}
 }
diff --git a/integrationtest/backend/lucene/src/test/java/org/hibernate/search/integrationtest/backend/lucene/mapping/LuceneVectorFieldIT.java b/integrationtest/backend/lucene/src/test/java/org/hibernate/search/integrationtest/backend/lucene/mapping/LuceneVectorFieldIT.java
@@ -44,7 +44,7 @@ void test(int dimension, int beamWidth, int maxConnections, String property, int
 				.withIndex( SimpleMappedIndex
 						.of( root -> root
 								.field( "vector",
-										f -> f.asByteVector( dimension ).beamWidth( beamWidth )
+										f -> f.asByteVector().dimension( dimension ).beamWidth( beamWidth )
 												.maxConnections( maxConnections ) )
 								.toReference() ) )
 				.setup()
diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/predicate/KnnPredicateSpecificsIT.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/predicate/KnnPredicateSpecificsIT.java
@@ -718,7 +718,7 @@ private static class PredicateIndexBinding {
 			PredicateIndexBinding(IndexSchemaElement root) {
 				parking = root.field( "parking", f -> f.asBoolean().projectable( Projectable.YES ) ).toReference();
 				rating = root.field( "rating", f -> f.asInteger().projectable( Projectable.YES ) ).toReference();
-				location = root.field( "location", f -> f.asFloatVector( 2 ).projectable( Projectable.YES )
+				location = root.field( "location", f -> f.asFloatVector().dimension( 2 ).projectable( Projectable.YES )
 						.maxConnections( 16 ).beamWidth( 100 ).vectorSimilarity( VectorSimilarity.L2 ) ).toReference();
 			}
 		}
@@ -727,7 +727,7 @@ private static class MultiValuedIndexBinding {
 			final IndexFieldReference<byte[]> vector;
 
 			private MultiValuedIndexBinding(IndexSchemaElement root) {
-				vector = root.field( "vector", f -> f.asByteVector( 2 ) ).multiValued().toReference();
+				vector = root.field( "vector", f -> f.asByteVector().dimension( 2 ) ).multiValued().toReference();
 			}
 		}
 
@@ -742,10 +742,10 @@ private static class NestedIndexBinding {
 				nested = nestedField.toReference();
 
 				byteVector = nestedField.field(
-						"byteVector", f -> f.asByteVector( 2 ).projectable( Projectable.YES ) )
+						"byteVector", f -> f.asByteVector().dimension( 2 ).projectable( Projectable.YES ) )
 						.toReference();
 				floatVector = nestedField
-						.field( "floatVector", f -> f.asFloatVector( 2 ).projectable( Projectable.YES ) )
+						.field( "floatVector", f -> f.asFloatVector().dimension( 2 ).projectable( Projectable.YES ) )
 						.toReference();
 			}
 		}
diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/types/ByteVectorFieldTypeDescriptor.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/types/ByteVectorFieldTypeDescriptor.java
@@ -34,7 +34,7 @@ public VectorFieldTypeDescriptor<byte[]> withDimension(int dimension) {
 
 	@Override
 	public VectorFieldTypeOptionsStep<?, byte[]> configure(IndexFieldTypeFactory fieldContext) {
-		return fieldContext.asByteVector( size );
+		return fieldContext.asByteVector().dimension( size );
 	}
 
 	@Override
diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/types/FloatVectorFieldTypeDescriptor.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/types/FloatVectorFieldTypeDescriptor.java
@@ -34,7 +34,7 @@ public VectorFieldTypeDescriptor<float[]> withDimension(int dimension) {
 
 	@Override
 	public VectorFieldTypeOptionsStep<?, float[]> configure(IndexFieldTypeFactory fieldContext) {
-		return fieldContext.asFloatVector( size );
+		return fieldContext.asFloatVector().dimension( size );
 	}
 
 	@Override
diff --git a/integrationtest/mapper/pojo-base/src/test/java/org/hibernate/search/integrationtest/mapper/pojo/mapping/definition/VectorFieldIT.java b/integrationtest/mapper/pojo-base/src/test/java/org/hibernate/search/integrationtest/mapper/pojo/mapping/definition/VectorFieldIT.java
@@ -420,26 +420,6 @@ class IndexedEntity {
 								+ " or set the type parameter F to a definite, raw type." ) );
 	}
 
-	@Test
-	void customBridge_vectorDimensionUnknown() {
-		@Indexed(index = INDEX_NAME)
-		class IndexedEntity {
-			@DocumentId
-			Integer id;
-			@VectorField(valueBinder = @ValueBinderRef(type = ValidImplicitTypeBridge.ValidImplicitTypeBinder.class))
-			Collection<Float> floats;
-		}
-
-		assertThatThrownBy( () -> setupHelper.start().expectCustomBeans().setup( IndexedEntity.class ) )
-				.isInstanceOf( SearchException.class )
-				.satisfies( FailureReportUtils.hasFailureReport()
-						.typeContext( IndexedEntity.class.getName() )
-						.pathContext( ".floats" )
-						.failure( "Vector dimension is a required property. "
-								+ "Either specify it as an annotation property (@VectorField(dimension = somePositiveInteger)),"
-								+ " or define a value binder (@VectorField(valueBinder = @ValueBinderRef(..))) that explicitly declares a vector field specifying the dimension." ) );
-	}
-
 	@Test
 	void valueExtractorsEnabled() {
 		@Indexed(index = INDEX_NAME)
@@ -510,6 +490,24 @@ class IndexedEntity {
 								+ "e.g. @ContainerExtraction(extract = ContainerExtract.DEFAULT, value = { ... })." ) );
 	}
 
+	@Test
+	void customBridge_dimensionFromAnnotationTypeInBridge() {
+		@Indexed(index = INDEX_NAME)
+		class IndexedEntity {
+			@DocumentId
+			Integer id;
+			@VectorField(dimension = 3,
+					valueBinder = @ValueBinderRef(type = ListTypeBridgeDimensionFromAnnotation.ExplicitFieldTypeBinder.class))
+			List<Float> floats;
+		}
+
+		backendMock.expectSchema( INDEX_NAME, b -> b
+				.field( "floats", float[].class, f -> f.dimension( 3 ) )
+		);
+		setupHelper.start().expectCustomBeans().setup( IndexedEntity.class );
+		backendMock.verifyExpectationsMet();
+	}
+
 	@SuppressWarnings("rawtypes")
 	public static class ValidTypeBridge implements ValueBridge<List, byte[]> {
 		@Override
@@ -528,7 +526,31 @@ public byte[] toIndexedValue(List value, ValueBridgeToIndexedValueContext contex
 		public static class ExplicitFieldTypeBinder implements ValueBinder {
 			@Override
 			public void bind(ValueBindingContext<?> context) {
-				context.bridge( List.class, new ValidTypeBridge(), context.typeFactory().asByteVector( 2 ) );
+				context.bridge( List.class, new ValidTypeBridge(), context.typeFactory().asByteVector().dimension( 2 ) );
+			}
+		}
+	}
+
+	@SuppressWarnings("rawtypes")
+	public static class ListTypeBridgeDimensionFromAnnotation implements ValueBridge<List, float[]> {
+		@Override
+		public float[] toIndexedValue(List value, ValueBridgeToIndexedValueContext context) {
+			if ( value == null ) {
+				return null;
+			}
+			float[] floats = new float[value.size()];
+			int index = 0;
+			for ( Object o : value ) {
+				floats[index++] = Byte.parseByte( Objects.toString( o, null ) );
+			}
+			return floats;
+		}
+
+		public static class ExplicitFieldTypeBinder implements ValueBinder {
+			@Override
+			public void bind(ValueBindingContext<?> context) {
+				context.bridge( List.class, new ListTypeBridgeDimensionFromAnnotation(),
+						context.typeFactory().asFloatVector() );
 			}
 		}
 	}
@@ -553,7 +575,7 @@ public static class ParametricBinder implements ValueBinder {
 			@Override
 			public void bind(ValueBindingContext<?> context) {
 				context.bridge( List.class, new ParametricBridge(),
-						context.typeFactory().asFloatVector( extractDimension( context ) )
+						context.typeFactory().asFloatVector().dimension( extractDimension( context ) )
 				);
 			}
 		}
diff --git a/integrationtest/mapper/pojo-standalone-realbackend/pom.xml b/integrationtest/mapper/pojo-standalone-realbackend/pom.xml
@@ -88,6 +88,8 @@
                             </systemPropertyVariables>
                             <excludes>
                                 <exclude>org.hibernate.search.integrationtest.mapper.pojo.standalone.realbackend.schema.management.LuceneSchemaManagerExporterIT</exclude>
+                                <!-- Include once HSEARCH-4950 is implemented -->
+                                <exclude>org.hibernate.search.integrationtest.mapper.pojo.standalone.realbackend.mapping.VectorFieldIT</exclude>
                             </excludes>
                         </configuration>
                     </execution>
diff --git a/integrationtest/mapper/pojo-standalone-realbackend/src/test/java/org/hibernate/search/integrationtest/mapper/pojo/standalone/realbackend/mapping/VectorFieldIT.java b/integrationtest/mapper/pojo-standalone-realbackend/src/test/java/org/hibernate/search/integrationtest/mapper/pojo/standalone/realbackend/mapping/VectorFieldIT.java
diff --git a/mapper/orm/src/main/java/org/hibernate/search/mapper/orm/reporting/impl/HibernateOrmMappingHints.java b/mapper/orm/src/main/java/org/hibernate/search/mapper/orm/reporting/impl/HibernateOrmMappingHints.java
diff --git a/mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/mapping/definition/programmatic/impl/PropertyMappingVectorFieldOptionsStepImpl.java b/mapper/pojo-base/src/main/java/org/hibernate/search/mapper/pojo/mapping/definition/programmatic/impl/PropertyMappingVectorFieldOptionsStepImpl.java
diff --git a/mapper/pojo-standalone/src/main/java/org/hibernate/search/mapper/pojo/standalone/reporting/impl/StandalonePojoMappingHints.java b/mapper/pojo-standalone/src/main/java/org/hibernate/search/mapper/pojo/standalone/reporting/impl/StandalonePojoMappingHints.java
diff --git a/util/internal/integrationtest/common/src/main/java/org/hibernate/search/util/impl/integrationtest/common/stub/backend/types/dsl/impl/StubIndexFieldTypeFactory.java b/util/internal/integrationtest/common/src/main/java/org/hibernate/search/util/impl/integrationtest/common/stub/backend/types/dsl/impl/StubIndexFieldTypeFactory.java
diff --git a/util/internal/integrationtest/common/src/main/java/org/hibernate/search/util/impl/integrationtest/common/stub/backend/types/dsl/impl/StubVectorFieldTypeOptionsStep.java b/util/internal/integrationtest/common/src/main/java/org/hibernate/search/util/impl/integrationtest/common/stub/backend/types/dsl/impl/StubVectorFieldTypeOptionsStep.java
diff --git a/util/internal/integrationtest/mapper/stub/src/main/java/org/hibernate/search/util/impl/integrationtest/mapper/stub/StubMappingHints.java b/util/internal/integrationtest/mapper/stub/src/main/java/org/hibernate/search/util/impl/integrationtest/mapper/stub/StubMappingHints.java

Original file line number	Diff line number	Diff line change
`@@ -236,17 +236,17 @@ public ScaledNumberIndexFieldTypeOptionsStep<?, BigInteger> asBigInteger() {`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`@Override`
`239`		`- public <F> VectorFieldTypeOptionsStep<?, F> asVector(int dimension, Class<F> valueType) {`
	`239`	`+ public <F> VectorFieldTypeOptionsStep<?, F> asVector(Class<F> valueType) {`
`240`	`240`	`throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`@Override`
`244`		`- public VectorFieldTypeOptionsStep<?, byte[]> asByteVector(int dimension) {`
	`244`	`+ public VectorFieldTypeOptionsStep<?, byte[]> asByteVector() {`
`245`	`245`	`throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`@Override`
`249`		`- public VectorFieldTypeOptionsStep<?, float[]> asFloatVector(int dimension) {`
	`249`	`+ public VectorFieldTypeOptionsStep<?, float[]> asFloatVector() {`
`250`	`250`	`throw new UnsupportedOperationException( "The Elasticsearch backend does not support vector field yet." );`
`251`	`251`	`}`
`252`	`252`
Original file line number	Diff line number	Diff line change
`@@ -727,4 +727,8 @@ SearchException vectorKnnMatchVectorTypeDiffersFromField(String absoluteFieldPat`
`727`	`727`	`+ " Matching against an array with length of '%3$s' is unsupported."`
`728`	`728`	`+ " Use the array of the same size as the vector field.")`
`729`	`729`	`SearchException vectorKnnMatchVectorDimensionDiffersFromField(String absoluteFieldPath, int expected, int actual);`
	`730`	`+`
	`731`	`+ @Message(id = ID_OFFSET + 179, value = "Invalid index field type: missing vector dimension."`
	`732`	`+ + " Define the vector dimension explicitly. %1$s")`
	`733`	`+ SearchException nullVectorDimension(String hint, @Param EventContext eventContext);`
`730`	`734`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@`
`17`	`17`	`class LuceneByteVectorFieldTypeOptionsStep`
`18`	`18`	`extends AbstractLuceneVectorFieldTypeOptionsStep<LuceneByteVectorFieldTypeOptionsStep, byte[]> {`
`19`	`19`
`20`		`- LuceneByteVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext, int dimension) {`
`21`		`- super( buildContext, byte[].class, dimension );`
	`20`	`+ LuceneByteVectorFieldTypeOptionsStep(LuceneIndexFieldTypeBuildContext buildContext) {`
	`21`	`+ super( buildContext, byte[].class );`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -128,12 +128,12 @@ else if ( BigInteger.class.equals( valueType ) ) {`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`@SuppressWarnings("unchecked")`
`131`		`- public <F> VectorFieldTypeOptionsStep<?, F> asVector(int dimension, Class<F> valueType) {`
	`131`	`+ public <F> VectorFieldTypeOptionsStep<?, F> asVector(Class<F> valueType) {`
`132`	`132`	`if ( byte[].class.equals( valueType ) ) {`
`133`		`- return (VectorFieldTypeOptionsStep<?, F>) asByteVector( dimension );`
	`133`	`+ return (VectorFieldTypeOptionsStep<?, F>) asByteVector();`
`134`	`134`	`}`
`135`	`135`	`else if ( float[].class.equals( valueType ) ) {`
`136`		`- return (VectorFieldTypeOptionsStep<?, F>) asFloatVector( dimension );`
	`136`	`+ return (VectorFieldTypeOptionsStep<?, F>) asFloatVector();`
`137`	`137`	`}`
`138`	`138`	`else {`
`139`	`139`	`throw log.cannotGuessVectorFieldType( valueType, getEventContext() );`
`@@ -246,13 +246,13 @@ public ScaledNumberIndexFieldTypeOptionsStep<?, BigInteger> asBigInteger() {`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`@Override`
`249`		`- public VectorFieldTypeOptionsStep<?, byte[]> asByteVector(int dimension) {`
`250`		`- return new LuceneByteVectorFieldTypeOptionsStep( this, dimension );`
	`249`	`+ public VectorFieldTypeOptionsStep<?, byte[]> asByteVector() {`
	`250`	`+ return new LuceneByteVectorFieldTypeOptionsStep( this );`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`@Override`
`254`		`- public VectorFieldTypeOptionsStep<?, float[]> asFloatVector(int dimension) {`
`255`		`- return new LuceneFloatVectorFieldTypeOptionsStep( this, dimension );`
	`254`	`+ public VectorFieldTypeOptionsStep<?, float[]> asFloatVector() {`
	`255`	`+ return new LuceneFloatVectorFieldTypeOptionsStep( this );`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,7 @@ public interface BackendMappingHints {`
`23`	`23`	`@Message("")`
`24`	`24`	`String missingDecimalScale();`
`25`	`25`
	`26`	`+ @Message("")`
	`27`	`+ String missingVectorDimension();`
	`28`	`+`
`26`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ private static class IndexBinding {`
`89`	`89`	`final IndexFieldReference<byte[]> vectorField;`
`90`	`90`
`91`	`91`	`IndexBinding(IndexSchemaElement root) {`
`92`		`- vectorField = root.field( "vector", c -> c.asByteVector( 2 ).maxConnections( 10 ) ).toReference();`
	`92`	`+ vectorField = root.field( "vector", c -> c.asByteVector().dimension( 2 ).maxConnections( 10 ) ).toReference();`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`