diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortBaseIT.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortBaseIT.java index 9e7577c659b..31c070df628 100644 --- a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortBaseIT.java +++ b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortBaseIT.java @@ -11,16 +11,14 @@ import java.util.ArrayList; import java.util.Arrays; -import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; -import java.util.Map; import java.util.function.Consumer; import java.util.function.Function; +import java.util.stream.Stream; import org.hibernate.search.engine.backend.common.DocumentReference; import org.hibernate.search.engine.backend.document.DocumentElement; -import org.hibernate.search.engine.backend.document.IndexFieldReference; import org.hibernate.search.engine.backend.document.IndexObjectFieldReference; import org.hibernate.search.engine.backend.document.model.dsl.IndexSchemaElement; import org.hibernate.search.engine.backend.document.model.dsl.IndexSchemaObjectField; @@ -35,7 +33,8 @@ import org.hibernate.search.integrationtest.backend.tck.testsupport.types.NormalizedStringFieldTypeDescriptor; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.ExpectationsAlternative; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.IndexFieldStructure; -import org.hibernate.search.integrationtest.backend.tck.testsupport.util.StandardFieldMapper; +import org.hibernate.search.integrationtest.backend.tck.testsupport.util.SimpleFieldModel; +import org.hibernate.search.integrationtest.backend.tck.testsupport.util.SimpleFieldModelsByType; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.TckConfiguration; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.rule.SearchSetupHelper; import org.hibernate.search.util.impl.integrationtest.mapper.stub.StubMappingIndexManager; @@ -54,17 +53,22 @@ @RunWith(Parameterized.class) public class FieldSearchSortBaseIT { + private static Stream> supportedTypeDescriptors() { + return FieldTypeDescriptor.getAll().stream() + .filter( typeDescriptor -> typeDescriptor.getFieldSortExpectations().isSupported() ); + } + @Parameterized.Parameters(name = "{0} - {1}") public static Object[][] parameters() { List parameters = new ArrayList<>(); - for ( FieldTypeDescriptor fieldTypeDescriptor : FieldTypeDescriptor.getAll() ) { + supportedTypeDescriptors().forEach( fieldTypeDescriptor -> { ExpectationsAlternative expectations = fieldTypeDescriptor.getFieldSortExpectations(); if ( expectations.isSupported() ) { for ( IndexFieldStructure indexFieldStructure : IndexFieldStructure.values() ) { parameters.add( new Object[] { indexFieldStructure, fieldTypeDescriptor } ); } } - } + } ); return parameters.toArray( new Object[0][] ); } @@ -321,20 +325,24 @@ private String getFieldPath() { } private static void initDocument(IndexMapping indexMapping, DocumentElement document, Integer ordinal) { - forEachSupportedTypeDescriptor( typeDescriptor -> { - addValue( document, indexMapping.fieldModels, typeDescriptor, ordinal ); - } ); + indexMapping.fieldModels.forEach( + fieldModel -> addValue( fieldModel, document, ordinal ) + ); // Note: these objects must be single-valued for these tests DocumentElement flattenedObject = document.addObject( indexMapping.flattenedObject.self ); DocumentElement nestedObject = document.addObject( indexMapping.nestedObject.self ); DocumentElement nestedObjectInNestedObject = nestedObject.addObject( indexMapping.nestedObject.nestedObject.self ); - forEachSupportedTypeDescriptor( typeDescriptor -> { - addValue( flattenedObject, indexMapping.flattenedObject.fieldModels, typeDescriptor, ordinal ); - addValue( nestedObject, indexMapping.nestedObject.fieldModels, typeDescriptor, ordinal ); - addValue( nestedObjectInNestedObject, indexMapping.nestedObject.nestedObject.fieldModels, typeDescriptor, ordinal ); - } ); + indexMapping.flattenedObject.fieldModels.forEach( + fieldModel -> addValue( fieldModel, flattenedObject, ordinal ) + ); + indexMapping.nestedObject.fieldModels.forEach( + fieldModel -> addValue( fieldModel, nestedObject, ordinal ) + ); + indexMapping.nestedObject.nestedObject.fieldModels.forEach( + fieldModel -> addValue( fieldModel, nestedObjectInNestedObject, ordinal ) + ); } @SuppressWarnings("unchecked") @@ -351,14 +359,13 @@ private F getSingleValueForMissingUse(int ordinal) { return value; } - private static void addValue(DocumentElement documentElement, - FieldModelsByType fieldModels, FieldTypeDescriptor typeDescriptor, Integer ordinal) { + private static void addValue(SimpleFieldModel fieldModel, DocumentElement documentElement, Integer ordinal) { if ( ordinal == null ) { return; } documentElement.addValue( - fieldModels.get( typeDescriptor ).reference, - typeDescriptor.getAscendingUniqueTermValues().get( ordinal ) + fieldModel.reference, + fieldModel.typeDescriptor.getAscendingUniqueTermValues().get( ordinal ) ); } @@ -389,18 +396,13 @@ private static void initData() { .hasDocRefHitsAnyOrder( INDEX_NAME, DOCUMENT_1, DOCUMENT_2, DOCUMENT_3, EMPTY_1, EMPTY_2, EMPTY_3, EMPTY_4 ); } - private static void forEachSupportedTypeDescriptor(Consumer> action) { - FieldTypeDescriptor.getAll().stream() - .filter( typeDescriptor -> typeDescriptor.getFieldSortExpectations().isSupported() ) - .forEach( action ); - } - private static class AbstractObjectMapping { - final FieldModelsByType fieldModels; + final SimpleFieldModelsByType fieldModels; AbstractObjectMapping(IndexSchemaElement self, Consumer> additionalConfiguration) { - fieldModels = FieldModelsByType.mapSupported( self, "", additionalConfiguration ); + fieldModels = SimpleFieldModelsByType.mapAll( supportedTypeDescriptors(), self, "", + c -> c.sortable( Sortable.YES ), additionalConfiguration ); } } @@ -466,44 +468,4 @@ private SecondLevelObjectMapping(String relativeFieldName, IndexSchemaObjectFiel } } - private static class FieldModelsByType { - public static FieldModelsByType mapSupported(IndexSchemaElement parent, String prefix, - Consumer> additionalConfiguration) { - FieldModelsByType result = new FieldModelsByType(); - forEachSupportedTypeDescriptor( typeDescriptor -> { - result.content.put( - typeDescriptor, - FieldModel.mapper( typeDescriptor ) - .map( parent, prefix + typeDescriptor.getUniqueName(), additionalConfiguration ) - ); - } ); - return result; - } - - private final Map, FieldModel> content = new LinkedHashMap<>(); - - @SuppressWarnings("unchecked") - private FieldModel get(FieldTypeDescriptor typeDescriptor) { - return (FieldModel) content.get( typeDescriptor ); - } - } - - private static class FieldModel { - static StandardFieldMapper> mapper(FieldTypeDescriptor typeDescriptor) { - return StandardFieldMapper.of( - typeDescriptor::configure, - c -> c.sortable( Sortable.YES ), - FieldModel::new - ); - } - - final IndexFieldReference reference; - final String relativeFieldName; - - private FieldModel(IndexFieldReference reference, String relativeFieldName) { - this.reference = reference; - this.relativeFieldName = relativeFieldName; - } - } - } diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortTypeCheckingAndConversionIT.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortTypeCheckingAndConversionIT.java index ac31239b66f..1377bc2d1db 100644 --- a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortTypeCheckingAndConversionIT.java +++ b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortTypeCheckingAndConversionIT.java @@ -10,16 +10,14 @@ import static org.hibernate.search.util.impl.integrationtest.mapper.stub.StubMapperUtils.referenceProvider; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; -import java.util.Map; import java.util.function.Consumer; import java.util.function.Function; +import java.util.stream.Stream; import org.hibernate.search.engine.backend.common.DocumentReference; import org.hibernate.search.engine.backend.document.DocumentElement; -import org.hibernate.search.engine.backend.document.IndexFieldReference; import org.hibernate.search.engine.backend.document.model.dsl.IndexSchemaElement; import org.hibernate.search.engine.backend.types.Sortable; import org.hibernate.search.engine.backend.types.dsl.IndexFieldTypeFactory; @@ -34,6 +32,8 @@ import org.hibernate.search.integrationtest.backend.tck.testsupport.types.NormalizedStringFieldTypeDescriptor; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.ExpectationsAlternative; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.InvalidType; +import org.hibernate.search.integrationtest.backend.tck.testsupport.util.SimpleFieldModel; +import org.hibernate.search.integrationtest.backend.tck.testsupport.util.SimpleFieldModelsByType; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.StandardFieldMapper; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.TckConfiguration; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.ValueWrapper; @@ -57,15 +57,20 @@ @RunWith(Parameterized.class) public class FieldSearchSortTypeCheckingAndConversionIT { + private static Stream> supportedTypeDescriptors() { + return FieldTypeDescriptor.getAll().stream() + .filter( typeDescriptor -> typeDescriptor.getFieldSortExpectations().isSupported() ); + } + @Parameterized.Parameters(name = "{0} - {1}") public static Object[][] parameters() { List parameters = new ArrayList<>(); - for ( FieldTypeDescriptor fieldTypeDescriptor : FieldTypeDescriptor.getAll() ) { + supportedTypeDescriptors().forEach( fieldTypeDescriptor -> { ExpectationsAlternative expectations = fieldTypeDescriptor.getFieldSortExpectations(); if ( expectations.isSupported() ) { parameters.add( new Object[] { fieldTypeDescriptor } ); } - } + } ); return parameters.toArray( new Object[0][] ); } @@ -377,10 +382,8 @@ private String getNonSortableFieldPath() { } private static void initDocument(IndexMapping indexMapping, DocumentElement document, Integer ordinal) { - forEachSupportedTypeDescriptor( typeDescriptor -> { - addValue( document, indexMapping.fieldModels, typeDescriptor, ordinal ); - addValue( document, indexMapping.fieldWithDslConverterModels, typeDescriptor, ordinal ); - } ); + indexMapping.fieldModels.forEach( fieldModel -> addValue( fieldModel, document, ordinal ) ); + indexMapping.fieldWithDslConverterModels.forEach( fieldModel -> addValue( fieldModel, document, ordinal ) ); } @SuppressWarnings("unchecked") @@ -397,14 +400,13 @@ private F getSingleValueForMissingUse(int ordinal) { return value; } - private static void addValue(DocumentElement documentElement, - FieldModelsByType fieldModels, FieldTypeDescriptor typeDescriptor, Integer ordinal) { + private static void addValue(SimpleFieldModel fieldModel, DocumentElement documentElement, Integer ordinal) { if ( ordinal == null ) { return; } documentElement.addValue( - fieldModels.get( typeDescriptor ).reference, - typeDescriptor.getAscendingUniqueTermValues().get( ordinal ) + fieldModel.reference, + fieldModel.typeDescriptor.getAscendingUniqueTermValues().get( ordinal ) ); } @@ -447,16 +449,10 @@ private static void initData() { assertThat( query ).hasDocRefHitsAnyOrder( RAW_FIELD_COMPATIBLE_INDEX_NAME, RAW_FIELD_COMPATIBLE_INDEX_DOCUMENT_1 ); } - private static void forEachSupportedTypeDescriptor(Consumer> action) { - FieldTypeDescriptor.getAll().stream() - .filter( typeDescriptor -> typeDescriptor.getFieldSortExpectations().isSupported() ) - .forEach( action ); - } - private static class IndexMapping { - final FieldModelsByType fieldModels; - final FieldModelsByType fieldWithDslConverterModels; - final FieldModelsByType nonSortableFieldModels; + final SimpleFieldModelsByType fieldModels; + final SimpleFieldModelsByType fieldWithDslConverterModels; + final SimpleFieldModelsByType nonSortableFieldModels; IndexMapping(IndexSchemaElement root) { this( root, ignored -> { } ); @@ -464,15 +460,20 @@ private static class IndexMapping { IndexMapping(IndexSchemaElement root, Consumer> additionalConfiguration) { - fieldModels = FieldModelsByType.mapSupported( root, "", additionalConfiguration ); - fieldWithDslConverterModels = FieldModelsByType.mapSupported( - root, "converted_", + fieldModels = SimpleFieldModelsByType.mapAll( + supportedTypeDescriptors(), + root, "", c -> c.sortable( Sortable.YES ), additionalConfiguration + ); + fieldWithDslConverterModels = SimpleFieldModelsByType.mapAll( + supportedTypeDescriptors(), root, "converted_", + c -> c.sortable( Sortable.YES ), additionalConfiguration.andThen( c -> c.dslConverter( ValueWrapper.class, ValueWrapper.toIndexFieldConverter() ) ) ); - nonSortableFieldModels = FieldModelsByType.mapSupported( - root, "nonSortable_", + nonSortableFieldModels = SimpleFieldModelsByType.mapAll( + supportedTypeDescriptors(), root, "nonSortable_", + c -> c.sortable( Sortable.YES ), additionalConfiguration.andThen( c -> c.sortable( Sortable.NO ) ) ); } @@ -498,7 +499,7 @@ private static class IncompatibleIndexMapping { } private static void mapFieldsWithIncompatibleType(IndexSchemaElement parent) { - forEachSupportedTypeDescriptor( typeDescriptor -> { + supportedTypeDescriptors().forEach( typeDescriptor -> { StandardFieldMapper mapper; if ( Integer.class.equals( typeDescriptor.getJavaType() ) ) { mapper = IncompatibleFieldModel.mapper( context -> context.asLong() ); @@ -511,46 +512,6 @@ private static void mapFieldsWithIncompatibleType(IndexSchemaElement parent) { } } - private static class FieldModelsByType { - public static FieldModelsByType mapSupported(IndexSchemaElement parent, String prefix, - Consumer> additionalConfiguration) { - FieldModelsByType result = new FieldModelsByType(); - forEachSupportedTypeDescriptor( typeDescriptor -> { - result.content.put( - typeDescriptor, - FieldModel.mapper( typeDescriptor ) - .map( parent, prefix + typeDescriptor.getUniqueName(), additionalConfiguration ) - ); - } ); - return result; - } - - private final Map, FieldModel> content = new LinkedHashMap<>(); - - @SuppressWarnings("unchecked") - private FieldModel get(FieldTypeDescriptor typeDescriptor) { - return (FieldModel) content.get( typeDescriptor ); - } - } - - private static class FieldModel { - static StandardFieldMapper> mapper(FieldTypeDescriptor typeDescriptor) { - return StandardFieldMapper.of( - typeDescriptor::configure, - c -> c.sortable( Sortable.YES ), - FieldModel::new - ); - } - - final IndexFieldReference reference; - final String relativeFieldName; - - private FieldModel(IndexFieldReference reference, String relativeFieldName) { - this.reference = reference; - this.relativeFieldName = relativeFieldName; - } - } - private static class IncompatibleFieldModel { static StandardFieldMapper mapper( Function> configuration) { diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortUnsupportedTypesIT.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortUnsupportedTypesIT.java index 6630a0d39a8..b87014d319e 100644 --- a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortUnsupportedTypesIT.java +++ b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/search/sort/FieldSearchSortUnsupportedTypesIT.java @@ -7,18 +7,13 @@ package org.hibernate.search.integrationtest.backend.tck.search.sort; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; -import java.util.Map; -import java.util.function.Consumer; import java.util.stream.Stream; -import org.hibernate.search.engine.backend.document.IndexFieldReference; import org.hibernate.search.engine.backend.document.model.dsl.IndexSchemaElement; import org.hibernate.search.engine.backend.types.Sortable; -import org.hibernate.search.engine.backend.types.dsl.StandardIndexFieldTypeOptionsStep; import org.hibernate.search.integrationtest.backend.tck.testsupport.types.FieldTypeDescriptor; -import org.hibernate.search.integrationtest.backend.tck.testsupport.util.StandardFieldMapper; +import org.hibernate.search.integrationtest.backend.tck.testsupport.util.SimpleFieldModelsByType; import org.hibernate.search.integrationtest.backend.tck.testsupport.util.rule.SearchSetupHelper; import org.hibernate.search.util.common.SearchException; import org.hibernate.search.util.impl.integrationtest.mapper.stub.StubMappingIndexManager; @@ -97,53 +92,12 @@ private String getFieldPath() { } private static class IndexMapping { - final FieldModelsByType fieldModels; + final SimpleFieldModelsByType fieldModels; IndexMapping(IndexSchemaElement root) { - fieldModels = FieldModelsByType.mapUnsupported( root, "", ignored -> { } ); + fieldModels = SimpleFieldModelsByType.mapAll( unsupportedTypeDescriptors(), root, "", + c -> c.sortable( Sortable.NO ) ); } } - private static class FieldModelsByType { - public static FieldModelsByType mapUnsupported(IndexSchemaElement parent, String prefix, - Consumer> additionalConfiguration) { - FieldModelsByType result = new FieldModelsByType(); - unsupportedTypeDescriptors().forEach( typeDescriptor -> { - result.content.put( - typeDescriptor, - FieldModel.mapper( typeDescriptor ) - .map( parent, prefix + typeDescriptor.getUniqueName(), additionalConfiguration ) - ); - } ); - return result; - } - - private final Map, FieldModel> content = new LinkedHashMap<>(); - - @SuppressWarnings("unchecked") - private FieldModel get(FieldTypeDescriptor typeDescriptor) { - return (FieldModel) content.get( typeDescriptor ); - } - } - - private static class FieldModel { - static StandardFieldMapper> mapper(FieldTypeDescriptor typeDescriptor) { - return StandardFieldMapper.of( - typeDescriptor::configure, - c -> c.sortable( Sortable.NO ), - (reference, name) -> new FieldModel<>( reference, name, typeDescriptor.getJavaType() ) - ); - } - - final IndexFieldReference reference; - final String relativeFieldName; - final Class type; - - private FieldModel(IndexFieldReference reference, String relativeFieldName, - Class type) { - this.reference = reference; - this.relativeFieldName = relativeFieldName; - this.type = type; - } - } } diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModel.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModel.java new file mode 100644 index 00000000000..24b3991d58d --- /dev/null +++ b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModel.java @@ -0,0 +1,44 @@ +/* + * Hibernate Search, full-text search for your domain model + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later + * See the lgpl.txt file in the root directory or . + */ +package org.hibernate.search.integrationtest.backend.tck.testsupport.util; + +import java.util.function.Consumer; + +import org.hibernate.search.engine.backend.document.IndexFieldReference; +import org.hibernate.search.engine.backend.types.dsl.StandardIndexFieldTypeOptionsStep; +import org.hibernate.search.integrationtest.backend.tck.testsupport.types.FieldTypeDescriptor; + +public class SimpleFieldModel { + + public static StandardFieldMapper> mapper(FieldTypeDescriptor typeDescriptor, + Consumer> configurationAdjustment) { + return StandardFieldMapper.of( + typeDescriptor::configure, + configurationAdjustment, + (reference, relativeFieldName) -> new SimpleFieldModel<>( typeDescriptor, reference, relativeFieldName ) + ); + } + + public final FieldTypeDescriptor typeDescriptor; + public final String relativeFieldName; + public final IndexFieldReference reference; + + private SimpleFieldModel(FieldTypeDescriptor typeDescriptor, IndexFieldReference reference, + String relativeFieldName) { + this.typeDescriptor = typeDescriptor; + this.reference = reference; + this.relativeFieldName = relativeFieldName; + } + + @Override + public String toString() { + return "SimpleFieldModel[" + + "typeDescriptor=" + typeDescriptor + + ", relativeFieldName=" + relativeFieldName + + "]"; + } +} diff --git a/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModelsByType.java b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModelsByType.java new file mode 100644 index 00000000000..a7dc1bf953d --- /dev/null +++ b/integrationtest/backend/tck/src/main/java/org/hibernate/search/integrationtest/backend/tck/testsupport/util/SimpleFieldModelsByType.java @@ -0,0 +1,50 @@ +/* + * Hibernate Search, full-text search for your domain model + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later + * See the lgpl.txt file in the root directory or . + */ +package org.hibernate.search.integrationtest.backend.tck.testsupport.util; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.function.Consumer; +import java.util.stream.Stream; + +import org.hibernate.search.engine.backend.document.model.dsl.IndexSchemaElement; +import org.hibernate.search.engine.backend.types.dsl.StandardIndexFieldTypeOptionsStep; +import org.hibernate.search.integrationtest.backend.tck.testsupport.types.FieldTypeDescriptor; + +public class SimpleFieldModelsByType { + @SafeVarargs + public static SimpleFieldModelsByType mapAll(Stream> typeDescriptors, + IndexSchemaElement parent, String prefix, + Consumer> additionalConfiguration1, + Consumer> ... additionalConfiguration2) { + SimpleFieldModelsByType result = new SimpleFieldModelsByType(); + typeDescriptors.forEach( typeDescriptor -> { + result.content.put( + typeDescriptor, + SimpleFieldModel.mapper( typeDescriptor, additionalConfiguration1 ) + .map( parent, prefix + typeDescriptor.getUniqueName(), additionalConfiguration2 ) + ); + } ); + return result; + } + + private final Map, SimpleFieldModel> content = new LinkedHashMap<>(); + + @Override + public String toString() { + return "SimpleFieldModelsByType[" + content + "]"; + } + + @SuppressWarnings("unchecked") + public SimpleFieldModel get(FieldTypeDescriptor typeDescriptor) { + return (SimpleFieldModel) content.get( typeDescriptor ); + } + + public void forEach(Consumer> action) { + content.values().forEach( action ); + } +}