Unpivoting repeated fields with SQL functions (#3537)

Previously, correlated qualifiers were incorrectly processed, which
prevented unpivoting operations on repeated fields when used alongside
SQL functions. This fix resolves the qualifier handling logic to enable
proper unpivoting according to our SQL syntax.

This fixes #3532.

Author: hatyo

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/LogicalOperator.java

@@ -184,7 +184,7 @@ public static LogicalOperator generateAccess(@Nonnull Identifier identifier,
         } else if (semanticAnalyzer.tableExists(identifier)) {
             return logicalOperatorCatalog.lookupTableAccess(identifier, alias, requestedIndexes, semanticAnalyzer);
         } else if (semanticAnalyzer.functionExists(identifier)) {
-            return semanticAnalyzer.resolveTableFunction(identifier.getName(), Expressions.empty(), false);
+            return semanticAnalyzer.resolveTableFunction(identifier, Expressions.empty(), false);
         } else {
             final var correlatedField = semanticAnalyzer.resolveCorrelatedIdentifier(identifier, currentPlanFragment.getLogicalOperatorsIncludingOuter());
             Assert.thatUnchecked(requestedIndexes.isEmpty(), ErrorCode.UNSUPPORTED_QUERY, () -> String.format(Locale.ROOT, "Can not hint indexes with correlated field access %s", identifier));

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/SemanticAnalyzer.java

@@ -815,11 +815,11 @@ private void processFunctionSideEffects(@Nonnull final CatalogedFunction builtIn
      * @return A {@link LogicalOperator} representing the semantics of the requested SQL table function.
      */
     @Nonnull
-    public LogicalOperator resolveTableFunction(@Nonnull final String functionName, @Nonnull final Expressions arguments,
+    public LogicalOperator resolveTableFunction(@Nonnull final Identifier functionName, @Nonnull final Expressions arguments,
                                                 boolean flattenSingleItemRecords) {
-        Assert.thatUnchecked(functionCatalog.containsFunction(functionName), ErrorCode.UNDEFINED_FUNCTION,
+        Assert.thatUnchecked(functionCatalog.containsFunction(functionName.getName()), ErrorCode.UNDEFINED_FUNCTION,
                 () -> String.format(Locale.ROOT, "Unknown function %s", functionName));
-        final var tableFunction = functionCatalog.lookupFunction(functionName, arguments);
+        final var tableFunction = functionCatalog.lookupFunction(functionName.getName(), arguments);
         if (tableFunction instanceof BuiltInFunction) {
             Assert.thatUnchecked(tableFunction instanceof BuiltInTableFunction, functionName + " is not a table-valued function");
         }
@@ -838,11 +838,11 @@ public LogicalOperator resolveTableFunction(@Nonnull final String functionName,
             final var tableFunctionExpression = new TableFunctionExpression(Assert.castUnchecked(resultingValue, StreamingValue.class));
             final var resultingQuantifier = Quantifier.forEach(Reference.initialOf(tableFunctionExpression));
             final var output = Expressions.of(LogicalOperator.convertToExpressions(resultingQuantifier));
-            return LogicalOperator.newUnnamedOperator(output, resultingQuantifier);
+            return LogicalOperator.newNamedOperator(functionName, output, resultingQuantifier);
         }
         final var relationalExpression = Assert.castUnchecked(resultingValue, RelationalExpression.class);
         final var topQun = Quantifier.forEach(Reference.initialOf(relationalExpression));
-        return LogicalOperator.newUnnamedOperator(Expressions.fromQuantifier(topQun), topQun);
+        return LogicalOperator.newNamedOperator(functionName, Expressions.fromQuantifier(topQun), topQun);
     }
 
     // TODO: this will be removed once we unify both Java- and SQL-UDFs.

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/BaseVisitor.java

@@ -223,7 +223,7 @@ public Expression resolveFunction(@Nonnull String functionName, boolean flattenS
     }
 
     @Nonnull
-    public LogicalOperator resolveTableValuedFunction(@Nonnull String functionName, @Nonnull Expressions arguments) {
+    public LogicalOperator resolveTableValuedFunction(@Nonnull Identifier functionName, @Nonnull Expressions arguments) {
         return getSemanticAnalyzer().resolveTableFunction(functionName, arguments, true);
     }
 

fdb-relational-core/src/main/java/com/apple/foundationdb/relational/recordlayer/query/visitors/ExpressionVisitor.java

@@ -87,7 +87,7 @@ public static ExpressionVisitor of(@Nonnull BaseVisitor baseVisitor) {
 
     @Override
     public LogicalOperator visitTableFunction(@Nonnull RelationalParser.TableFunctionContext ctx) {
-        final var functionName = visitTableFunctionName(ctx.tableFunctionName()).toString();
+        final var functionName = visitTableFunctionName(ctx.tableFunctionName());
         return ctx.tableFunctionArgs() == null
                 ? getDelegate().resolveTableValuedFunction(functionName, Expressions.empty())
                 : getDelegate().resolveTableValuedFunction(functionName, visitTableFunctionArgs(ctx.tableFunctionArgs()));

fdb-relational-core/src/test/java/com/apple/foundationdb/relational/recordlayer/query/TemporaryFunctionTests.java

@@ -1051,6 +1051,35 @@ void attemptToCreateTemporaryFunctionWithDifferentCaseSensitivityOptionCase2() t
         }
     }
 
+    @Test
+    void unpivotRepeatedFieldInSqlFunctionWorksCorrectly() throws Exception {
+        final String schemaTemplate = "create type as struct city(name string, population bigint) " +
+                "create table country(id bigint, name string, continent string, cities city array, primary key(id))";
+        try (var ddl = Ddl.builder().database(URI.create("/TEST/QT")).relationalExtension(relationalExtension).schemaTemplate(schemaTemplate).build()) {
+            try (var statement = ddl.setSchemaAndGetConnection().createStatement()) {
+                statement.executeUpdate("insert into country values " +
+                        "(1, 'USA', 'North America', [('New York' ,8419600), ('Los Angeles', 3980400)]), " +
+                        "(2, 'Canada', 'North America', [('Toronto', 2731571), ('Montreal', 1760400)]), " +
+                        "(3, 'Brazil', 'South America', [('Rio de Janeiro', 6795900), ('Sao Paulo', 12303800)]), " +
+                        "(4, 'France', 'Europe', [('Paris', 2148327), ('Lyon', 516855)])");
+            }
+            final var connection = ddl.getConnection();
+            connection.setAutoCommit(false);
+            try (var statement = connection.prepareStatement("create temporary function northAmericaCountries() " +
+                    "on commit drop function as select * from country where continent = 'North America'")) {
+                statement.execute();
+            }
+            try (var statement = connection.prepareStatement("select A.name from northAmericaCountries, (select * from northAmericaCountries.cities) as A where population > 8000000")) {
+                try (var resultSet = statement.executeQuery()) {
+                    Assertions.assertTrue(resultSet.next());
+                    Assertions.assertEquals("New York", resultSet.getString(1));
+                    Assertions.assertFalse(resultSet.next());
+                }
+            }
+            connection.rollback();
+        }
+    }
+
     private void invokeAndVerifyTempFunction(final RelationalStatement statement) throws SQLException {
         Assertions.assertTrue(statement.execute("select * from sq1(x => 2)"));
         invokeAndVerify(statement::getResultSet, 1L, 10L, 2L, 20L, 3L, 30L, 4L, 40L);