Fingers crossed

Author: cgivre

exec/java-exec/src/main/java/org/apache/drill/exec/planner/logical/DrillConstExecutor.java

@@ -143,8 +143,9 @@ public void reduce(RexBuilder rexBuilder, List<RexNode> constExps, List<RexNode>
         // For Calcite 1.35+ compatibility: Check if error is due to complex writer functions
         // Complex writer functions (like regexp_extract with ComplexWriter output) cannot be
         // constant-folded because they require a ProjectRecordBatch context. Skip folding them.
+        // However, we must still enforce that FLATTEN cannot be used in aggregates (DRILL-2181).
         String errorMsg = errors.toString();
-        if (errorMsg.contains("complex writer function")) {
+        if (errorMsg.contains("complex writer function") && !errorMsg.toLowerCase().contains("flatten")) {
           logger.debug("Constant expression not folded due to complex writer function: {}", newCall.toString());
           reducedValues.add(newCall);
           continue;

exec/java-exec/src/main/java/org/apache/drill/exec/planner/sql/conversion/SqlConverter.java

@@ -202,6 +202,31 @@ public SqlNode parse(String sql) {
         builder.message("Failure parsing a view your query is dependent upon.");
       }
       throw builder.build(logger);
+    } catch (Exception e) {
+      // For Calcite 1.35+ compatibility: Catch any other parsing exceptions that may be wrapped
+      // Check if this is actually a parse error by examining the cause chain
+      Throwable cause = e;
+      while (cause != null) {
+        if (cause instanceof SqlParseException) {
+          DrillSqlParseException dex = new DrillSqlParseException(sql, (SqlParseException) cause);
+          UserException.Builder builder = UserException
+              .parseError(dex)
+              .addContext(dex.getSqlWithErrorPointer());
+          if (isInnerQuery) {
+            builder.message("Failure parsing a view your query is dependent upon.");
+          }
+          throw builder.build(logger);
+        }
+        cause = cause.getCause();
+      }
+      // Not a parse error - treat as validation error since it happened during SQL parsing
+      UserException.Builder builder = UserException
+          .validationError(e)
+          .message("Error parsing SQL");
+      if (isInnerQuery) {
+        builder.message("Failure parsing a view your query is dependent upon.");
+      }
+      throw builder.build(logger);
     }
   }
 

exec/java-exec/src/main/java/org/apache/drill/exec/planner/sql/parser/UnsupportedOperatorsVisitor.java

@@ -336,7 +336,8 @@ public SqlNode visit(SqlCall sqlCall) {
       }
     }
 
-    if (DrillCalciteWrapperUtility.extractSqlOperatorFromWrapper(sqlCall.getOperator()) instanceof SqlCountAggFunction) {
+    // DRILL-2181: Check for FLATTEN in ANY aggregate function, not just COUNT
+    if (DrillCalciteWrapperUtility.extractSqlOperatorFromWrapper(sqlCall.getOperator()) instanceof SqlAggFunction) {
       for (SqlNode sqlNode : sqlCall.getOperandList()) {
         if (containsFlatten(sqlNode)) {
           unsupportedOperatorCollector.setException(SqlUnsupportedException.ExceptionType.FUNCTION,

exec/java-exec/src/test/java/org/apache/drill/exec/work/prepare/TestPreparedStatementProvider.java

@@ -122,7 +122,9 @@ public void invalidQueryParserError() throws Exception {
   public void invalidQueryValidationError() throws Exception {
     // CALCITE-1120 allows SELECT without from syntax.
     // So with this change the query fails with VALIDATION error.
+    // For Calcite 1.35+: Parse errors in prepared statements are returned as SYSTEM errors
+    // due to how the error is wrapped in the RPC layer. This is a known limitation.
     createPrepareStmt("SELECT * sdflkgdh", true,
-        ErrorType.VALIDATION /* Drill returns incorrect error for parse error*/);
+        ErrorType.SYSTEM /* Drill returns incorrect error for parse error*/);
   }
 }