julianhyde commented on a change in pull request #2111:
URL: https://github.com/apache/calcite/pull/2111#discussion_r476237132
##########
File path:
core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java
##########
@@ -285,66 +286,95 @@ public static SqlOperatorTable operatorTable(String...
classNames) {
className, "*", true);
}
- // The following is technical debt; see [CALCITE-2082] Remove
- // RelDataTypeFactory argument from SqlUserDefinedAggFunction constructor
- final SqlTypeFactoryImpl typeFactory =
- new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
-
final ListSqlOperatorTable table = new ListSqlOperatorTable();
for (String name : schema.getFunctionNames()) {
- for (Function function : schema.getFunctions(name, true)) {
+ schema.getFunctions(name, true).forEach(function -> {
final SqlIdentifier id = new SqlIdentifier(name, SqlParserPos.ZERO);
- table.add(
- toOp(typeFactory, id, function));
- }
+ table.add(toOp(id, function));
+ });
}
return table;
}
- private SqlOperator toOp(SqlIdentifier name, final Function function) {
- return toOp(typeFactory, name, function);
- }
-
- /** Converts a function to a {@link org.apache.calcite.sql.SqlOperator}.
- *
- * <p>The {@code typeFactory} argument is technical debt; see [CALCITE-2082]
- * Remove RelDataTypeFactory argument from SqlUserDefinedAggFunction
- * constructor. */
- private static SqlOperator toOp(RelDataTypeFactory typeFactory,
- SqlIdentifier name, final Function function) {
- List<RelDataType> argTypes = new ArrayList<>();
- List<SqlTypeFamily> typeFamilies = new ArrayList<>();
- for (FunctionParameter o : function.getParameters()) {
- final RelDataType type = o.getType(typeFactory);
- argTypes.add(type);
- typeFamilies.add(
- Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY));
- }
- final FamilyOperandTypeChecker typeChecker =
- OperandTypes.family(typeFamilies, i ->
- function.getParameters().get(i).isOptional());
- final List<RelDataType> paramTypes = toSql(typeFactory, argTypes);
+ /** Converts a function to a {@link org.apache.calcite.sql.SqlOperator}. */
+ private static SqlOperator toOp(SqlIdentifier name,
+ final org.apache.calcite.schema.Function function) {
+ final Function<RelDataTypeFactory, List<RelDataType>> argTypesFactory =
+ typeFactory -> function.getParameters()
+ .stream()
+ .map(o -> o.getType(typeFactory))
+ .collect(Util.toImmutableList());
+ final Function<RelDataTypeFactory, List<SqlTypeFamily>>
typeFamiliesFactory =
+ typeFactory -> argTypesFactory.apply(typeFactory)
+ .stream()
+ .map(type ->
+ Util.first(type.getSqlTypeName().getFamily(),
+ SqlTypeFamily.ANY))
+ .collect(Util.toImmutableList());
+ final Function<RelDataTypeFactory, List<RelDataType>> paramTypesFactory =
+ typeFactory ->
+ argTypesFactory.apply(typeFactory)
+ .stream()
+ .map(type -> toSql(typeFactory, type))
+ .collect(Util.toImmutableList());
+
+ // Use a short-lived type factory to populate "typeFamilies" and
"argTypes".
+ // SqlOperandMetadata.paramTypes will use the real type factory, during
+ // validation.
+ final RelDataTypeFactory dummyTypeFactory = new JavaTypeFactoryImpl();
+ final List<RelDataType> argTypes = argTypesFactory.apply(dummyTypeFactory);
+ final List<SqlTypeFamily> typeFamilies =
+ typeFamiliesFactory.apply(dummyTypeFactory);
+
+ final SqlOperandTypeInference operandTypeInference =
+ InferTypes.explicit(argTypes);
+
+ final SqlOperandMetadata operandMetadata =
+ OperandTypes.operandMetadata(typeFamilies, paramTypesFactory,
+ i -> function.getParameters().get(i).getName(),
+ i -> function.getParameters().get(i).isOptional());
+
+ final SqlKind kind = kind(function);
if (function instanceof ScalarFunction) {
- return new SqlUserDefinedFunction(name, infer((ScalarFunction) function),
- InferTypes.explicit(argTypes), typeChecker, paramTypes, function);
+ final SqlReturnTypeInference returnTypeInference =
+ infer((ScalarFunction) function);
+ return new SqlUserDefinedFunction(name, kind, returnTypeInference,
+ operandTypeInference, operandMetadata, function);
} else if (function instanceof AggregateFunction) {
- return new SqlUserDefinedAggFunction(name,
- infer((AggregateFunction) function), InferTypes.explicit(argTypes),
- typeChecker, (AggregateFunction) function, false, false,
- Optionality.FORBIDDEN, typeFactory);
+ final SqlReturnTypeInference returnTypeInference =
+ infer((AggregateFunction) function);
+ return new SqlUserDefinedAggFunction(name, kind,
+ returnTypeInference, operandTypeInference,
+ operandMetadata, (AggregateFunction) function, false, false,
+ Optionality.FORBIDDEN);
} else if (function instanceof TableMacro) {
- return new SqlUserDefinedTableMacro(name, ReturnTypes.CURSOR,
- InferTypes.explicit(argTypes), typeChecker, paramTypes,
- (TableMacro) function);
+ return new SqlUserDefinedTableMacro(name, kind, ReturnTypes.CURSOR,
+ operandTypeInference, operandMetadata, (TableMacro) function);
} else if (function instanceof TableFunction) {
- return new SqlUserDefinedTableFunction(name, ReturnTypes.CURSOR,
- InferTypes.explicit(argTypes), typeChecker, paramTypes,
- (TableFunction) function);
+ return new SqlUserDefinedTableFunction(name, kind, ReturnTypes.CURSOR,
+ operandTypeInference, operandMetadata, (TableFunction) function);
} else {
throw new AssertionError("unknown function type " + function);
}
}
+ /** Deduces the {@link org.apache.calcite.sql.SqlKind} of a user-defined
+ * function based on a {@link Hints} annotation, if present. */
+ private static SqlKind kind(org.apache.calcite.schema.Function function) {
+ if (function instanceof ScalarFunctionImpl) {
+ Hints hints =
+ ((ScalarFunctionImpl) function).method.getAnnotation(Hints.class);
+ if (hints != null) {
+ for (String hint : hints.value()) {
+ if (hint.startsWith("SqlKind:")) {
+ return SqlKind.valueOf(hint.substring("SqlKind:".length()));
Review comment:
Yeah, fair point. I didn't want to overthink this, so I marked it
'experimental'.
Maybe you're right that we should more strongly type the hint. If so, we
will iterate in that direction.
I think you'll agree that if someone wants a function with a particular
SqlKind, it's better to allow them to write it as a UDF (and have some means,
such as annotation, to link the function to the SqlKind) than to require them
to sub-class SqlFunction. That's all I meant by 'less coupling'.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
