Throw exceptions instead of returning nulls in PostgresArrayTypeExtractor

Author: suddendust

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

@@ -11,6 +11,21 @@
 import org.hypertrace.core.documentstore.expression.impl.JsonIdentifierExpression;
 import org.hypertrace.core.documentstore.parser.SelectTypeExpressionVisitor;
 
+/**
+ * Visitor to extract PostgreSQL array type information from {@link ArrayIdentifierExpression}.
+ *
+ * <p>This visitor is specifically designed to work ONLY with {@link ArrayIdentifierExpression}. Any
+ * other expression type will throw {@link UnsupportedOperationException} to catch programming
+ * errors early.
+ *
+ * <p>Returns:
+ *
+ * <ul>
+ *   <li>The PostgreSQL array type string (e.g., "text[]", "integer[]") if {@link ArrayType} is
+ *       specified
+ *   <li>{@code null} if {@link ArrayIdentifierExpression} is used without an explicit type
+ * </ul>
+ */
 class PostgresArrayTypeExtractor implements SelectTypeExpressionVisitor {
 
   public PostgresArrayTypeExtractor() {}
@@ -22,36 +37,44 @@ public String visit(ArrayIdentifierExpression expression) {
 
   @Override
   public String visit(JsonIdentifierExpression expression) {
-    return null; // JSON fields don't have array type
+    throw unsupportedExpression("JsonIdentifierExpression");
   }
 
   @Override
   public String visit(IdentifierExpression expression) {
-    return null; // Regular identifiers don't have array type (backward compat fallback)
+    throw new UnsupportedOperationException(
+        "PostgresArrayTypeExtractor should only be used with ArrayIdentifierExpression. "
+            + "Use IdentifierExpression only for scalar fields, not arrays.");
   }
 
   @Override
   public String visit(AggregateExpression expression) {
-    return null;
+    throw unsupportedExpression("AggregateExpression");
   }
 
   @Override
   public String visit(ConstantExpression expression) {
-    return null;
+    throw unsupportedExpression("ConstantExpression");
   }
 
   @Override
   public String visit(DocumentConstantExpression expression) {
-    return null;
+    throw unsupportedExpression("DocumentConstantExpression");
   }
 
   @Override
   public String visit(FunctionExpression expression) {
-    return null;
+    throw unsupportedExpression("FunctionExpression");
   }
 
   @Override
   public String visit(AliasedIdentifierExpression expression) {
-    return null;
+    throw unsupportedExpression("AliasedIdentifierExpression");
+  }
+
+  private static UnsupportedOperationException unsupportedExpression(String expressionType) {
+    return new UnsupportedOperationException(
+        "PostgresArrayTypeExtractor should only be used with ArrayIdentifierExpression, not "
+            + expressionType);
   }
 }

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

@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.hypertrace.core.documentstore.expression.impl.AggregateExpression;
 import org.hypertrace.core.documentstore.expression.impl.AliasedIdentifierExpression;
@@ -49,15 +50,13 @@ void testVisitArrayIdentifierExpression_withoutType() {
   @Test
   void testVisitJsonIdentifierExpression() {
     JsonIdentifierExpression expr = JsonIdentifierExpression.of("customAttr", "field");
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
   void testVisitIdentifierExpression() {
     IdentifierExpression expr = IdentifierExpression.of("item");
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
@@ -66,24 +65,21 @@ void testVisitAggregateExpression() {
         AggregateExpression.of(
             org.hypertrace.core.documentstore.expression.operators.AggregationOperator.COUNT,
             IdentifierExpression.of("item"));
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
   void testVisitConstantExpression() {
     ConstantExpression expr = ConstantExpression.of("test");
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
   void testVisitDocumentConstantExpression() {
     ConstantExpression.DocumentConstantExpression expr =
         (ConstantExpression.DocumentConstantExpression)
             ConstantExpression.of((org.hypertrace.core.documentstore.Document) null);
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
@@ -93,15 +89,13 @@ void testVisitFunctionExpression() {
             .operator(FunctionOperator.LENGTH)
             .operand(IdentifierExpression.of("item"))
             .build();
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 
   @Test
   void testVisitAliasedIdentifierExpression() {
     AliasedIdentifierExpression expr =
         AliasedIdentifierExpression.builder().name("item").contextAlias("i").build();
-    String result = extractor.visit(expr);
-    assertNull(result);
+    assertThrows(UnsupportedOperationException.class, () -> extractor.visit(expr));
   }
 }