Rav4768

core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java

@@ -93,9 +93,17 @@
 import static org.apache.calcite.linq4j.tree.ExpressionType.Subtract;
 import static org.apache.calcite.linq4j.tree.ExpressionType.UnaryPlus;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CHR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATETIME_ADD;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATETIME_SUB;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATE_MOD;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DAYNAME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DAYOCCURRENCE_OF_MONTH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DIFFERENCE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.FROM_BASE64;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.IFNULL;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.INSTR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.ISNULL;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_DEPTH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_KEYS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_LENGTH;
@@ -104,17 +112,35 @@
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_STORAGE_SIZE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_TYPE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.LEFT;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.LPAD;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.MD5;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.MONTHNAME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.MONTHNUMBER_OF_QUARTER;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.MONTHNUMBER_OF_YEAR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.QUARTERNUMBER_OF_YEAR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REGEXP_REPLACE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REPEAT;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REVERSE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.RIGHT;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.RPAD;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SHA1;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SOUNDEX;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SPACE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMPINTADD;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMPINTSUB;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_SECONDS;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_TO_DATE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIME_DIFF;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIME_SUB;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TO_BASE64;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TO_BINARY;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TO_CHAR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TO_VARCHAR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TRANSLATE3;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.WEEKNUMBER_OF_CALENDAR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.WEEKNUMBER_OF_MONTH;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.WEEKNUMBER_OF_YEAR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.YEARNUMBER_OF_CALENDAR;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ABS;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ACOS;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.AND;
@@ -303,8 +329,7 @@ public class RexImpTable {
     defineMethod(REPLACE, BuiltInMethod.REPLACE.method, NullPolicy.STRICT);
     defineMethod(TRANSLATE3, BuiltInMethod.TRANSLATE3.method, NullPolicy.STRICT);
     defineMethod(CHR, "chr", NullPolicy.STRICT);
-    defineMethod(CHARACTER_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
-        NullPolicy.STRICT);
+    defineMethod(CHARACTER_LENGTH, BuiltInMethod.CHAR_LENGTH.method, NullPolicy.STRICT);
     defineMethod(CHAR_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
         NullPolicy.STRICT);
     defineMethod(CONCAT, BuiltInMethod.STRING_CONCAT.method,
@@ -317,10 +342,16 @@ public class RexImpTable {
     defineMethod(SOUNDEX, BuiltInMethod.SOUNDEX.method, NullPolicy.STRICT);
     defineMethod(DIFFERENCE, BuiltInMethod.DIFFERENCE.method, NullPolicy.STRICT);
     defineMethod(REVERSE, BuiltInMethod.REVERSE.method, NullPolicy.STRICT);
-
+    defineMethod(IFNULL, BuiltInMethod.IFNULL.method, NullPolicy.NONE);
+    defineMethod(ISNULL, BuiltInMethod.ISNULL.method, NullPolicy.NONE);
+    defineMethod(RPAD, BuiltInMethod.RPAD.method, NullPolicy.NONE);
+    defineMethod(LPAD, BuiltInMethod.LPAD.method, NullPolicy.NONE);
+    defineMethod(FORMAT, BuiltInMethod.FORMAT.method, NullPolicy.ARG0);
+    defineMethod(TO_VARCHAR, BuiltInMethod.TO_VARCHAR.method, NullPolicy.ARG0);
+    defineOtherFunctionMethod();
     final TrimImplementor trimImplementor = new TrimImplementor();
     defineImplementor(TRIM, NullPolicy.STRICT, trimImplementor, false);
-
+    defineMethod(DATE_MOD, BuiltInMethod.DATE_MOD.method, NullPolicy.NONE);
     // logical
     defineBinary(AND, AndAlso, NullPolicy.AND, null);
     defineBinary(OR, OrElse, NullPolicy.OR, null);
@@ -634,6 +665,33 @@ public Expression implement(RexToLixTranslator translator, RexCall call,
     });
   }
 
+  private void defineOtherFunctionMethod() {
+    defineMethod(WEEKNUMBER_OF_YEAR, BuiltInMethod.WEEKNUMBER_OF_YEAR.method, NullPolicy.NONE);
+    defineMethod(DAYOCCURRENCE_OF_MONTH, BuiltInMethod.DAYOCCURRENCE_OF_MONTH.method,
+        NullPolicy.NONE);
+    defineMethod(MONTHNUMBER_OF_QUARTER, BuiltInMethod.MONTHNUMBER_OF_QUARTER.method,
+        NullPolicy.NONE);
+    defineMethod(MONTHNUMBER_OF_YEAR, BuiltInMethod.MONTHNUMBER_OF_YEAR.method, NullPolicy.NONE);
+    defineMethod(QUARTERNUMBER_OF_YEAR, BuiltInMethod.QUARTERNUMBER_OF_YEAR.method,
+        NullPolicy.NONE);
+    defineMethod(WEEKNUMBER_OF_MONTH, BuiltInMethod.WEEKNUMBER_OF_MONTH.method, NullPolicy.NONE);
+    defineMethod(WEEKNUMBER_OF_CALENDAR, BuiltInMethod.WEEKNUMBER_OF_CALENDAR.method,
+        NullPolicy.NONE);
+    defineMethod(YEARNUMBER_OF_CALENDAR, BuiltInMethod.YEARNUMBER_OF_CALENDAR.method,
+        NullPolicy.NONE);
+    defineMethod(TIMESTAMP_TO_DATE, BuiltInMethod.TIMESTAMP_TO_DATE.method, NullPolicy.STRICT);
+    defineMethod(INSTR, BuiltInMethod.INSTR.method, NullPolicy.ARG0);
+    defineMethod(TO_BINARY, BuiltInMethod.TO_BINARY.method, NullPolicy.NONE);
+    defineMethod(TIME_SUB, BuiltInMethod.TIME_SUB.method, NullPolicy.NONE);
+    defineMethod(TO_CHAR, BuiltInMethod.TO_CHAR.method, NullPolicy.ARG0);
+    defineMethod(TIMESTAMP_SECONDS, BuiltInMethod.TIMESTAMPSECONDS.method, NullPolicy.ARG0);
+    defineMethod(TIME_DIFF, BuiltInMethod.TIME_DIFF.method, NullPolicy.NONE);
+    defineMethod(TIMESTAMPINTADD, BuiltInMethod.TIME_DIFF.method, NullPolicy.NONE);
+    defineMethod(TIMESTAMPINTSUB, BuiltInMethod.TIME_DIFF.method, NullPolicy.NONE);
+    defineMethod(DATETIME_ADD, BuiltInMethod.DATETIME_ADD.method, NullPolicy.NONE);
+    defineMethod(DATETIME_SUB, BuiltInMethod.DATETIME_SUB.method, NullPolicy.NONE);
+  }
+
   private <T> Supplier<T> constructorSupplier(Class<T> klass) {
     final Constructor<T> constructor;
     try {

core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java

@@ -35,6 +35,7 @@
 import org.apache.calcite.rel.core.Minus;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
+import org.apache.calcite.rel.core.TableFunctionScan;
 import org.apache.calcite.rel.core.TableModify;
 import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Uncollect;
@@ -53,6 +54,7 @@
 import org.apache.calcite.rex.RexProgram;
 import org.apache.calcite.sql.JoinConditionType;
 import org.apache.calcite.sql.JoinType;
+import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDelete;
 import org.apache.calcite.sql.SqlDialect;
@@ -66,12 +68,16 @@
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlUpdate;
 import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.fun.SqlCollectionTableOperator;
 import org.apache.calcite.sql.fun.SqlRowOperator;
 import org.apache.calcite.sql.fun.SqlSingleValueAggFunction;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlModality;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Pair;
@@ -88,6 +94,7 @@
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
+import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
@@ -228,8 +235,15 @@ public Result visit(Project e) {
     final List<SqlNode> selectList = new ArrayList<>();
     for (RexNode ref : e.getChildExps()) {
       SqlNode sqlExpr = builder.context.toSql(null, ref);
-      if (SqlUtil.isNullLiteral(sqlExpr, false)) {
-        sqlExpr = castNullType(sqlExpr, e.getRowType().getFieldList().get(selectList.size()));
+      RelDataTypeField targetField = e.getRowType().getFieldList().get(selectList.size());
+
+      if (SqlKind.SINGLE_VALUE == sqlExpr.getKind()) {
+        sqlExpr = dialect.rewriteSingleValueExpr(sqlExpr);
+      }
+
+      if (SqlUtil.isNullLiteral(sqlExpr, false)
+          && targetField.getType().getSqlTypeName() != SqlTypeName.NULL) {
+        sqlExpr = castNullType(sqlExpr, targetField);
       }
       addSelect(selectList, sqlExpr, e.getRowType());
     }
@@ -351,11 +365,22 @@ private List<SqlNode> generateGroupList(Builder builder,
 
     final List<SqlNode> groupKeys = new ArrayList<>();
     for (int key : groupList) {
-      final SqlNode field = builder.context.field(key);
+      boolean isGroupByAlias = dialect.getConformance().isGroupByAlias();
+      if (builder.context.field(key).getKind() == SqlKind.LITERAL
+          && dialect.getConformance().isGroupByOrdinal()) {
+        isGroupByAlias = false;
+      } /*else if (isGroupByAlias) {
+        List<SqlIdentifier> identifierList = new ArrayList<>();
+        SqlNode node = builder.context.field(key);
+        String alias = builder.context.field(key, true).toString();
+        extractSqlIdentifiers(identifierList, node);
+        isGroupByAlias = !checkIfAliasMatchesIdentifier(identifierList, alias);
+      }*/
+      SqlNode field = builder.context.field(key, isGroupByAlias);
       groupKeys.add(field);
     }
     for (int key : sortedGroupList) {
-      final SqlNode field = builder.context.field(key);
+      final SqlNode field = builder.context.field(key, false);
       addSelect(selectList, field, aggregate.getRowType());
     }
     switch (aggregate.getGroupType()) {
@@ -382,6 +407,42 @@ private List<SqlNode> generateGroupList(Builder builder,
     }
   }
 
+  /*private boolean checkIfAliasMatchesIdentifier(List<SqlIdentifier> identifierList, String alias)
+  {
+    for (SqlIdentifier node : identifierList) {
+      if (node.toString().equalsIgnoreCase(alias)) {
+        return true;
+      }
+    }
+    return false;
+  }*/
+
+  /*private void extractSqlIdentifiers(List<SqlIdentifier> identifierList, SqlNode node) {
+    if (node instanceof SqlIdentifier) {
+      identifierList.add((SqlIdentifier) node);
+    } else if (node instanceof SqlCase) {
+      SqlCase caseNode = (SqlCase) node;
+      SqlNode exprNode = caseNode.getValueOperand();
+      SqlNodeList whenList = caseNode.getWhenOperands();
+      SqlNodeList thenList = caseNode.getThenOperands();
+      SqlNode elseNode = caseNode.getElseOperand();
+      if (null != exprNode) {
+        extractSqlIdentifiers(identifierList, exprNode);
+      }
+      whenList.forEach(whenNode ->
+          extractSqlIdentifiers(identifierList, whenNode));
+      thenList.forEach(thenNode ->
+          extractSqlIdentifiers(identifierList, thenNode));
+      if (null != elseNode) {
+        extractSqlIdentifiers(identifierList, elseNode);
+      }
+    } else if (node instanceof SqlBasicCall) {
+      List<SqlNode> nodeList = Arrays.asList(((SqlBasicCall) node).operands);
+      nodeList.forEach(sqlNode ->
+          extractSqlIdentifiers(identifierList, sqlNode));
+    }
+  }*/
+
   private SqlNode groupItem(List<SqlNode> groupKeys,
       ImmutableBitSet groupSet, ImmutableBitSet wholeGroupSet) {
     final List<SqlNode> nodes = groupSet.asList().stream()
@@ -627,6 +688,38 @@ public Result visit(Sort e) {
     return x;
   }
 
+  public Result visit(TableFunctionScan e) {
+    List<RelDataTypeField> fieldList = e.getRowType().getFieldList();
+    if (fieldList == null || fieldList.size() > 1) {
+      throw new RuntimeException("Table function supports only one argument");
+    }
+    final List<SqlNode> inputSqlNodes = new ArrayList<>();
+    final int inputSize = e.getInputs().size();
+    for (int i = 0; i < inputSize; i++) {
+      Result child = visitChild(i, e.getInput(i));
+      inputSqlNodes.add(child.asStatement());
+    }
+    final Context context = tableFunctionScanContext(inputSqlNodes);
+    SqlNode callNode = context.toSql(null, e.getCall());
+    // Convert to table function call, "TABLE($function_name(xxx))"
+    SqlSpecialOperator collectionTable = new SqlCollectionTableOperator("TABLE",
+            SqlModality.RELATION, e.getRowType().getFieldNames().get(0));
+    SqlNode tableCall = new SqlBasicCall(
+            collectionTable,
+            new SqlNode[]{callNode},
+            SqlParserPos.ZERO);
+    SqlNode select = new SqlSelect(
+            SqlParserPos.ZERO, null, null, tableCall,
+            null, null, null, null, null, null, null);
+    Map<String, RelDataType> aliasesMap = new HashMap<>();
+    RelDataTypeField relDataTypeField = fieldList.get(0);
+    aliasesMap.put(relDataTypeField.getName(), e.getRowType());
+    Result x = new Result(select,
+            ImmutableList.of(Clause.SELECT),
+            relDataTypeField.getName(), e.getRowType(), aliasesMap);
+    return x;
+  }
+
   Result offsetFetch(Sort e, Result x) {
     if (e.fetch != null) {
       final Builder builder = x.builder(e, Clause.FETCH);