michaelmior commented on a change in pull request #2111:
URL: https://github.com/apache/calcite/pull/2111#discussion_r475101004
##########
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:
I'm not sure I see how the coupling would be increased. I'm really just
talking about having a type for the hint.
----------------------------------------------------------------
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]
