support for contains and in relational filter for first class fields; added quotes around fields

Author: patelraj0602

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresContainsRelationalFilterParser.java

@@ -6,7 +6,8 @@
 import org.hypertrace.core.documentstore.Document;
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
 
-class PostgresContainsRelationalFilterParser implements PostgresRelationalFilterParser {
+class PostgresContainsRelationalFilterParser
+    implements PostgresContainsRelationalFilterParserInterface {
   private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
 
   @Override

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresContainsRelationalFilterParserInterface.java

@@ -0,0 +1,12 @@
+package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter;
+
+/**
+ * Interface for handling CONTAINS operations in PostgreSQL queries. Implementations can provide
+ * different strategies for handling containment operations based on the context of the query (e.g.,
+ * first-class fields vs. JSON fields).
+ */
+public interface PostgresContainsRelationalFilterParserInterface
+    extends PostgresRelationalFilterParser {
+  // Interface inherits the parse method from PostgresRelationalFilterParser
+  // No additional methods required at this time
+}

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresInRelationalFilterParser.java

@@ -5,7 +5,7 @@
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
 import org.hypertrace.core.documentstore.postgres.Params;
 
-class PostgresInRelationalFilterParser implements PostgresRelationalFilterParser {
+class PostgresInRelationalFilterParser implements PostgresInRelationalFilterParserInterface {
 
   @Override
   public String parse(

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresInRelationalFilterParserInterface.java

@@ -0,0 +1,11 @@
+package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter;
+
+/**
+ * Interface for handling IN operation filters in PostgreSQL queries. Implementations can provide
+ * different strategies for handling IN operations based on the context of the query (e.g.,
+ * first-class fields vs. JSON fields).
+ */
+public interface PostgresInRelationalFilterParserInterface extends PostgresRelationalFilterParser {
+  // Interface inherits the parse method from PostgresRelationalFilterParser
+  // No additional methods required at this time
+}

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresNotContainsRelationalFilterParser.java

@@ -1,19 +1,33 @@
 package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter;
 
-import static org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.PostgresContainsRelationalFilterParser.prepareJsonValueForContainsOp;
-
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field.PostgresContainsRelationalFilterParserNonJsonField;
 
 class PostgresNotContainsRelationalFilterParser implements PostgresRelationalFilterParser {
+  private static final PostgresContainsRelationalFilterParser jsonContainsParser =
+      new PostgresContainsRelationalFilterParser();
+  private static final PostgresContainsRelationalFilterParserNonJsonField nonJsonContainsParser =
+      new PostgresContainsRelationalFilterParserNonJsonField();
+
   @Override
   public String parse(
       final RelationalExpression expression, final PostgresRelationalFilterContext context) {
     final String parsedLhs = expression.getLhs().accept(context.lhsParser());
-    final Object parsedRhs = expression.getRhs().accept(context.rhsParser());
 
-    final Object convertedRhs = prepareJsonValueForContainsOp(parsedRhs);
-    context.getParamsBuilder().addObjectParam(convertedRhs);
+    boolean isFirstClassField =
+        context
+            .getFlatStructureCollectionName()
+            .map(name -> name.equals(context.getTableIdentifier().getTableName()))
+            .orElse(false);
 
-    return String.format("%s IS NULL OR NOT %s @> ?::jsonb", parsedLhs, parsedLhs);
+    if (isFirstClassField) {
+      // Use the non-JSON logic for first-class fields
+      String containsExpression = nonJsonContainsParser.parse(expression, context);
+      return String.format("%s IS NULL OR NOT (%s)", parsedLhs, containsExpression);
+    } else {
+      // Use the JSON logic for document fields.
+      jsonContainsParser.parse(expression, context); // This adds the parameter.
+      return String.format("%s IS NULL OR NOT %s @> ?::jsonb", parsedLhs, parsedLhs);
+    }
   }
 }

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresNotInRelationalFilterParser.java

@@ -1,16 +1,33 @@
 package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter;
 
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field.PostgresInRelationalFilterParserNonJsonField;
 
 class PostgresNotInRelationalFilterParser implements PostgresRelationalFilterParser {
-  private static final PostgresInRelationalFilterParser inRelationalFilterParser =
+  private static final PostgresInRelationalFilterParserInterface jsonFieldInFilterParser =
       new PostgresInRelationalFilterParser();
+  private static final PostgresInRelationalFilterParserInterface nonJsonFieldInFilterParser =
+      new PostgresInRelationalFilterParserNonJsonField();
 
   @Override
   public String parse(
       final RelationalExpression expression, final PostgresRelationalFilterContext context) {
     final String parsedLhs = expression.getLhs().accept(context.lhsParser());
-    final String parsedInExpression = inRelationalFilterParser.parse(expression, context);
+
+    PostgresInRelationalFilterParserInterface inFilterParser = getInFilterParser(context);
+
+    final String parsedInExpression = inFilterParser.parse(expression, context);
     return String.format("%s IS NULL OR NOT (%s)", parsedLhs, parsedInExpression);
   }
+
+  private PostgresInRelationalFilterParserInterface getInFilterParser(
+      PostgresRelationalFilterContext context) {
+    boolean isFirstClassField =
+        context
+            .getFlatStructureCollectionName()
+            .map(name -> name.equals(context.getTableIdentifier().getTableName()))
+            .orElse(false);
+
+    return isFirstClassField ? nonJsonFieldInFilterParser : jsonFieldInFilterParser;
+  }
 }

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresRelationalFilterParserFactory.java

@@ -1,7 +1,9 @@
 package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter;
 
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
+import org.hypertrace.core.documentstore.postgres.query.v1.PostgresQueryParser;
 
 public interface PostgresRelationalFilterParserFactory {
-  PostgresRelationalFilterParser parser(final RelationalExpression expression);
+  PostgresRelationalFilterParser parser(
+      final RelationalExpression expression, final PostgresQueryParser postgresQueryParser);
 }

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/PostgresRelationalFilterParserFactoryImpl.java

@@ -14,25 +14,55 @@
 import java.util.Map;
 import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
 import org.hypertrace.core.documentstore.expression.operators.RelationalOperator;
+import org.hypertrace.core.documentstore.postgres.query.v1.PostgresQueryParser;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field.PostgresContainsRelationalFilterParserNonJsonField;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field.PostgresInRelationalFilterParserNonJsonField;
 
 public class PostgresRelationalFilterParserFactoryImpl
     implements PostgresRelationalFilterParserFactory {
   private static final Map<RelationalOperator, PostgresRelationalFilterParser> parserMap =
       Maps.immutableEnumMap(
           Map.ofEntries(
-              entry(CONTAINS, new PostgresContainsRelationalFilterParser()),
+              // CONTAINS is conditionally chosen between JSON and non-JSON versions
               entry(NOT_CONTAINS, new PostgresNotContainsRelationalFilterParser()),
               entry(EXISTS, new PostgresExistsRelationalFilterParser()),
               entry(NOT_EXISTS, new PostgresNotExistsRelationalFilterParser()),
-              entry(IN, new PostgresInRelationalFilterParser()),
+              // IN  are conditionally chosen between JSON and non-JSON versions
               entry(NOT_IN, new PostgresNotInRelationalFilterParser()),
               entry(LIKE, new PostgresLikeRelationalFilterParser()),
               entry(STARTS_WITH, new PostgresStartsWithRelationalFilterParser())));
+
+  // IN filter parsers
+  private static final PostgresInRelationalFilterParserInterface jsonFieldInFilterParser =
+      new PostgresInRelationalFilterParser();
+  private static final PostgresInRelationalFilterParserInterface nonJsonFieldInFilterParser =
+      new PostgresInRelationalFilterParserNonJsonField();
+
+  // CONTAINS parser implementations
+  private static final PostgresContainsRelationalFilterParserInterface jsonFieldContainsParser =
+      new PostgresContainsRelationalFilterParser();
+  private static final PostgresContainsRelationalFilterParserInterface nonJsonFieldContainsParser =
+      new PostgresContainsRelationalFilterParserNonJsonField();
+
   private static final PostgresStandardRelationalFilterParser
       postgresStandardRelationalFilterParser = new PostgresStandardRelationalFilterParser();
 
   @Override
-  public PostgresRelationalFilterParser parser(final RelationalExpression expression) {
+  public PostgresRelationalFilterParser parser(
+      final RelationalExpression expression, final PostgresQueryParser postgresQueryParser) {
+
+    boolean isFirstClassField =
+        postgresQueryParser
+            .getFlatStructureCollectionName()
+            .map(name -> name.equals(postgresQueryParser.getTableIdentifier().getTableName()))
+            .orElse(false);
+
+    if (expression.getOperator() == CONTAINS) {
+      return isFirstClassField ? nonJsonFieldContainsParser : jsonFieldContainsParser;
+    } else if (expression.getOperator() == IN) {
+      return isFirstClassField ? nonJsonFieldInFilterParser : jsonFieldInFilterParser;
+    }
+
     return parserMap.getOrDefault(expression.getOperator(), postgresStandardRelationalFilterParser);
   }
 }

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/nonjson/field/PostgresContainsRelationalFilterParserNonJsonField.java

@@ -0,0 +1,40 @@
+package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field;
+
+import java.util.Collection;
+import java.util.Collections;
+import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.PostgresContainsRelationalFilterParserInterface;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.PostgresRelationalFilterParser;
+
+/**
+ * Implementation of CONTAINS operator for non-JSON fields (regular PostgreSQL arrays). Uses the
+ * PostgreSQL array containment operator (@>) for checking if one array contains another.
+ *
+ * <p>This class is optimized for first-class array columns rather than JSON document fields.
+ */
+public class PostgresContainsRelationalFilterParserNonJsonField
+    implements PostgresContainsRelationalFilterParserInterface {
+
+  @Override
+  public String parse(
+      final RelationalExpression expression,
+      final PostgresRelationalFilterParser.PostgresRelationalFilterContext context) {
+    final String parsedLhs = expression.getLhs().accept(context.lhsParser());
+    final Object parsedRhs = expression.getRhs().accept(context.rhsParser());
+
+    Object normalizedRhs = normalizeValue(parsedRhs);
+    context.getParamsBuilder().addObjectParam(normalizedRhs);
+
+    return String.format("%s @> ARRAY[?]::text[]", parsedLhs);
+  }
+
+  private Object normalizeValue(final Object value) {
+    if (value == null) {
+      return null;
+    } else if (value instanceof Collection) {
+      return value;
+    } else {
+      return Collections.singletonList(value);
+    }
+  }
+}

document-store/src/main/java/org/hypertrace/core/documentstore/postgres/query/v1/parser/filter/nonjson/field/PostgresInRelationalFilterParserNonJsonField.java

@@ -0,0 +1,43 @@
+package org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.nonjson.field;
+
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+import org.hypertrace.core.documentstore.expression.impl.RelationalExpression;
+import org.hypertrace.core.documentstore.postgres.Params;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.PostgresInRelationalFilterParserInterface;
+import org.hypertrace.core.documentstore.postgres.query.v1.parser.filter.PostgresRelationalFilterParser;
+
+/**
+ * Implementation of PostgresInRelationalFilterParserInterface for handling IN operations on
+ * first-class fields (non-JSON columns), using the more efficient array-based syntax.
+ */
+public class PostgresInRelationalFilterParserNonJsonField
+    implements PostgresInRelationalFilterParserInterface {
+
+  @Override
+  public String parse(
+      final RelationalExpression expression,
+      final PostgresRelationalFilterParser.PostgresRelationalFilterContext context) {
+    final String parsedLhs = expression.getLhs().accept(context.lhsParser());
+    final Iterable<Object> parsedRhs = expression.getRhs().accept(context.rhsParser());
+
+    return prepareFilterStringForInOperator(parsedLhs, parsedRhs, context.getParamsBuilder());
+  }
+
+  private String prepareFilterStringForInOperator(
+      final String parsedLhs,
+      final Iterable<Object> parsedRhs,
+      final Params.Builder paramsBuilder) {
+
+    String placeholders =
+        StreamSupport.stream(parsedRhs.spliterator(), false)
+            .map(
+                value -> {
+                  paramsBuilder.addObjectParam(value);
+                  return "?";
+                })
+            .collect(Collectors.joining(", "));
+
+    return String.format("%s && ARRAY[%s]::text[]", parsedLhs, placeholders);
+  }
+}