[WIP] Error message type aliasing - built out aliasTypeMap and in the…

babel/src/test/resources/sql/big-query.iq

@@ -1937,7 +1937,7 @@ SELECT
 SELECT
   TIMESTAMP "2010-07-07 10:20:00" AS later_timestamp,
   TIMESTAMP "2008-12-25 15:30:00" AS earlier_timestamp,
-  TIMESTAMP_DIFF(TIMESTAMP "2010-07-07 10:20:00", TIMESTAMP "2008-12-25 15:30:00", HOUR) AS hours;
+  TIMESTAMP_DIFF(1, TIMESTAMP "2008-12-25 15:30:00", HOUR) AS hours;
 +---------------------+---------------------+-------+
 | later_timestamp     | earlier_timestamp   | hours |
 +---------------------+---------------------+-------+

core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java

@@ -16,8 +16,13 @@
  */
 package org.apache.calcite.prepare;
 
+import com.google.common.collect.BiMap;
+
+import com.google.common.collect.HashBiMap;
+
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.jdbc.CalciteSchema.TypeEntry;
 import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
 import org.apache.calcite.linq4j.function.Hints;
 import org.apache.calcite.model.ModelHandler;
@@ -88,6 +93,7 @@ public class CalciteCatalogReader implements Prepare.CatalogReader {
   private final List<List<String>> schemaPaths;
   protected final SqlNameMatcher nameMatcher;
   protected final CalciteConnectionConfig config;
+  protected BiMap<TypeEntry, String> aliasTypeMap;
 
   public CalciteCatalogReader(CalciteSchema rootSchema,
       List<String> defaultSchema, RelDataTypeFactory typeFactory, CalciteConnectionConfig config) {
@@ -108,6 +114,23 @@ protected CalciteCatalogReader(CalciteSchema rootSchema,
             : new LinkedHashSet<>(schemaPaths));
     this.typeFactory = typeFactory;
     this.config = config;
+    this.aliasTypeMap = HashBiMap.create();
+    populateAliasTypeMap(this.aliasTypeMap, rootSchema);
+  }
+
+
+  public static void populateAliasTypeMap(BiMap<TypeEntry, String> aliasTypeMap,
+      CalciteSchema schema) {
+
+    for (String typeName: schema.getTypeNames()){
+      TypeEntry typeEntry = schema.getType(typeName, true);
+      if (typeEntry!=null){
+        aliasTypeMap.put(typeEntry, typeName);
+      }
+    }
+    for (CalciteSchema subschema: schema.getSubSchemaMap().values()){
+      populateAliasTypeMap(aliasTypeMap, subschema);
+    }
   }
 
   @Override public CalciteCatalogReader withSchemaPath(List<String> schemaPath) {
@@ -172,8 +195,14 @@ private Collection<org.apache.calcite.schema.Function> getFunctionsFrom(
     }
     return functions2;
   }
+  // public @Nullable SqlIdentifier getNameFromType(RelDataType type) {
+  //   // fill this out
+  // // SqlValidatorUtil.getNameFromType(getRootSchema(), type);
+  //   return null;
+  // }
 
   @Override public @Nullable RelDataType getNamedType(SqlIdentifier typeName) {
+    // getRootSchema().schema.
     CalciteSchema.TypeEntry typeEntry = SqlValidatorUtil.getTypeEntry(getRootSchema(), typeName);
     if (typeEntry != null) {
       return typeEntry.getType().apply(typeFactory);
@@ -452,4 +481,9 @@ private static RelDataType toSql(RelDataTypeFactory typeFactory,
     }
     return null;
   }
+
+  @Override
+  public BiMap<TypeEntry, String> getAliasTypeMap() {
+    return aliasTypeMap;
+  }
 }

core/src/main/java/org/apache/calcite/sql/SqlCallBinding.java

@@ -398,10 +398,13 @@ public SqlCall permutedCall() {
    * @return signature exception
    */
   public CalciteException newValidationSignatureError() {
+    // String type = validator.getCatalogReader().getNamedType(call.getOperator()
+    // .getNameAsId()).getSqlTypeName().getName();
     return validator.newValidationError(call,
         RESOURCE.canNotApplyOp2Type(getOperator().getName(),
             call.getCallSignature(validator, scope),
-            getOperator().getAllowedSignatures()));
+            // getOperator().getAllowedSignatures()));
+            getOperator().getAllowedSignaturesUsingValidator(validator)));
   }
 
   /**

core/src/main/java/org/apache/calcite/sql/SqlHopTableFunction.java

@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.sql;
 
+import org.apache.calcite.sql.validate.SqlValidator;
+
 import com.google.common.collect.ImmutableList;
 
 /**
@@ -61,5 +63,11 @@ private static class OperandMetadataImpl extends AbstractOperandMetadata {
       return opName + "(TABLE table_name, DESCRIPTOR(timecol), "
           + "datetime interval, datetime interval[, datetime interval])";
     }
+
+    @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+        SqlValidator validator) {
+      return opName + "(TABLE table_name, DESCRIPTOR(timecol), "
+          + "datetime interval, datetime interval[, datetime interval])";
+    }
   }
 }

core/src/main/java/org/apache/calcite/sql/SqlOperator.java

@@ -583,7 +583,6 @@ public RelDataType deriveType(
       RelDataType nodeType = validator.deriveType(scope, operand);
       assert nodeType != null;
     }
-
     final List<SqlNode> args = constructOperandList(validator, call, null);
 
     final List<RelDataType> argTypes = constructArgTypeList(validator, scope,
@@ -806,6 +805,9 @@ public final String getAllowedSignatures() {
     return getAllowedSignatures(name);
   }
 
+  public final String getAllowedSignaturesUsingValidator(SqlValidator validator) {
+    return getAllowedSignaturesUsingValidator(name, validator);
+  }
   /**
    * Returns a string describing the expected operand types of a call, e.g.
    * "SUBSTRING(VARCHAR, INTEGER, INTEGER)" where the name (SUBSTRING in this
@@ -815,10 +817,18 @@ public String getAllowedSignatures(String opNameToUse) {
     requireNonNull(operandTypeChecker,
         "If you see this, assign operandTypeChecker a value "
         + "or override this function");
+    // is validator available here?
     return operandTypeChecker.getAllowedSignatures(this, opNameToUse)
         .trim();
   }
 
+  public String getAllowedSignaturesUsingValidator(String opNameToUse, SqlValidator validator) {
+    requireNonNull(operandTypeChecker,
+        "If you see this, assign operandTypeChecker a value "
+            + "or override this function");
+    return operandTypeChecker.getAllowedSignaturesUsingValidator(this, opNameToUse, validator);
+  }
+
   public @Nullable SqlOperandTypeInference getOperandTypeInference() {
     return operandTypeInference;
   }

core/src/main/java/org/apache/calcite/sql/SqlSessionTableFunction.java

@@ -79,5 +79,11 @@ private static class OperandMetadataImpl extends AbstractOperandMetadata {
       return opName + "(TABLE table_name, DESCRIPTOR(timecol), "
           + "DESCRIPTOR(key) optional, datetime interval)";
     }
+
+    @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+        SqlValidator validator) {
+      return opName + "(TABLE table_name, DESCRIPTOR(timecol), "
+          + "DESCRIPTOR(key) optional, datetime interval)";
+    }
   }
 }

core/src/main/java/org/apache/calcite/sql/SqlTumbleTableFunction.java

@@ -16,6 +16,8 @@
  */
 package org.apache.calcite.sql;
 
+import org.apache.calcite.sql.validate.SqlValidator;
+
 import com.google.common.collect.ImmutableList;
 
 /**
@@ -62,5 +64,12 @@ private static class OperandMetadataImpl extends AbstractOperandMetadata {
       return opName + "(TABLE table_name, DESCRIPTOR(timecol), datetime interval"
           + "[, datetime interval])";
     }
+
+    @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+        SqlValidator validator) {
+      return opName + "(TABLE table_name, DESCRIPTOR(timecol), datetime interval"
+          + "[, datetime interval])";
+    }
+
   }
 }

core/src/main/java/org/apache/calcite/sql/SqlUtil.java

@@ -38,6 +38,7 @@
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.util.SqlBasicVisitor;
 import org.apache.calcite.sql.validate.SqlNameMatcher;
+import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.util.BarfingInvocationHandler;
 import org.apache.calcite.util.ConversionUtil;
@@ -905,6 +906,43 @@ public static String getAliasedSignature(
     return ret.toString();
   }
 
+  public static String getAliasedSignatureWithValidator(
+      SqlOperator op,
+      String opName,
+      List<?> typeList,
+      SqlValidator validator
+      ) {
+    StringBuilder ret = new StringBuilder();
+    String template = op.getSignatureTemplate(typeList.size());
+    if (null == template) {
+      ret.append("'");
+      ret.append(opName);
+      ret.append("(");
+      for (int i = 0; i < typeList.size(); i++) {
+        if (i > 0) {
+          ret.append(", ");
+        }
+        final String t = String.valueOf(typeList.get(i)).toUpperCase(Locale.ROOT);
+        String aliasedType = SqlValidatorUtil.getAliasedTypeName(validator, t);
+        ret.append("<").append(aliasedType).append(">");
+      }
+      ret.append(")'");
+    } else {
+      Object[] values = new Object[typeList.size() + 1];
+      values[0] = opName;
+      ret.append("'");
+      for (int i = 0; i < typeList.size(); i++) {
+        final String t = String.valueOf(typeList.get(i)).toUpperCase(Locale.ROOT);
+        values[i + 1] = "<" + t + ">";
+      }
+      ret.append(new MessageFormat(template, Locale.ROOT).format(values));
+      ret.append("'");
+      assert (typeList.size() + 1) == values.length;
+    }
+
+    return ret.toString();
+  }
+
   /**
    * Wraps an exception with context.
    */

core/src/main/java/org/apache/calcite/sql/fun/SqlItemOperator.java

@@ -37,6 +37,8 @@
 
 import java.util.Arrays;
 
+import org.apache.calcite.sql.validate.SqlValidator;
+
 import static org.apache.calcite.sql.type.NonNullableAccessors.getComponentTypeOrThrow;
 import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getOperandLiteralValueOrThrow;
 
@@ -127,6 +129,11 @@ private static SqlSingleOperandTypeChecker getChecker(SqlCallBinding callBinding
         + "<ROW>[<CHARACTER>|<INTEGER>]";
   }
 
+  @Override public String getAllowedSignaturesUsingValidator(String name, SqlValidator validator) {
+    return "<ARRAY>[<INTEGER>]\n"
+        + "<MAP>[<ANY>]\n"
+        + "<ROW>[<CHARACTER>|<INTEGER>]";
+  }
   @Override public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
     final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
     final RelDataType operandType = opBinding.getOperandType(0);

core/src/main/java/org/apache/calcite/sql/type/AssignableOperandTypeChecker.java

@@ -16,12 +16,17 @@
  */
 package org.apache.calcite.sql.type;
 
+import java.util.stream.Stream;
+
+import org.apache.calcite.jdbc.CalciteSchema.TypeEntry;
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.util.Pair;
 
 import com.google.common.collect.ImmutableList;
@@ -102,4 +107,29 @@ public AssignableOperandTypeChecker(List<RelDataType> paramTypes,
     sb.append(")");
     return sb.toString();
   }
+
+  @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+      SqlValidator validator) {
+    StringBuilder sb = new StringBuilder();
+    // validator.getCatalogReader().alias
+    sb.append(opName);
+    sb.append("(");
+    for (Ord<RelDataType> paramType : Ord.zip(paramTypes)) {
+      if (paramType.i > 0) {
+        sb.append(", ");
+      }
+      if (paramNames != null) {
+        String paramTypeName = paramNames.get(paramType.i);
+        // String aliasedName = SqlValidatorUtil.getAliasedTypeName(validator, paramTypeName);
+        String aliasedName = paramTypeName;
+        sb.append(aliasedName)
+            .append(" => ");
+      }
+      sb.append("<");
+      sb.append(paramType.e.getFamily());
+      sb.append(">");
+    }
+    sb.append(")");
+    return sb.toString();
+  }
 }

core/src/main/java/org/apache/calcite/sql/type/CompositeOperandTypeChecker.java

@@ -21,6 +21,7 @@
 import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.implicit.TypeCoercion;
 import org.apache.calcite.util.Util;
 
@@ -154,6 +155,8 @@ public ImmutableList<? extends SqlOperandTypeChecker> getRules() {
       if (ord.i > 0) {
         ret.append(SqlOperator.NL);
       }
+      // is call binding available here?
+
       ret.append(ord.e.getAllowedSignatures(op, opName));
       if (composition == Composition.AND) {
         break;
@@ -162,6 +165,37 @@ public ImmutableList<? extends SqlOperandTypeChecker> getRules() {
     return ret.toString();
   }
 
+  @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+      SqlValidator validator) {
+    if (allowedSignatures != null) {
+      return allowedSignatures;
+    }
+    if (signatureGenerator != null) {
+      return signatureGenerator.apply(op, opName);
+    }
+    if (composition == Composition.SEQUENCE) {
+      throw new AssertionError(
+          "specify allowedSignatures or override getAllowedSignatures");
+    }
+    StringBuilder ret = new StringBuilder();
+    for (Ord<SqlOperandTypeChecker> ord
+        : Ord.<SqlOperandTypeChecker>zip(allowedRules)) {
+      if (ord.i > 0) {
+        ret.append(SqlOperator.NL);
+      }
+      // is call binding available here?
+      ret.append("test");
+      validator.getCatalogReader().getRootSchema();
+
+      ret.append(ord.e.getAllowedSignaturesUsingValidator(op, opName, validator));
+      if (composition == Composition.AND) {
+        break;
+      }
+    }
+    return ret.toString();
+
+  }
+
   @Override public SqlOperandCountRange getOperandCountRange() {
     switch (composition) {
     case REPEAT:

core/src/main/java/org/apache/calcite/sql/type/ExplicitOperandTypeChecker.java

@@ -21,6 +21,7 @@
 import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.validate.SqlValidator;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -69,4 +70,9 @@ public ExplicitOperandTypeChecker(RelDataType type) {
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return "<TYPE> " + opName + " <TYPE>";
   }
+
+  @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+      SqlValidator validator) {
+    return "<TYPE> " + opName + " <TYPE>";
+  }
 }

core/src/main/java/org/apache/calcite/sql/type/FamilyOperandTypeChecker.java

@@ -23,6 +23,7 @@
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.implicit.TypeCoercion;
 
 import com.google.common.collect.ImmutableList;
@@ -189,4 +190,9 @@ public class FamilyOperandTypeChecker implements SqlSingleOperandTypeChecker,
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return SqlUtil.getAliasedSignature(op, opName, families);
   }
+
+  @Override public String getAllowedSignaturesUsingValidator(SqlOperator op, String opName,
+      SqlValidator validator) {
+    return SqlUtil.getAliasedSignatureWithValidator(op, opName, families, validator);
+  }
 }