DDP-7443 | change strategy of building query

src/main/java/org/broadinstitute/dsm/model/elastic/filter/query/QueryBuilderFactory.java → src/main/java/org/broadinstitute/dsm/model/elastic/filter/query/BaseQueryBuilder.java

@@ -13,54 +13,56 @@
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
 import org.elasticsearch.index.query.RegexpQueryBuilder;
-import org.elasticsearch.index.query.TermQueryBuilder;
-import org.elasticsearch.index.query.WildcardQueryBuilder;
 
-public class QueryBuilderFactory {
-    public static QueryBuilder buildQueryBuilder(Operator operator, QueryPayload payload,
-                                                 BaseSplitter splitter) {
+public abstract class BaseQueryBuilder {
+
+    protected Operator operator;
+    protected QueryPayload payload;
+    protected BaseSplitter splitter;
+
+    protected QueryBuilder buildQueryBuilder() {
         QueryBuilder qb;
         switch (operator) {
             case LIKE:
             case EQUALS:
             case DATE:
             case DIAMOND_EQUALS:
             case STR_DATE:
-                qb = new MatchQueryBuilder(payload.getFieldName(), payload.getValues()[0]);
+                qb = build(new MatchQueryBuilder(payload.getFieldName(), payload.getValues()[0]));
                 break;
             case GREATER_THAN_EQUALS:
                 RangeQueryBuilder greaterRangeQuery = new RangeQueryBuilder(payload.getFieldName());
                 greaterRangeQuery.gte(payload.getValues()[0]);
-                qb = greaterRangeQuery;
+                qb = build(greaterRangeQuery);
                 break;
             case LESS_THAN_EQUALS:
                 RangeQueryBuilder lessRangeQuery = new RangeQueryBuilder(payload.getFieldName());
                 lessRangeQuery.lte(payload.getValues()[0]);
-                qb = lessRangeQuery;
+                qb = build(lessRangeQuery);
                 break;
             case DATE_GREATER:
                 RangeQueryBuilder dateGreaterQuery = new RangeQueryBuilder(payload.getFieldName());
                 dateGreaterQuery.gte(payload.getValues()[0]);
-                qb = dateGreaterQuery;
+                qb = build(dateGreaterQuery);
                 break;
             case DATE_LESS:
                 RangeQueryBuilder dateLessQuery = new RangeQueryBuilder(payload.getFieldName());
                 dateLessQuery.lte(payload.getValues()[0]);
-                qb = dateLessQuery;
+                qb = build(dateLessQuery);
                 break;
             case IS_NOT_NULL:
-                qb = buildIsNotNullAndEmpty(payload);
+                qb = buildIsNotNullAndEmpty();
                 break;
             case IS_NULL:
-                qb = buildIsNullQuery(payload);
+                qb = buildIsNullQuery();
                 break;
             case MULTIPLE_OPTIONS:
                 BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
                 Object[] values = payload.getValues();
                 for (Object value : values) {
                     boolQueryBuilder.should(new MatchQueryBuilder(payload.getFieldName(), value));
                 }
-                qb = boolQueryBuilder;
+                qb = build(boolQueryBuilder);
                 break;
             case JSON_EXTRACT:
                 Object[] dynamicFieldValues = payload.getValues();
@@ -78,32 +80,36 @@ public static QueryBuilder buildQueryBuilder(Operator operator, QueryPayload pay
                     }
                 } else {
                     if (jsonExtractSplitter.getDecoratedSplitter() instanceof IsNullSplitter) {
-                        qb = buildIsNullQuery(payload);
+                        qb = buildIsNullQuery();
                     } else {
-                        qb = buildIsNotNullAndEmpty(payload);
+                        qb = buildIsNotNullAndEmpty();
                     }
                 }
+                qb = build(qb);
                 break;
             default:
                 throw new IllegalArgumentException(Operator.UNKNOWN_OPERATOR);
         }
         return qb;
     }
 
-    private static QueryBuilder buildIsNotNullAndEmpty(QueryPayload payload) {
+    private QueryBuilder buildIsNotNullAndEmpty() {
         BoolQueryBuilder isNotNullAndNotEmpty = new BoolQueryBuilder();
         isNotNullAndNotEmpty.must(new ExistsQueryBuilder(payload.getFieldName()));
         isNotNullAndNotEmpty.must(new RegexpQueryBuilder(payload.getFieldName(), DsmAbstractQueryBuilder.ONE_OR_MORE_REGEX));
         return isNotNullAndNotEmpty;
     }
 
-    private static QueryBuilder buildIsNullQuery(QueryPayload payload) {
-        BoolQueryBuilder isNullQuery = new BoolQueryBuilder();
+    protected abstract QueryBuilder build(QueryBuilder queryBuilder);
+
+    private QueryBuilder buildIsNullQuery() {
         BoolQueryBuilder existsWithEmpty = new BoolQueryBuilder();
-        existsWithEmpty.must(new ExistsQueryBuilder(payload.getFieldName()));
-        existsWithEmpty.mustNot(new WildcardQueryBuilder(payload.getFieldName(), DsmAbstractQueryBuilder.WILDCARD));
-        isNullQuery.should(existsWithEmpty);
-        isNullQuery.should(new BoolQueryBuilder().mustNot(new ExistsQueryBuilder(payload.getFieldName())));
-        return isNullQuery;
+        existsWithEmpty.mustNot(build(new ExistsQueryBuilder(payload.getFieldName())));
+        return existsWithEmpty;
     }
+
+    protected abstract QueryBuilder buildEachQuery(Operator operator,
+                                                   QueryPayload queryPayload,
+                                                   BaseSplitter splitter);
+
 }

src/main/java/org/broadinstitute/dsm/model/elastic/filter/query/CollectionQueryBuilder.java

@@ -1,16 +1,29 @@
 package org.broadinstitute.dsm.model.elastic.filter.query;
 
 import org.apache.lucene.search.join.ScoreMode;
-import org.broadinstitute.dsm.model.elastic.filter.FilterStrategy;
+import org.broadinstitute.dsm.model.elastic.filter.Operator;
+import org.broadinstitute.dsm.model.elastic.filter.splitter.BaseSplitter;
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.NestedQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
-public class CollectionQueryBuilder extends DsmAbstractQueryBuilder {
+public class CollectionQueryBuilder extends BaseQueryBuilder {
 
-    public CollectionQueryBuilder() {}
+    @Override
+    protected QueryBuilder build(QueryBuilder queryBuilder) {
+        return new NestedQueryBuilder(payload.getPath(), queryBuilder, ScoreMode.Avg);
+    }
 
     @Override
-    protected void buildEachQuery(FilterStrategy filterStrategy) {
-        filterStrategy.build(boolQueryBuilder, new NestedQueryBuilder(buildPath(), queryBuilder, ScoreMode.Avg));
+    protected QueryBuilder buildEachQuery(Operator operator,
+                                          QueryPayload queryPayload,
+                                          BaseSplitter splitter) {
+        this.operator = operator;
+        this.payload = queryPayload;
+        this.splitter = splitter;
+        return buildQueryBuilder();
     }
 
 }

src/main/java/org/broadinstitute/dsm/model/elastic/filter/query/DsmAbstractQueryBuilder.java

@@ -28,6 +28,7 @@ public abstract class DsmAbstractQueryBuilder {
     protected QueryBuilder queryBuilder;
     protected BaseSplitter splitter;
     protected AndOrFilterSeparator filterSeparator;
+    private BaseQueryBuilder baseQueryBuilder;
 
     public DsmAbstractQueryBuilder(String filter, Parser parser) {
         this();
@@ -75,15 +76,16 @@ protected void buildUpQuery(List<String> filterValues, FilterStrategy filterStra
             splitter = SplitterFactory.createSplitter(operator, filterValue);
             splitter.setFilter(filterValue);
             QueryPayload queryPayload = new QueryPayload(buildPath(), splitter.getInnerProperty(), parser.parse(splitter.getValue()));
-            queryBuilder = QueryBuilderFactory.buildQueryBuilder(operator, queryPayload, splitter);
-            buildEachQuery(filterStrategy);
+//            queryBuilder = BaseQueryBuilder.buildQueryBuilder(operator, queryPayload, splitter);
+            filterStrategy.build(boolQueryBuilder, baseQueryBuilder.buildEachQuery(operator, queryPayload, splitter));
+//            buildEachQuery(filterStrategy);
         }
     }
 
     protected String buildPath() {
         return DSM_WITH_DOT + Util.TABLE_ALIAS_MAPPINGS.get(splitter.getAlias()).getPropertyName();
     }
 
-    protected abstract void buildEachQuery(FilterStrategy filterStrategy);
+//    protected abstract void buildEachQuery(FilterStrategy filterStrategy);
 
 }

src/main/java/org/broadinstitute/dsm/model/elastic/filter/query/SingleQueryBuilder.java

@@ -1,13 +1,20 @@
 package org.broadinstitute.dsm.model.elastic.filter.query;
 
 import org.broadinstitute.dsm.model.elastic.filter.FilterStrategy;
+import org.broadinstitute.dsm.model.elastic.filter.Operator;
+import org.broadinstitute.dsm.model.elastic.filter.splitter.BaseSplitter;
+import org.elasticsearch.index.query.QueryBuilder;
 
-public class SingleQueryBuilder extends DsmAbstractQueryBuilder {
+public class SingleQueryBuilder extends BaseQueryBuilder {
 
-    public SingleQueryBuilder() {}
 
     @Override
-    protected void buildEachQuery(FilterStrategy filterStrategy) {
-        filterStrategy.build(boolQueryBuilder, queryBuilder);
+    protected QueryBuilder build(QueryBuilder queryBuilder) {
+        return queryBuilder;
+    }
+
+    @Override
+    protected QueryBuilder buildEachQuery(Operator operator, QueryPayload queryPayload, BaseSplitter splitter) {
+        return null;
     }
 }

src/test/java/org/broadinstitute/dsm/model/elastic/filter/query/QueryBuilderFactoryTest.java → src/test/java/org/broadinstitute/dsm/model/elastic/filter/query/BaseQueryBuilderTest.java

@@ -8,20 +8,20 @@
 import org.elasticsearch.index.query.RangeQueryBuilder;
 import org.junit.Test;
 
-public class QueryBuilderFactoryTest {
+public class BaseQueryBuilderTest {
 
 
     @Test
     public void buildQueryBuilder() {
         QueryPayload payload = new QueryPayload("dsm.medicalRecord", "medicalRecordId", new Integer[] {10});
         Operator operator = Operator.EQUALS;
-        QueryBuilder queryBuilder = QueryBuilderFactory.buildQueryBuilder(operator, payload, null);
+        QueryBuilder queryBuilder = BaseQueryBuilder.buildQueryBuilder();
         assertTrue(queryBuilder instanceof MatchQueryBuilder);
         operator = Operator.LIKE;
-        queryBuilder = QueryBuilderFactory.buildQueryBuilder(operator, payload, null);
+        queryBuilder = BaseQueryBuilder.buildQueryBuilder();
         assertTrue(queryBuilder instanceof MatchQueryBuilder);
         operator = Operator.GREATER_THAN_EQUALS;
-        queryBuilder = QueryBuilderFactory.buildQueryBuilder(operator, payload, null);
+        queryBuilder = BaseQueryBuilder.buildQueryBuilder();
         assertTrue(queryBuilder instanceof RangeQueryBuilder);
     }