DRILL-4047: add function category for table functions

julienledem · julienledem · commit 5562628d884b · 2015-11-24T15:32:15.000-08:00
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
@@ -1846,13 +1846,13 @@ void ColumnType(List<SqlNode> list) :
 SqlNode TableFunctionCall(SqlParserPos pos) :
 {
     SqlNode call;
-    SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
+    SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION;
 }
 {
     [
         <SPECIFIC>
         {
-            funcType = SqlFunctionCategory.USER_DEFINED_SPECIFIC_FUNCTION;
+            funcType = SqlFunctionCategory.USER_DEFINED_TABLE_SPECIFIC_FUNCTION;
         }
     ]
     {
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java b/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java
@@ -60,6 +60,7 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NavigableSet;
@@ -234,6 +235,18 @@ public void lookupOperatorOverloads(final SqlIdentifier opName,
       return;
     }
     final Collection<Function> functions = getFunctionsFrom(opName.names);
+    for (Iterator<Function> iterator = functions.iterator(); iterator.hasNext();) {
+      Function function = iterator.next();
+      if (function instanceof TableMacro || function instanceof TableFunction) {
+        if (category == null || !category.isTableFunction()) {
+          iterator.remove();
+        }
+      } else {
+        if (category != null && category.isTableFunction()) {
+          iterator.remove();
+        }
+      }
+    }
     if (functions.isEmpty()) {
       return;
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java b/core/src/main/java/org/apache/calcite/rel/externalize/RelJson.java
@@ -338,11 +338,7 @@ private Object toJson(RexNode node) {
           map.put("type", toJson(node.getType()));
         }
         if (call.getOperator() instanceof SqlFunction) {
-          switch (((SqlFunction) call.getOperator()).getFunctionType()) {
-          case USER_DEFINED_CONSTRUCTOR:
-          case USER_DEFINED_FUNCTION:
-          case USER_DEFINED_PROCEDURE:
-          case USER_DEFINED_SPECIFIC_FUNCTION:
+          if (((SqlFunction) call.getOperator()).getFunctionType().isUserdefined()) {
             map.put("class", call.getOperator().getClass().getName());
           }
         }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java b/core/src/main/java/org/apache/calcite/sql/SqlFunctionCategory.java
@@ -31,12 +31,53 @@ public enum SqlFunctionCategory {
   USER_DEFINED_PROCEDURE("UDP", "User-defined procedure"),
   USER_DEFINED_CONSTRUCTOR("UDC", "User-defined constructor"),
   USER_DEFINED_SPECIFIC_FUNCTION("UDF_SPECIFIC",
-      "User-defined function with SPECIFIC name");
+      "User-defined function with SPECIFIC name"),
+  USER_DEFINED_TABLE_FUNCTION("TABLE_UDF", "User-defined table function"),
+  USER_DEFINED_TABLE_SPECIFIC_FUNCTION("TABLE_UDF_SPECIFIC",
+      "User-defined table function with SPECIFIC name");
 
   SqlFunctionCategory(String abbrev, String description) {
     Util.discard(abbrev);
     Util.discard(description);
   }
+
+  public final boolean isUserdefined() {
+    return isOneOf(
+        USER_DEFINED_FUNCTION,
+        USER_DEFINED_PROCEDURE,
+        USER_DEFINED_CONSTRUCTOR,
+        USER_DEFINED_SPECIFIC_FUNCTION,
+        USER_DEFINED_TABLE_FUNCTION,
+        USER_DEFINED_TABLE_SPECIFIC_FUNCTION);
+  }
+
+  public final boolean isTableFunction() {
+    return isOneOf(
+        USER_DEFINED_TABLE_FUNCTION,
+        USER_DEFINED_TABLE_SPECIFIC_FUNCTION);
+  }
+
+  public final boolean isSpecific() {
+    return isOneOf(
+        USER_DEFINED_SPECIFIC_FUNCTION,
+        USER_DEFINED_TABLE_SPECIFIC_FUNCTION);
+  }
+
+  public final boolean isUnresolvedUserDefinedFunction() {
+    return isOneOf(
+        USER_DEFINED_FUNCTION,
+        USER_DEFINED_TABLE_FUNCTION);
+  }
+
+  public final boolean isOneOf(SqlFunctionCategory... categories) {
+    for (SqlFunctionCategory category : categories) {
+      if (category == this) {
+        return true;
+      }
+    }
+    return false;
+  }
+
 }
 
 // End SqlFunctionCategory.java
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUtil.java b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
@@ -228,8 +228,7 @@ public static void unparseFunctionSyntax(
     if (operator instanceof SqlFunction) {
       SqlFunction function = (SqlFunction) operator;
 
-      switch (function.getFunctionType()) {
-      case USER_DEFINED_SPECIFIC_FUNCTION:
+      if (function.getFunctionType().isSpecific()) {
         writer.keyword("SPECIFIC");
       }
       SqlIdentifier id = function.getSqlIdentifier();
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java
@@ -361,7 +361,7 @@ protected SqlCall createCall(
     /// name when regenerating SQL).
     if (funName.isSimple()) {
       final List<SqlOperator> list = Lists.newArrayList();
-      opTab.lookupOperatorOverloads(funName, null, SqlSyntax.FUNCTION, list);
+      opTab.lookupOperatorOverloads(funName, funcType, SqlSyntax.FUNCTION, list);
       if (list.size() == 1) {
         fun = list.get(0);
       }
diff --git a/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java
@@ -69,8 +69,7 @@ public void lookupOperatorOverloads(SqlIdentifier opName,
       } else {
         functionCategory = SqlFunctionCategory.SYSTEM;
       }
-      if (category != functionCategory
-          && category != SqlFunctionCategory.USER_DEFINED_FUNCTION) {
+      if (category != functionCategory && !category.isUnresolvedUserDefinedFunction()) {
         continue;
       }
       operatorList.add(operator);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AggFinder.java b/core/src/main/java/org/apache/calcite/sql/validate/AggFinder.java
@@ -18,15 +18,16 @@
 
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
-import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
-import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.util.SqlBasicVisitor;
 import org.apache.calcite.util.Util;
 
+import static org.apache.calcite.sql.SqlKind.QUERY;
+import static org.apache.calcite.sql.SqlSyntax.FUNCTION;
+
 import com.google.common.collect.Lists;
 
 import java.util.List;
@@ -91,19 +92,20 @@ public Void visit(SqlCall call) {
       throw new Util.FoundOne(call);
     }
     // User-defined function may not be resolved yet.
-    if (operator instanceof SqlFunction
-        && ((SqlFunction) operator).getFunctionType()
-        == SqlFunctionCategory.USER_DEFINED_FUNCTION) {
-      final List<SqlOperator> list = Lists.newArrayList();
-      opTab.lookupOperatorOverloads(((SqlFunction) operator).getSqlIdentifier(),
-          SqlFunctionCategory.USER_DEFINED_FUNCTION, SqlSyntax.FUNCTION, list);
-      for (SqlOperator sqlOperator : list) {
-        if (sqlOperator.isAggregator()) {
-          throw new Util.FoundOne(call);
+    if (operator instanceof SqlFunction) {
+      SqlFunction sqlFunction = (SqlFunction) operator;
+      if (sqlFunction.getFunctionType().isUnresolvedUserDefinedFunction()) {
+        final List<SqlOperator> list = Lists.newArrayList();
+        opTab.lookupOperatorOverloads(sqlFunction.getSqlIdentifier(),
+            sqlFunction.getFunctionType(), FUNCTION, list);
+        for (SqlOperator sqlOperator : list) {
+          if (sqlOperator.isAggregator()) {
+            throw new Util.FoundOne(call);
+          }
         }
       }
     }
-    if (call.isA(SqlKind.QUERY)) {
+    if (call.isA(QUERY)) {
       // don't traverse into queries
       return null;
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedFunction.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedFunction.java
@@ -47,9 +47,25 @@ public SqlUserDefinedFunction(SqlIdentifier opName,
       SqlOperandTypeChecker operandTypeChecker,
       List<RelDataType> paramTypes,
       Function function) {
+    this(opName,
+        returnTypeInference,
+        operandTypeInference,
+        operandTypeChecker,
+        paramTypes,
+        function,
+        SqlFunctionCategory.USER_DEFINED_FUNCTION);
+  }
+
+  public SqlUserDefinedFunction(SqlIdentifier opName,
+      SqlReturnTypeInference returnTypeInference,
+      SqlOperandTypeInference operandTypeInference,
+      SqlOperandTypeChecker operandTypeChecker,
+      List<RelDataType> paramTypes,
+      Function function,
+      SqlFunctionCategory category) {
     super(Util.last(opName.names), opName, SqlKind.OTHER_FUNCTION,
         returnTypeInference, operandTypeInference, operandTypeChecker,
-        paramTypes, SqlFunctionCategory.USER_DEFINED_FUNCTION);
+        paramTypes, category);
     this.function = function;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedTableFunction.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedTableFunction.java
@@ -19,6 +19,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.schema.TableFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.type.SqlOperandTypeChecker;
@@ -42,7 +43,7 @@ public SqlUserDefinedTableFunction(SqlIdentifier opName,
       List<RelDataType> paramTypes,
       TableFunction function) {
     super(opName, returnTypeInference, operandTypeInference, operandTypeChecker,
-        paramTypes, function);
+        paramTypes, function, SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedTableMacro.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlUserDefinedTableMacro.java
@@ -70,7 +70,7 @@ public SqlUserDefinedTableMacro(SqlIdentifier opName,
     super(Util.last(opName.names), opName, SqlKind.OTHER_FUNCTION,
         returnTypeInference, operandTypeInference, operandTypeChecker,
         Preconditions.checkNotNull(paramTypes),
-        SqlFunctionCategory.USER_DEFINED_FUNCTION);
+        SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
     this.tableMacro = tableMacro;
   }
 

Original file line number	Diff line number	Diff line change
`@@ -1846,13 +1846,13 @@ void ColumnType(List<SqlNode> list) :`
`1846`	`1846`	`SqlNode TableFunctionCall(SqlParserPos pos) :`
`1847`	`1847`	`{`
`1848`	`1848`	`SqlNode call;`
`1849`		`- SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;`
	`1849`	`+ SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION;`
`1850`	`1850`	`}`
`1851`	`1851`	`{`
`1852`	`1852`	`[`
`1853`	`1853`	`<SPECIFIC>`
`1854`	`1854`	`{`
`1855`		`- funcType = SqlFunctionCategory.USER_DEFINED_SPECIFIC_FUNCTION;`
	`1855`	`+ funcType = SqlFunctionCategory.USER_DEFINED_TABLE_SPECIFIC_FUNCTION;`
`1856`	`1856`	`}`
`1857`	`1857`	`]`
`1858`	`1858`	`{`
Original file line number	Diff line number	Diff line change
`@@ -338,11 +338,7 @@ private Object toJson(RexNode node) {`
`338`	`338`	`map.put("type", toJson(node.getType()));`
`339`	`339`	`}`
`340`	`340`	`if (call.getOperator() instanceof SqlFunction) {`
`341`		`- switch (((SqlFunction) call.getOperator()).getFunctionType()) {`
`342`		`- case USER_DEFINED_CONSTRUCTOR:`
`343`		`- case USER_DEFINED_FUNCTION:`
`344`		`- case USER_DEFINED_PROCEDURE:`
`345`		`- case USER_DEFINED_SPECIFIC_FUNCTION:`
	`341`	`+ if (((SqlFunction) call.getOperator()).getFunctionType().isUserdefined()) {`
`346`	`342`	`map.put("class", call.getOperator().getClass().getName());`
`347`	`343`	`}`
`348`	`344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -228,8 +228,7 @@ public static void unparseFunctionSyntax(`
`228`	`228`	`if (operator instanceof SqlFunction) {`
`229`	`229`	`SqlFunction function = (SqlFunction) operator;`
`230`	`230`
`231`		`- switch (function.getFunctionType()) {`
`232`		`- case USER_DEFINED_SPECIFIC_FUNCTION:`
	`231`	`+ if (function.getFunctionType().isSpecific()) {`
`233`	`232`	`writer.keyword("SPECIFIC");`
`234`	`233`	`}`
`235`	`234`	`SqlIdentifier id = function.getSqlIdentifier();`
Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ protected SqlCall createCall(`
`361`	`361`	`/// name when regenerating SQL).`
`362`	`362`	`if (funName.isSimple()) {`
`363`	`363`	`final List<SqlOperator> list = Lists.newArrayList();`
`364`		`- opTab.lookupOperatorOverloads(funName, null, SqlSyntax.FUNCTION, list);`
	`364`	`+ opTab.lookupOperatorOverloads(funName, funcType, SqlSyntax.FUNCTION, list);`
`365`	`365`	`if (list.size() == 1) {`
`366`	`366`	`fun = list.get(0);`
`367`	`367`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,7 @@ public void lookupOperatorOverloads(SqlIdentifier opName,`
`69`	`69`	`} else {`
`70`	`70`	`functionCategory = SqlFunctionCategory.SYSTEM;`
`71`	`71`	`}`
`72`		`- if (category != functionCategory`
`73`		`- && category != SqlFunctionCategory.USER_DEFINED_FUNCTION) {`
	`72`	`+ if (category != functionCategory && !category.isUnresolvedUserDefinedFunction()) {`
`74`	`73`	`continue;`
`75`	`74`	`}`
`76`	`75`	`operatorList.add(operator);`