Allow CASE alternative implicit type promotions when feasible. (#3379)

Previously, the `CASE` runtime used to reject alternatives with
different types even if they have a common max-type.

This PR address this by implementing an encapsulator that is capable of
generating a `CASE` expression callsite that with implicit promotions
applied to the alternatives when necessary.

As a result a query like this now works:

```sql
create table A(A1 bigint, A2 bigint, A3 bigint, primary key(A1));
insert into A values
        (1, 10, 10),
        (2, 11, 20),
        (3, 12, 30);
select a3, case when a3 > 15 then 10 else 3.14 end from A;
10, 3.14
20, 10.0
30, 10.0 
```

(note how `10` is promoted to `10.0` in the result set).

This fixes #3378.

Author: hatyo

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/JavaCallFunction.java

@@ -44,7 +44,6 @@ public JavaCallFunction() {
         super("java_call", List.of(Type.primitiveType(Type.TypeCode.STRING)), new Type.Any(), JavaCallFunction::findFunction);
     }
 
-    @SuppressWarnings({"DataFlowIssue"})
     @Nonnull
     private static Value findFunction(@Nonnull final BuiltInFunction<Value> ignored, final List<? extends Typed> arguments) {
         Verify.verify(!arguments.isEmpty());

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/PickValue.java

@@ -31,6 +31,8 @@
 import com.apple.foundationdb.record.planprotos.PValue;
 import com.apple.foundationdb.record.provider.foundationdb.FDBRecordStoreBase;
 import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
+import com.apple.foundationdb.record.query.plan.cascades.BuiltInFunction;
+import com.apple.foundationdb.record.query.plan.cascades.typing.Typed;
 import com.apple.foundationdb.record.query.plan.explain.ExplainTokens;
 import com.apple.foundationdb.record.query.plan.explain.ExplainTokensWithPrecedence;
 import com.apple.foundationdb.record.query.plan.cascades.SemanticException;
@@ -218,4 +220,37 @@ public PickValue fromProto(@Nonnull final PlanSerializationContext serialization
             return PickValue.fromProto(serializationContext, pickValueProto);
         }
     }
+
+    /**
+     * The {@code pick} function.
+     */
+    @AutoService(BuiltInFunction.class)
+    public static class PickValueFn extends BuiltInFunction<Value> {
+        public PickValueFn() {
+            super("pick", List.of(Type.primitiveType(Type.TypeCode.INT), Type.any()), Type.any(), PickValueFn::encapsulate);
+        }
+
+        @SuppressWarnings("PMD.UnusedFormalParameter")
+        private static Value encapsulate(@Nonnull BuiltInFunction<Value> ignored,
+                                         @Nonnull final List<? extends Typed> arguments) {
+            Verify.verify(arguments.size() > 1);
+            var selectorValue = (Value)arguments.get(0);
+            final var selectorMaxType = Type.maximumType(selectorValue.getResultType(), Type.primitiveType(Type.TypeCode.INT));
+            SemanticException.check(selectorMaxType != null, SemanticException.ErrorCode.INCOMPATIBLE_TYPE);
+            selectorValue = PromoteValue.inject(selectorValue, selectorMaxType);
+
+            final var firstAlternative = (Value)arguments.get(1);
+            var alternativesMaxType = firstAlternative.getResultType();
+            for (int i = 2; i < arguments.size(); i++) {
+                alternativesMaxType = Type.maximumType(alternativesMaxType, arguments.get(i).getResultType());
+                SemanticException.check(alternativesMaxType != null, SemanticException.ErrorCode.INCOMPATIBLE_TYPE);
+            }
+
+            final var alternativesList = ImmutableList.<Value>builder();
+            for (int i = 1; i < arguments.size(); i++) {
+                alternativesList.add(PromoteValue.inject((Value)arguments.get(i), alternativesMaxType));
+            }
+            return new PickValue(selectorValue, alternativesList.build());
+        }
+    }
 }

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

@@ -148,6 +148,7 @@ private static ImmutableMap<String, Function<Integer, Optional<BuiltInFunction<?
                 .put("range", argumentsCount -> BuiltInFunctionCatalog.resolve("range", argumentsCount))
                 .put("__pattern_for_like", argumentsCount -> BuiltInFunctionCatalog.resolve("patternForLike", argumentsCount))
                 .put("__internal_array", argumentsCount -> BuiltInFunctionCatalog.resolve("array", argumentsCount))
+                .put("__pick_value", argumentsCount -> BuiltInFunctionCatalog.resolve("pick", argumentsCount))
                 .build();
     }
 

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

@@ -30,7 +30,6 @@
 import com.apple.foundationdb.record.query.plan.cascades.values.FieldValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.LiteralValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.NullValue;
-import com.apple.foundationdb.record.query.plan.cascades.values.PickValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.PromoteValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.RecordConstructorValue;
 import com.apple.foundationdb.record.query.plan.cascades.values.Value;
@@ -311,20 +310,24 @@ public Expression visitScalarFunctionCall(@Nonnull RelationalParser.ScalarFuncti
     @Override
     public Expression visitCaseFunctionCall(@Nonnull RelationalParser.CaseFunctionCallContext ctx) {
         final ImmutableList.Builder<Value> implications = ImmutableList.builder();
-        final ImmutableList.Builder<Value> pickerValues = ImmutableList.builder();
+        final ImmutableList.Builder<Expression> pickerValues = ImmutableList.builder();
         for (final var caseAlternative : ctx.caseFuncAlternative()) {
             final var condition = visitFunctionArg(caseAlternative.condition);
-            Assert.thatUnchecked(condition.getDataType().getCode().equals(DataType.Code.BOOLEAN));
+            Assert.thatUnchecked(condition.getDataType().getCode().equals(DataType.Code.BOOLEAN), ErrorCode.DATATYPE_MISMATCH,
+                    "argument of case when must be of boolean type");
             final var consequent = visitFunctionArg(caseAlternative.consequent);
             implications.add(condition.getUnderlying());
-            pickerValues.add(consequent.getUnderlying());
+            pickerValues.add(consequent);
         }
         if (ctx.ELSE() != null) {
             implications.add(TautologicalValue.getInstance());
             final var defaultConsequent = visitFunctionArg(ctx.functionArg());
-            pickerValues.add(defaultConsequent.getUnderlying());
+            pickerValues.add(defaultConsequent);
         }
-        return Expression.ofUnnamed(new PickValue(new ConditionSelectorValue(implications.build()), pickerValues.build()));
+        final var arguments = ImmutableList.<Expression>builder();
+        arguments.add(Expression.ofUnnamed(new ConditionSelectorValue(implications.build())));
+        arguments.addAll(pickerValues.build());
+        return getDelegate().resolveFunction("__pick_value", arguments.build().toArray(new Expression[0]));
     }
 
     @Nonnull

yaml-tests/src/test/resources/case-when.yamsql

@@ -53,6 +53,12 @@ test_block:
       - supported_version: !current_version
       - result: [ { B2: true, 'foo' },
                   { B2: false, 'bar' } ]
+    -
+      - query: select a3, case when a3 > 15 then 10 else 3.14 end from A;
+      - supported_version: !current_version
+      - result: [ { A3: 10, 3.14 },
+                  { A3: 20, 10.0 },
+                  { A3: 30, 10.0 } ]
 ---
 setup:
   steps: