From 51a3e98c749cb2fe180477f2452c376dccbcd237 Mon Sep 17 00:00:00 2001 From: Jack Conradson Date: Mon, 18 Mar 2024 15:14:42 -0700 Subject: [PATCH] clean up tests --- .../index/mapper/BooleanFieldMapper.java | 5 +- .../index/mapper/MappedFieldType.java | 5 +- .../index/mapper/MapperRegistry.java | 4 +- .../wildcard/mapper/TermsQueryTests.java | 67 ++++++++++++++++--- 4 files changed, 69 insertions(+), 12 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java index 39f0cd5278bd5..568136b26bcca 100644 --- a/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java +++ b/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java @@ -318,8 +318,11 @@ public Query termsQuery(Collection values, SearchExecutionContext context) { if (isIndexed()) { return super.termsQuery(values, context); } else { - BooleanQuery.Builder builder = new BooleanQuery.Builder(); Set dedupe = new HashSet<>(values); + if (dedupe.size() == 1) { + return new ConstantScoreQuery(termQuery(dedupe.iterator().next(), context)); + } + BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (Object value : dedupe) { builder.add(termQuery(value, context), BooleanClause.Occur.SHOULD); } diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java index 69fc4108fde17..73e4be67c2468 100644 --- a/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java +++ b/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java @@ -235,8 +235,11 @@ public Query termQueryCaseInsensitive(Object value, @Nullable SearchExecutionCon * {@link ConstantScoreQuery} around a {@link BooleanQuery} whose {@link Occur#SHOULD} clauses * are generated with {@link #termQuery}. */ public Query termsQuery(Collection values, @Nullable SearchExecutionContext context) { - BooleanQuery.Builder builder = new BooleanQuery.Builder(); Set dedupe = new HashSet<>(values); + if (dedupe.size() == 1) { + return new ConstantScoreQuery(termQuery(dedupe.iterator().next(), context)); + } + BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (Object value : dedupe) { builder.add(termQuery(value, context), Occur.SHOULD); } diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java b/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java index c57ee06bdc250..dcf24c9a61bbd 100644 --- a/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java +++ b/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java @@ -23,7 +23,7 @@ */ public final class MapperRegistry { - public final Map mapperParsers; + private final Map mapperParsers; private final Map runtimeFieldParsers; private final Map metadataMapperParsers; private final Map metadataMapperParsers7x; @@ -37,7 +37,7 @@ public MapperRegistry( Map metadataMapperParsers, Function> fieldFilter ) { - this.mapperParsers = new LinkedHashMap<>(mapperParsers); + this.mapperParsers = Collections.unmodifiableMap(new LinkedHashMap<>(mapperParsers)); this.runtimeFieldParsers = runtimeFieldParsers; this.metadataMapperParsers = Collections.unmodifiableMap(new LinkedHashMap<>(metadataMapperParsers)); Map metadata7x = new LinkedHashMap<>(metadataMapperParsers); diff --git a/x-pack/plugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java b/x-pack/plugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java index ec43faf2f3d83..c4093c6ebca1d 100644 --- a/x-pack/plugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java +++ b/x-pack/plugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java @@ -7,29 +7,34 @@ package org.elasticsearch.xpack.wildcard.mapper; +import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.Query; import org.elasticsearch.common.compress.CompressedXContent; import org.elasticsearch.index.mapper.MapperService; +import org.elasticsearch.index.query.BoolQueryBuilder; +import org.elasticsearch.index.query.QueryBuilder; import org.elasticsearch.index.query.TermsQueryBuilder; +import org.elasticsearch.index.query.WildcardQueryBuilder; +import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.AbstractBuilderTestCase; +import org.elasticsearch.xpack.wildcard.Wildcard; import java.io.IOException; +import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; public class TermsQueryTests extends AbstractBuilderTestCase { - public void testDuplicateTerms() throws IOException { - String[] duplicates = new String[1023]; - Arrays.fill(duplicates, "duplicate"); - TermsQueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates); - termsQueryBuilder.rewrite(createQueryRewriteContext()); - Query query = termsQueryBuilder.toQuery(createSearchExecutionContext()); - query.toString(); + protected Collection> getPlugins() { + return List.of(Wildcard.class); } @Override protected void initializeAdditionalMappings(MapperService mapperService) throws IOException { - mapperService.getMapperRegistry().mapperParsers.put("wildcard", WildcardFieldMapper.PARSER); mapperService.merge("_doc", new CompressedXContent(org.elasticsearch.common.Strings.format(""" { "properties": { @@ -39,4 +44,50 @@ protected void initializeAdditionalMappings(MapperService mapperService) throws } }""")), MapperService.MergeReason.MAPPING_UPDATE); } + + public void testSingleDuplicateTerms() throws IOException { + String[] duplicates = new String[1023]; + Arrays.fill(duplicates, "duplicate"); + QueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates); + termsQueryBuilder = termsQueryBuilder.rewrite(createQueryRewriteContext()); + Query actual = termsQueryBuilder.toQuery(createSearchExecutionContext()); + + QueryBuilder wildcardQueryBuilder = new WildcardQueryBuilder("mapped_wildcard", "duplicate"); + wildcardQueryBuilder = wildcardQueryBuilder.rewrite(createQueryRewriteContext()); + Query expected = new ConstantScoreQuery(wildcardQueryBuilder.toQuery(createSearchExecutionContext())); + + assertEquals(expected, actual); + } + + public void testMultiDuplicateTerms() throws IOException { + int numTerms = randomIntBetween(2, 10); + List randomTerms = new ArrayList<>(numTerms); + for (int i = 0; i < numTerms; ++i) { + randomTerms.add(randomAlphaOfLengthBetween(1, 1024)); + } + int totalTerms = randomIntBetween(numTerms * 5, 1023); + String[] duplicates = new String[totalTerms]; + for (int i = 0; i < numTerms; ++i) { + duplicates[i] = randomTerms.get(i); + } + for (int i = numTerms; i < totalTerms; ++i) { + duplicates[i] = randomTerms.get(randomIntBetween(0, numTerms - 1)); + } + + QueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates); + termsQueryBuilder = termsQueryBuilder.rewrite(createQueryRewriteContext()); + Query actual = termsQueryBuilder.toQuery(createSearchExecutionContext()); + + Set ordered = new HashSet<>(randomTerms); + BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder(); + for (String randomTerm : ordered) { + QueryBuilder wildcardQueryBuilder = new WildcardQueryBuilder("mapped_wildcard", randomTerm); + wildcardQueryBuilder = wildcardQueryBuilder.rewrite(createQueryRewriteContext()); + boolQueryBuilder.should(wildcardQueryBuilder); + } + QueryBuilder expectedQueryBuilder = boolQueryBuilder.rewrite(createQueryRewriteContext()); + Query expected = new ConstantScoreQuery(expectedQueryBuilder.toQuery(createSearchExecutionContext())); + + assertEquals(expected, actual); + } }