From 41980d80c348f71ecb8533614d108d010abf9057 Mon Sep 17 00:00:00 2001 From: Matt Hall Date: Tue, 23 Jul 2019 11:55:59 +0100 Subject: [PATCH 1/3] DATASOLR-153 - Added support for dismax queries. --- .../data/solr/core/DefaultQueryParser.java | 43 ++++- .../data/solr/core/QueryParserBase.java | 27 +++- .../data/solr/core/QueryParsers.java | 4 +- .../data/solr/core/SolrOperations.java | 27 +++- .../data/solr/core/SolrTemplate.java | 22 ++- .../query/AbstractDisMaxQueryDecorator.java | 30 ++++ .../data/solr/core/query/DisMaxOptions.java | 151 ++++++++++++++++++ .../data/solr/core/query/DisMaxQuery.java | 17 ++ .../solr/core/query/SimpleDisMaxQuery.java | 34 ++++ .../solr/core/DefaultQueryParserTests.java | 78 ++++++++- 10 files changed, 426 insertions(+), 7 deletions(-) create mode 100644 src/main/java/org/springframework/data/solr/core/query/AbstractDisMaxQueryDecorator.java create mode 100644 src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java create mode 100644 src/main/java/org/springframework/data/solr/core/query/DisMaxQuery.java create mode 100644 src/main/java/org/springframework/data/solr/core/query/SimpleDisMaxQuery.java diff --git a/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java b/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java index 219d5bbef..3a57594c3 100644 --- a/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java +++ b/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java @@ -15,11 +15,14 @@ */ package org.springframework.data.solr.core; +import static org.apache.solr.common.params.CommonParams.*; +import static org.apache.solr.common.params.DisMaxParams.*; +import static org.apache.solr.common.params.SimpleParams.QF; + import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map.Entry; - import org.apache.commons.lang3.StringUtils; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.SolrQuery.ORDER; @@ -36,7 +39,6 @@ import org.springframework.data.domain.Sort.Order; import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.solr.core.query.*; -import org.springframework.data.solr.core.query.Criteria.Predicate; import org.springframework.data.solr.core.query.FacetOptions.FacetParameter; import org.springframework.data.solr.core.query.FacetOptions.FieldWithDateRangeParameters; import org.springframework.data.solr.core.query.FacetOptions.FieldWithFacetParameters; @@ -65,6 +67,7 @@ * @author Joachim Uhrlaß * @author Petar Tahchiev * @author Juan Manuel de Blas + * @author Matthew Hall */ public class DefaultQueryParser extends QueryParserBase { @@ -109,6 +112,10 @@ public final SolrQuery doConstructSolrQuery(SolrDataQuery query, @Nullable Class processHighlightOptions(solrQuery, (HighlightQuery) query, domainType); } + if (query instanceof DisMaxQuery) { + processDisMaxOptions(solrQuery, (DisMaxQuery) query); + } + return solrQuery; } @@ -132,6 +139,38 @@ private void processQueryOptions(SolrQuery solrQuery, Query query, @Nullable Cla LOGGER.debug("Constructed SolrQuery:\r\n {}", solrQuery); } + protected void processDisMaxOptions(SolrQuery solrQuery, DisMaxQuery disMaxQuery) { + + if (disMaxQuery == null || disMaxQuery.getDisMaxOptions() == null) { + return; + } + + DisMaxOptions disMaxOptions = disMaxQuery.getDisMaxOptions(); + + solrQuery.set("defType", "dismax"); + + setSolrParamIfPresent(solrQuery, DF, disMaxOptions.getDefaultField()); + + setSolrParamIfPresent(solrQuery, ALTQ, disMaxOptions.getAltQuery()); + setSolrParamIfPresent(solrQuery, QF, disMaxOptions.getQueryFunction()); + setSolrParamIfPresent(solrQuery, MM, disMaxOptions.getMinimumMatch()); + + setSolrParamIfPresent(solrQuery, BQ, disMaxOptions.getBoostQuery()); + setSolrParamIfPresent(solrQuery, BF, disMaxOptions.getBoostFunction()); + setSolrParamIfPresent(solrQuery, PF, disMaxOptions.getPhraseFunction()); + + setSolrParamIfPresent(solrQuery, PS, disMaxOptions.getPhraseSlop() == null ? null : + String.valueOf(disMaxOptions.getPhraseSlop())); + setSolrParamIfPresent(solrQuery, QS, disMaxOptions.getQuerySlop() == null ? null : String.valueOf(disMaxOptions.getQuerySlop())); + setSolrParamIfPresent(solrQuery, TIE, disMaxOptions.getTie() == null ? null : String.valueOf(disMaxOptions.getTie())); + } + + private static void setSolrParamIfPresent(SolrQuery solrQuery, String param, String value) { + if (!org.springframework.util.StringUtils.isEmpty(value)) { + solrQuery.setParam(param, value); + } + } + private void processFacetOptions(SolrQuery solrQuery, FacetQuery query, @Nullable Class domainType) { if (enableFaceting(solrQuery, query)) { diff --git a/src/main/java/org/springframework/data/solr/core/QueryParserBase.java b/src/main/java/org/springframework/data/solr/core/QueryParserBase.java index 48766ade5..8b97314a4 100644 --- a/src/main/java/org/springframework/data/solr/core/QueryParserBase.java +++ b/src/main/java/org/springframework/data/solr/core/QueryParserBase.java @@ -25,7 +25,6 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; - import org.apache.commons.lang3.StringUtils; import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrQuery; @@ -62,6 +61,7 @@ * @author Radek Mensik * @author David Webb * @author Michael Rocke + * @author Matthew Hall */ public abstract class QueryParserBase implements QueryParser { @@ -1064,6 +1064,31 @@ public Map getNamesAssociation() { } } + /** + * @author Matthew Hall + * @since 4.1 + */ + static class NamedObjectsDisMaxQuery extends AbstractDisMaxQueryDecorator implements NamedObjects { + + private Map namesAssociation = new HashMap<>(); + + public NamedObjectsDisMaxQuery(DisMaxQuery query) { + super(query); + } + + @Override + public void setName(Object object, String name) { + setObjectName(namesAssociation, object, name); + } + + @Override + public Map getNamesAssociation() { + return Collections.unmodifiableMap(namesAssociation); + } + + } + + /** * Create new new {@link Context} for rendering {@link Function functions}. * diff --git a/src/main/java/org/springframework/data/solr/core/QueryParsers.java b/src/main/java/org/springframework/data/solr/core/QueryParsers.java index d3f6e73be..ee5465bb2 100644 --- a/src/main/java/org/springframework/data/solr/core/QueryParsers.java +++ b/src/main/java/org/springframework/data/solr/core/QueryParsers.java @@ -19,11 +19,11 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; - import org.apache.solr.client.solrj.SolrQuery; import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.solr.core.mapping.SolrPersistentEntity; import org.springframework.data.solr.core.mapping.SolrPersistentProperty; +import org.springframework.data.solr.core.query.DisMaxQuery; import org.springframework.data.solr.core.query.FacetQuery; import org.springframework.data.solr.core.query.HighlightQuery; import org.springframework.data.solr.core.query.Query; @@ -35,6 +35,7 @@ /** * @author Christoph Strobl + * @author Matthew Hall */ public class QueryParsers { @@ -60,6 +61,7 @@ public QueryParsers( parserPairs.add(new QueryParserPair(FacetQuery.class, defaultQueryParser)); parserPairs.add(new QueryParserPair(HighlightQuery.class, defaultQueryParser)); parserPairs.add(new QueryParserPair(Query.class, defaultQueryParser)); + parserPairs.add(new QueryParserPair(DisMaxQuery.class, defaultQueryParser)); } /** diff --git a/src/main/java/org/springframework/data/solr/core/SolrOperations.java b/src/main/java/org/springframework/data/solr/core/SolrOperations.java index e9a148067..70b8e5901 100644 --- a/src/main/java/org/springframework/data/solr/core/SolrOperations.java +++ b/src/main/java/org/springframework/data/solr/core/SolrOperations.java @@ -18,13 +18,13 @@ import java.time.Duration; import java.util.Collection; import java.util.Optional; - import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.response.SolrPingResponse; import org.apache.solr.client.solrj.response.UpdateResponse; import org.apache.solr.common.SolrInputDocument; import org.springframework.data.domain.Page; import org.springframework.data.solr.core.convert.SolrConverter; +import org.springframework.data.solr.core.query.DisMaxQuery; import org.springframework.data.solr.core.query.FacetAndHighlightQuery; import org.springframework.data.solr.core.query.FacetQuery; import org.springframework.data.solr.core.query.HighlightQuery; @@ -37,6 +37,7 @@ import org.springframework.data.solr.core.query.result.GroupPage; import org.springframework.data.solr.core.query.result.HighlightPage; import org.springframework.data.solr.core.query.result.ScoredPage; +import org.springframework.data.solr.core.query.result.SolrResultPage; import org.springframework.data.solr.core.query.result.StatsPage; import org.springframework.data.solr.core.query.result.TermsPage; import org.springframework.data.solr.core.schema.SchemaOperations; @@ -50,6 +51,7 @@ * @author Francisco Spaeth * @author Shiradwade Sateesh Krishna * @author David Webb + * @author Matthew Hall */ public interface SolrOperations { @@ -455,6 +457,29 @@ FacetAndHighlightPage queryForFacetAndHighlightPage(String collection, Fa */ StatsPage queryForStatsPage(String collection, Query query, Class clazz, RequestMethod method); + /** + * Execute the query against Solr and return result as {@link StatsPage}. + * + * @param collection must not be {@literal null}. + * @param query must not be {@literal null}. + * @param clazz must not be {@literal null}. + * @return never {@literal null}. + * @since 4.1 + */ + SolrResultPage queryForDisMaxPage(String collection, DisMaxQuery query, Class clazz); + + /** + * Execute the query against Solr and return result as {@link StatsPage}. + * + * @param collection must not be {@literal null}. + * @param query must not be {@literal null}. + * @param clazz must not be {@literal null}. + * @param requestMethod must not be {@literal null}. + * @return never {@literal null}. + * @since 4.1 + */ + public SolrResultPage queryForDisMaxPage(String collection, DisMaxQuery query, Class clazz, + @Nullable RequestMethod requestMethod); /** * Execute the query against Solr and return result as page. * diff --git a/src/main/java/org/springframework/data/solr/core/SolrTemplate.java b/src/main/java/org/springframework/data/solr/core/SolrTemplate.java index 536b954e8..90f646395 100644 --- a/src/main/java/org/springframework/data/solr/core/SolrTemplate.java +++ b/src/main/java/org/springframework/data/solr/core/SolrTemplate.java @@ -27,7 +27,6 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; - import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.SolrRequest; @@ -52,6 +51,7 @@ import org.springframework.data.domain.Pageable; import org.springframework.data.mapping.context.MappingContext; import org.springframework.data.solr.UncategorizedSolrException; +import org.springframework.data.solr.core.QueryParserBase.NamedObjectsDisMaxQuery; import org.springframework.data.solr.core.QueryParserBase.NamedObjectsFacetAndHighlightQuery; import org.springframework.data.solr.core.QueryParserBase.NamedObjectsFacetQuery; import org.springframework.data.solr.core.QueryParserBase.NamedObjectsHighlightQuery; @@ -62,6 +62,7 @@ import org.springframework.data.solr.core.mapping.SolrPersistentEntity; import org.springframework.data.solr.core.mapping.SolrPersistentProperty; import org.springframework.data.solr.core.query.AbstractQueryDecorator; +import org.springframework.data.solr.core.query.DisMaxQuery; import org.springframework.data.solr.core.query.FacetAndHighlightQuery; import org.springframework.data.solr.core.query.FacetQuery; import org.springframework.data.solr.core.query.HighlightQuery; @@ -91,6 +92,7 @@ * @author Petar Tahchiev * @author Mark Paluch * @author Juan Manuel de Blas + * @author Matthew Hall */ public class SolrTemplate implements SolrOperations, InitializingBean, ApplicationContextAware { @@ -431,6 +433,24 @@ public FacetAndHighlightPage queryForFacetAndHighlightPage(String collect return createSolrResultPage(query, clazz, response, objectsName); } + @Override + public SolrResultPage queryForDisMaxPage(String collection, DisMaxQuery query, Class clazz) { + return queryForDisMaxPage(collection, query, clazz, null); + } + + @Override + public SolrResultPage queryForDisMaxPage(String collection, DisMaxQuery query, Class clazz, + @Nullable RequestMethod requestMethod) { + + QueryResponse response; + NamedObjectsDisMaxQuery namedObjectsQuery = new NamedObjectsDisMaxQuery(query); + response = querySolr(collection, namedObjectsQuery, clazz, + requestMethod != null ? requestMethod : getDefaultRequestMethod()); + Map objectsName = namedObjectsQuery.getNamesAssociation(); + + return createSolrResultPage(query, clazz, response, objectsName); + } + private SolrResultPage createSolrResultPage(Query query, Class clazz, QueryResponse response, Map objectsName) { diff --git a/src/main/java/org/springframework/data/solr/core/query/AbstractDisMaxQueryDecorator.java b/src/main/java/org/springframework/data/solr/core/query/AbstractDisMaxQueryDecorator.java new file mode 100644 index 000000000..826eb7478 --- /dev/null +++ b/src/main/java/org/springframework/data/solr/core/query/AbstractDisMaxQueryDecorator.java @@ -0,0 +1,30 @@ +package org.springframework.data.solr.core.query; + +import org.springframework.lang.Nullable; + + +/** + * General purpose {@link DisMaxQuery} decorator. + * + * @author Matthew Hall + * @since 4.1.0 + */ +public abstract class AbstractDisMaxQueryDecorator extends AbstractQueryDecorator implements DisMaxQuery { + + private DisMaxQuery query; + + public AbstractDisMaxQueryDecorator(DisMaxQuery query) { + super(query); + this.query = query; + } + + @Nullable + @Override + public DisMaxOptions getDisMaxOptions() { + return this.query.getDisMaxOptions(); + } + + public T setDisMaxOptions(DisMaxOptions disMaxOptions) { + return this.query.setDisMaxOptions(disMaxOptions); + } +} diff --git a/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java b/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java new file mode 100644 index 000000000..d8a32fe63 --- /dev/null +++ b/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java @@ -0,0 +1,151 @@ +package org.springframework.data.solr.core.query; + +/** + * DisMax Options. + * + * @author Matthew Hall + */ +public class DisMaxOptions { + + private String altQuery; + private String queryFunction; + private String minimumMatch; + private String boostQuery; + private String boostFunction; + private Integer phraseSlop; + private Integer querySlop; + private Double tie; + private String phraseFunction; + private String defaultField; + + + public String getAltQuery() { + return altQuery; + } + + public String getQueryFunction() { + return queryFunction; + } + + public String getMinimumMatch() { + return minimumMatch; + } + + public String getBoostQuery() { + return boostQuery; + } + + public String getBoostFunction() { + return boostFunction; + } + + public Integer getPhraseSlop() { + return phraseSlop; + } + + public Integer getQuerySlop() { + return querySlop; + } + + public Double getTie() { + return tie; + } + + public String getPhraseFunction() { + return phraseFunction; + } + + public String getDefaultField() { + return defaultField; + } + + private DisMaxOptions(String altQuery, String queryFunction, String minimumMatch, String boostQuery, + String boostFunction, Integer phraseSlop, Integer querySlop, Double tie, String phraseFunction, + String defaultField) { + + this.altQuery = altQuery; + this.queryFunction = queryFunction; + this.minimumMatch = minimumMatch; + this.boostQuery = boostQuery; + this.boostFunction = boostFunction; + this.phraseSlop = phraseSlop; + this.querySlop = querySlop; + this.tie = tie; + this.phraseFunction = phraseFunction; + this.defaultField = defaultField; + } + + + public static class Builder { + + private String altQuery; + private String queryFunction; + private String minimumMatch; + private String boostQuery; + private String boostFunction; + private Integer phraseSlop; + private Integer querySlop; + private Double tie; + private String phraseFunction; + + private String defaultField; + + public Builder() {} + + public Builder altQuery(String altQuery) { + this.altQuery = altQuery; + return this; + } + + public Builder queryFunction(String queryFunction) { + this.queryFunction = queryFunction; + return this; + } + + public Builder minimumMatch(String minimumMatch) { + this.minimumMatch = minimumMatch; + return this; + } + + public Builder boostQuery(String boostQuery) { + this.boostQuery = boostQuery; + return this; + } + + public Builder phraseSlop(Integer phraseSlop) { + this.phraseSlop = phraseSlop; + return this; + } + + public Builder querySlop(Integer querySlop) { + this.querySlop = querySlop; + return this; + } + + public Builder tie(Double tie) { + this.tie = tie; + return this; + } + + public Builder boostFunction(String boostFunction) { + this.boostFunction = boostFunction; + return this; + } + + public Builder phraseFunction(String phraseFunction) { + this.phraseFunction = phraseFunction; + return this; + } + + public Builder defaultField(String defaultField) { + this.defaultField = defaultField; + return this; + } + + public DisMaxOptions build() { + return new DisMaxOptions(altQuery, queryFunction, minimumMatch, boostQuery, boostFunction, + phraseSlop, querySlop, tie, phraseFunction, defaultField); + } + + } +} diff --git a/src/main/java/org/springframework/data/solr/core/query/DisMaxQuery.java b/src/main/java/org/springframework/data/solr/core/query/DisMaxQuery.java new file mode 100644 index 000000000..c4a74c66e --- /dev/null +++ b/src/main/java/org/springframework/data/solr/core/query/DisMaxQuery.java @@ -0,0 +1,17 @@ +package org.springframework.data.solr.core.query; + +import org.springframework.lang.Nullable; + +/** + * Query to be used for DisMax query type. + * + * @author Matthew Hall + */ +public interface DisMaxQuery extends Query { + + @Nullable + DisMaxOptions getDisMaxOptions(); + + T setDisMaxOptions(DisMaxOptions disMaxOptions); + +} diff --git a/src/main/java/org/springframework/data/solr/core/query/SimpleDisMaxQuery.java b/src/main/java/org/springframework/data/solr/core/query/SimpleDisMaxQuery.java new file mode 100644 index 000000000..9df760431 --- /dev/null +++ b/src/main/java/org/springframework/data/solr/core/query/SimpleDisMaxQuery.java @@ -0,0 +1,34 @@ +package org.springframework.data.solr.core.query; + +import org.springframework.data.domain.Pageable; +import org.springframework.lang.Nullable; + +/** + * Trivial implementation of {@link DisMaxQuery} + * + * @author Matthew Hall + */ +public class SimpleDisMaxQuery extends SimpleQuery implements DisMaxQuery { + + private DisMaxOptions disMaxOptions; + + public SimpleDisMaxQuery(Criteria criteria) { + this(criteria, null); + } + + public SimpleDisMaxQuery(Criteria criteria, @Nullable Pageable pageable) { + super(criteria, pageable); + } + + @Nullable + @Override + public DisMaxOptions getDisMaxOptions() { + return this.disMaxOptions; + } + + @SuppressWarnings("unchecked") + public T setDisMaxOptions(DisMaxOptions disMaxOptions) { + this.disMaxOptions = disMaxOptions; + return (T) this; + } +} \ No newline at end of file diff --git a/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java b/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java index 83fcf7d33..45b679563 100644 --- a/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java +++ b/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java @@ -24,11 +24,11 @@ import java.util.Date; import java.util.List; import java.util.TimeZone; - import org.apache.commons.lang3.StringUtils; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.beans.Field; import org.apache.solr.common.params.CommonParams; +import org.apache.solr.common.params.DisMaxParams; import org.apache.solr.common.params.FacetParams; import org.apache.solr.common.params.FacetParams.FacetRangeInclude; import org.apache.solr.common.params.FacetParams.FacetRangeOther; @@ -70,6 +70,7 @@ * @author Francisco Spaeth * @author Petar Tahchiev * @author Michael Rocke + * @author Matthew Hall */ public class DefaultQueryParserTests { @@ -493,6 +494,7 @@ public void testConstructSimpleSolrQuery() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -508,6 +510,7 @@ public void testConstructSolrQueryWithPagination() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -522,6 +525,39 @@ public void testConstructSimpleSolrQueryWithProjection() { assertProjectionPresent(solrQuery, "projection_1,projection_2"); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); + } + + @Test + public void testConstructSimpleDisMaxSolrQuery() { + + DisMaxQuery query = new SimpleDisMaxQuery(new Criteria("field_1").is("value_1")); + + DisMaxOptions options = + new DisMaxOptions.Builder() + .altQuery("altq") + .boostFunction("boost_function") + .boostQuery("boost_query") + .defaultField("field_1") + .minimumMatch("100%") + .phraseFunction("phrase_function") + .phraseSlop(1) + .queryFunction("query_function") + .querySlop(2) + .tie(3.0) + .build(); + + query.setDisMaxOptions(options); + + SolrQuery solrQuery = queryParser.constructSolrQuery(query, null); + + assertNotNull(solrQuery); + assertQueryStringPresent(solrQuery); + assertPaginationNotPresent(solrQuery); + assertProjectionNotPresent(solrQuery); + assertGroupingNotPresent(solrQuery); + assertFactingNotPresent(solrQuery); + assertDisMaxParamsPresent(solrQuery, options); } @Test @@ -536,6 +572,7 @@ public void testConstructSolrQueryWithSingleGroupBy() { assertProjectionNotPresent(solrQuery); assertGroupingPresent(solrQuery, "group_1"); assertFactingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -550,6 +587,7 @@ public void testConstructSolrQueryWithSingleFacetOnField() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1"); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -564,6 +602,7 @@ public void testConstructSolrQueryWithSinglePivot() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertPivotFactingPresent(solrQuery, "field_1,field_2"); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -578,6 +617,7 @@ public void testConstructSolrQueryWithMultipleFacetOnFields() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -592,6 +632,7 @@ public void testConstructSolrQueryWithMultiplePivot() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertPivotFactingPresent(solrQuery, "field_1,field_2", "field_2,field_3"); + assertDisMaxParamsNotPresent(solrQuery); } @Test @@ -609,6 +650,7 @@ public void testConstructSolrQueryWithFacetPrefix() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); + assertDisMaxParamsNotPresent(solrQuery); assertEquals(facetOptions.getFacetPrefix(), solrQuery.getParams("facet.prefix")[0]); } @@ -628,6 +670,7 @@ public void testConstructSolrQueryWithFieldFacetParameters() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); + assertDisMaxParamsNotPresent(solrQuery); assertEquals(fieldWithFacetParameters.getPrefix(), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.prefix")[0]); assertEquals(FacetParams.FACET_SORT_INDEX, @@ -680,6 +723,7 @@ public void testConstructSolrQueryWithSingleFacetFilterQuery() { assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); assertArrayEquals(new String[] { "field_2:[* TO 5]" }, solrQuery.getFacetQuery()); } @@ -696,6 +740,7 @@ public void testConstructSolrQueryWithMultipleFacetFilterQuerues() { assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); assertArrayEquals(new String[] { "field_2:[* TO 5]", "field_3:prefix*" }, solrQuery.getFacetQuery()); } @@ -732,6 +777,7 @@ public void testWithSimpleStringCriteria() { assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); + assertDisMaxParamsNotPresent(solrQuery); assertEquals(criteria.getQueryString(), solrQuery.getQuery()); } @@ -1879,6 +1925,36 @@ private void assertGroupFormatPresent(SolrQuery solrQuery, boolean groupTotalCou assertEquals(String.valueOf(groupTotalCount), solrQuery.get(GroupParams.GROUP_TOTAL_COUNT)); } + private void assertDisMaxParamsNotPresent(SolrQuery solrQuery) { + + assertNull(solrQuery.get(DisMaxParams.ALTQ)); + assertNull(solrQuery.get(DisMaxParams.BF)); + assertNull(solrQuery.get(DisMaxParams.BQ)); + assertNull(solrQuery.get(DisMaxParams.MM)); + assertNull(solrQuery.get(DisMaxParams.PF)); + assertNull(solrQuery.get(DisMaxParams.PS)); + assertNull(solrQuery.get(DisMaxParams.QF)); + assertNull(solrQuery.get(DisMaxParams.QS)); + assertNull(solrQuery.get(DisMaxParams.TIE)); + assertNull(solrQuery.get(CommonParams.DF)); + + } + + private void assertDisMaxParamsPresent(SolrQuery solrQuery, DisMaxOptions options) { + + assertEquals(solrQuery.get(DisMaxParams.ALTQ), options.getAltQuery()); + assertEquals(solrQuery.get(DisMaxParams.BF), options.getBoostFunction()); + assertEquals(solrQuery.get(DisMaxParams.BQ), options.getBoostQuery()); + assertEquals(solrQuery.get(DisMaxParams.MM), options.getMinimumMatch()); + assertEquals(solrQuery.get(DisMaxParams.PF), options.getPhraseFunction()); + assertEquals(solrQuery.get(DisMaxParams.PS), String.valueOf(options.getPhraseSlop())); + assertEquals(solrQuery.get(DisMaxParams.QF), options.getQueryFunction()); + assertEquals(solrQuery.get(DisMaxParams.QS), String.valueOf(options.getQuerySlop())); + assertEquals(solrQuery.get(DisMaxParams.TIE), String.valueOf(options.getTie())); + assertEquals(solrQuery.get(CommonParams.DF), options.getDefaultField()); + + } + @SolrDocument static class Sample { From e792c4d538dc1cc480e881b08e4d21297276bfc3 Mon Sep 17 00:00:00 2001 From: Matt Hall Date: Thu, 15 Aug 2019 15:58:34 +0100 Subject: [PATCH 2/3] renamed version for ticketmaster --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index a7ee91fc7..0d01ba551 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ org.springframework.data spring-data-solr - 4.1.0.BUILD-SNAPSHOT + 4.1.0.BUILD-TICKETMASTER Spring Data Solr Spring Data module providing support for Apache Solr repositories. From 087f475b74e18dbd2b14d348f728bd72f7794647 Mon Sep 17 00:00:00 2001 From: Matt Hall Date: Mon, 20 Jan 2020 17:20:03 +0000 Subject: [PATCH 3/3] renamed queryFunction to queryFields --- pom.xml | 2 +- .../data/solr/core/DefaultQueryParser.java | 12 ++++++---- .../data/solr/core/query/DisMaxOptions.java | 23 +++++++++---------- .../SolrParametersParameterAccessor.java | 5 +++- .../solr/core/DefaultQueryParserTests.java | 2 +- 5 files changed, 24 insertions(+), 20 deletions(-) diff --git a/pom.xml b/pom.xml index 0d01ba551..2efe8977e 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ org.springframework.data spring-data-solr - 4.1.0.BUILD-TICKETMASTER + 4.1.0.BUILD Spring Data Solr Spring Data module providing support for Apache Solr repositories. diff --git a/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java b/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java index 3a57594c3..47ef8e769 100644 --- a/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java +++ b/src/main/java/org/springframework/data/solr/core/DefaultQueryParser.java @@ -152,17 +152,19 @@ protected void processDisMaxOptions(SolrQuery solrQuery, DisMaxQuery disMaxQuery setSolrParamIfPresent(solrQuery, DF, disMaxOptions.getDefaultField()); setSolrParamIfPresent(solrQuery, ALTQ, disMaxOptions.getAltQuery()); - setSolrParamIfPresent(solrQuery, QF, disMaxOptions.getQueryFunction()); + setSolrParamIfPresent(solrQuery, QF, disMaxOptions.getQueryFields()); setSolrParamIfPresent(solrQuery, MM, disMaxOptions.getMinimumMatch()); setSolrParamIfPresent(solrQuery, BQ, disMaxOptions.getBoostQuery()); setSolrParamIfPresent(solrQuery, BF, disMaxOptions.getBoostFunction()); setSolrParamIfPresent(solrQuery, PF, disMaxOptions.getPhraseFunction()); - setSolrParamIfPresent(solrQuery, PS, disMaxOptions.getPhraseSlop() == null ? null : - String.valueOf(disMaxOptions.getPhraseSlop())); - setSolrParamIfPresent(solrQuery, QS, disMaxOptions.getQuerySlop() == null ? null : String.valueOf(disMaxOptions.getQuerySlop())); - setSolrParamIfPresent(solrQuery, TIE, disMaxOptions.getTie() == null ? null : String.valueOf(disMaxOptions.getTie())); + setSolrParamIfPresent(solrQuery, PS, + disMaxOptions.getPhraseSlop() == null ? null : String.valueOf(disMaxOptions.getPhraseSlop())); + setSolrParamIfPresent(solrQuery, QS, + disMaxOptions.getQuerySlop() == null ? null : String.valueOf(disMaxOptions.getQuerySlop())); + setSolrParamIfPresent(solrQuery, TIE, + disMaxOptions.getTie() == null ? null : String.valueOf(disMaxOptions.getTie())); } private static void setSolrParamIfPresent(SolrQuery solrQuery, String param, String value) { diff --git a/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java b/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java index d8a32fe63..cd9650c3d 100644 --- a/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java +++ b/src/main/java/org/springframework/data/solr/core/query/DisMaxOptions.java @@ -8,7 +8,7 @@ public class DisMaxOptions { private String altQuery; - private String queryFunction; + private String queryFields; private String minimumMatch; private String boostQuery; private String boostFunction; @@ -18,13 +18,12 @@ public class DisMaxOptions { private String phraseFunction; private String defaultField; - public String getAltQuery() { return altQuery; } - public String getQueryFunction() { - return queryFunction; + public String getQueryFields() { + return queryFields; } public String getMinimumMatch() { @@ -59,12 +58,12 @@ public String getDefaultField() { return defaultField; } - private DisMaxOptions(String altQuery, String queryFunction, String minimumMatch, String boostQuery, - String boostFunction, Integer phraseSlop, Integer querySlop, Double tie, String phraseFunction, - String defaultField) { + private DisMaxOptions(String altQuery, String queryFields, String minimumMatch, String boostQuery, + String boostFunction, Integer phraseSlop, Integer querySlop, Double tie, String phraseFunction, + String defaultField) { this.altQuery = altQuery; - this.queryFunction = queryFunction; + this.queryFields = queryFields; this.minimumMatch = minimumMatch; this.boostQuery = boostQuery; this.boostFunction = boostFunction; @@ -79,7 +78,7 @@ private DisMaxOptions(String altQuery, String queryFunction, String minimumMatch public static class Builder { private String altQuery; - private String queryFunction; + private String queryFields; private String minimumMatch; private String boostQuery; private String boostFunction; @@ -98,7 +97,7 @@ public Builder altQuery(String altQuery) { } public Builder queryFunction(String queryFunction) { - this.queryFunction = queryFunction; + this.queryFields = queryFunction; return this; } @@ -143,8 +142,8 @@ public Builder defaultField(String defaultField) { } public DisMaxOptions build() { - return new DisMaxOptions(altQuery, queryFunction, minimumMatch, boostQuery, boostFunction, - phraseSlop, querySlop, tie, phraseFunction, defaultField); + return new DisMaxOptions(altQuery, queryFields, minimumMatch, boostQuery, boostFunction, phraseSlop, querySlop, + tie, phraseFunction, defaultField); } } diff --git a/src/main/java/org/springframework/data/solr/repository/query/SolrParametersParameterAccessor.java b/src/main/java/org/springframework/data/solr/repository/query/SolrParametersParameterAccessor.java index b825d0aea..7e177be47 100644 --- a/src/main/java/org/springframework/data/solr/repository/query/SolrParametersParameterAccessor.java +++ b/src/main/java/org/springframework/data/solr/repository/query/SolrParametersParameterAccessor.java @@ -17,7 +17,6 @@ import java.util.Iterator; import java.util.Optional; - import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; import org.springframework.data.repository.query.ParametersParameterAccessor; @@ -72,6 +71,10 @@ public Optional> getDynamicProjection() { return parametersParameterAccessorDelegate.getDynamicProjection(); } + @Override public Class findDynamicProjection() { + return parametersParameterAccessorDelegate.getDynamicProjection().orElse(null); + } + public class BindableSolrParameterIterator implements Iterator { private final Iterator delegate; diff --git a/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java b/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java index 45b679563..1f99e7caf 100644 --- a/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java +++ b/src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java @@ -1948,7 +1948,7 @@ private void assertDisMaxParamsPresent(SolrQuery solrQuery, DisMaxOptions option assertEquals(solrQuery.get(DisMaxParams.MM), options.getMinimumMatch()); assertEquals(solrQuery.get(DisMaxParams.PF), options.getPhraseFunction()); assertEquals(solrQuery.get(DisMaxParams.PS), String.valueOf(options.getPhraseSlop())); - assertEquals(solrQuery.get(DisMaxParams.QF), options.getQueryFunction()); + assertEquals(solrQuery.get(DisMaxParams.QF), options.getQueryFields()); assertEquals(solrQuery.get(DisMaxParams.QS), String.valueOf(options.getQuerySlop())); assertEquals(solrQuery.get(DisMaxParams.TIE), String.valueOf(options.getTie())); assertEquals(solrQuery.get(CommonParams.DF), options.getDefaultField());