import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitTablesBasedOnNullaryFunctionsToBuilder(
        ImmutableSortedMap.Builder<String, Table> builder) {
    ImmutableSortedMap<String, Table> explicitTables = builder.build();

    for (String s : implicitFunctionCache.get(System.currentTimeMillis())) {
        // explicit table wins.
        if (explicitTables.containsKey(s)) {
            continue;
        }
        for (Function function : getSchema().getFunctions(s)) {
            if (function instanceof TableMacro
                    && function.getParameters().isEmpty()) {
                final Table table = ((TableMacro) function).apply(ImmutableList.of());
                builder.put(s, table);
            }
        }
    }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
                                                            boolean caseSensitive) {
    final NavigableSet<String> set =
            implicitFunctionCache.get(System.currentTimeMillis());
    for (String s : find(set, tableName)) {
        for (Function function : getSchema().getFunctions(s)) {
            if (function instanceof TableMacro
                    && function.getParameters().isEmpty()) {
                final Table table =
                        ((TableMacro) function).apply(ImmutableList.of());
                return tableEntry(tableName, table);
            }
        }
    }
    return null;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitTablesBasedOnNullaryFunctionsToBuilder(
        ImmutableSortedMap.Builder<String, Table> builder) {
    ImmutableSortedMap<String, Table> explicitTables = builder.build();

    for (String s : getSchema().getFunctionNames()) {
        // explicit table wins.
        if (explicitTables.containsKey(s)) {
            continue;
        }
        for (Function function : getSchema().getFunctions(s)) {
            if (function instanceof TableMacro
                    && function.getParameters().isEmpty()) {
                final Table table = ((TableMacro) function).apply(ImmutableList.of());
                builder.put(s, table);
            }
        }
    }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
private void handleCreateFunction(SqlCreateFunction sqlCreateFunction) throws ClassNotFoundException {
  if(sqlCreateFunction.jarName() != null) {
    throw new UnsupportedOperationException("UDF 'USING JAR' not implemented");
  }
  Method method;
  Function function;
  if ((method=findMethod(sqlCreateFunction.className(), "evaluate")) != null) {
    function = ScalarFunctionImpl.create(method);
  } else if (findMethod(sqlCreateFunction.className(), "add") != null) {
    function = AggregateFunctionImpl.create(Class.forName(sqlCreateFunction.className()));
  } else {
    throw new RuntimeException("Invalid scalar or aggregate function");
  }
  schema.add(sqlCreateFunction.functionName().toUpperCase(), function);
  hasUdf = true;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
public void execute(CalcitePrepare.Context context) {
  final Pair<CalciteSchema, String> pair =
      SqlDdlNodes.schema(context, true, name);
  final SchemaPlus schemaPlus = pair.left.plus();
  for (Function function : schemaPlus.getFunctions(pair.right)) {
    if (function.getParameters().isEmpty()) {
      if (!getReplace()) {
        throw SqlUtil.newContextException(name.getParserPosition(),
            RESOURCE.viewExists(pair.right));
      }
      pair.left.removeFunction(pair.right);
    }
  }
  final SqlNode q = SqlDdlNodes.renameColumns(columnList, query);
  final String sql = q.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
  final ViewTableMacro viewTableMacro =
      ViewTable.viewMacro(schemaPlus, sql, pair.left.path(null),
          context.getObjectPath(), false);
  final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
  Util.discard(x);
  schemaPlus.add(pair.right, viewTableMacro);
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitTablesBasedOnNullaryFunctionsToBuilder(
    ImmutableSortedMap.Builder<String, Table> builder) {
  ImmutableSortedMap<String, Table> explicitTables = builder.build();

  final long now = System.currentTimeMillis();
  final NameSet set = implicitFunctionCache.get(now);
  for (String s : set.iterable()) {
    // explicit table wins.
    if (explicitTables.containsKey(s)) {
      continue;
    }
    for (Function function : schema.getFunctions(s)) {
      if (function instanceof TableMacro
          && function.getParameters().isEmpty()) {
        final Table table = ((TableMacro) function).apply(ImmutableList.of());
        builder.put(s, table);
      }
    }
  }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
    boolean caseSensitive) {
  final long now = System.currentTimeMillis();
  final NameSet set = implicitFunctionCache.get(now);
  for (String s : set.range(tableName, caseSensitive)) {
    for (Function function : schema.getFunctions(s)) {
      if (function instanceof TableMacro
          && function.getParameters().isEmpty()) {
        final Table table =
            ((TableMacro) function).apply(ImmutableList.of());
        return tableEntry(tableName, table);
      }
    }
  }
  return null;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitTablesBasedOnNullaryFunctionsToBuilder(
    ImmutableSortedMap.Builder<String, Table> builder) {
  ImmutableSortedMap<String, Table> explicitTables = builder.build();

  for (String s : schema.getFunctionNames()) {
    // explicit table wins.
    if (explicitTables.containsKey(s)) {
      continue;
    }
    for (Function function : schema.getFunctions(s)) {
      if (function instanceof TableMacro
          && function.getParameters().isEmpty()) {
        final Table table = ((TableMacro) function).apply(ImmutableList.of());
        builder.put(s, table);
      }
    }
  }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
/** Creates an operator table that contains functions in the given class.
 *
 * @see ModelHandler#addFunctions */
public static SqlOperatorTable operatorTable(String className) {
  // Dummy schema to collect the functions
  final CalciteSchema schema =
      CalciteSchema.createRootSchema(false, false);
  ModelHandler.addFunctions(schema.plus(), null, ImmutableList.<String>of(),
      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)) {
      final SqlIdentifier id = new SqlIdentifier(name, SqlParserPos.ZERO);
      table.add(
          toOp(typeFactory, id, function));
    }
  }
  return table;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
private Multimap<String, Function> createFunctionMap() {
  final ImmutableMultimap.Builder<String, Function> builder =
      ImmutableMultimap.builder();
  for (Method method : clazz.getMethods()) {
    final String methodName = method.getName();
    if (method.getDeclaringClass() == Object.class
        || methodName.equals("toString")) {
      continue;
    }
    if (TranslatableTable.class.isAssignableFrom(method.getReturnType())) {
      final TableMacro tableMacro =
          new MethodTableMacro(this, method);
      builder.put(methodName, tableMacro);
    }
  }
  return builder.build();
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
/**
 * Converts arguments from {@link org.apache.calcite.sql.SqlNode} to
 * java object format.
 *
 * @param typeFactory type factory used to convert the arguments
 * @param operandList input arguments
 * @param function target function to get parameter types from
 * @param opName name of the operator to use in error message
 * @param failOnNonLiteral true when conversion should fail on non-literal
 * @return converted list of arguments
 */
public static List<Object> convertArguments(RelDataTypeFactory typeFactory,
    List<SqlNode> operandList, Function function,
    SqlIdentifier opName,
    boolean failOnNonLiteral) {
  List<Object> arguments = new ArrayList<>(operandList.size());
  // Construct a list of arguments, if they are all constants.
  for (Pair<FunctionParameter, SqlNode> pair
      : Pair.zip(function.getParameters(), operandList)) {
    try {
      final Object o = getValue(pair.right);
      final Object o2 = coerce(o, pair.left.getType(typeFactory));
      arguments.add(o2);
    } catch (NonLiteralException e) {
      if (failOnNonLiteral) {
        throw new IllegalArgumentException("All arguments of call to macro "
            + opName + " should be literal. Actual argument #"
            + pair.left.getOrdinal() + " (" + pair.left.getName()
            + ") is not literal: " + pair.right);
      }
      arguments.add(null);
    }
  }
  return arguments;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
public List<Function> getFunctions(final List<String> tableSchemaPath, final FileSystemPlugin plugin, final SchemaConfig schemaConfig) {
  List<TableSignature> sigs = getTableSignatures(tableSchemaPath.get(tableSchemaPath.size() - 1));
  return FluentIterable.from(sigs).transform(new com.google.common.base.Function<TableSignature, Function>() {
    @Override
    public Function apply(TableSignature input) {
      return new WithOptionsTableMacro(tableSchemaPath, input, plugin, schemaConfig);
    }
  }).toList();
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
private Set<String> rawTableNames() {
  return newHashSet(
      transform(tables.keySet(), new com.google.common.base.Function<TableInstance, String>() {
    @Override
    public String apply(TableInstance input) {
      return input.sig.name;
    }
  }));
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
@Override
public List<Function> getFunctions(String name) {
  List<TableSignature> sigs = optionExtractor.getTableSignatures(name);
  return Lists.transform(sigs, new com.google.common.base.Function<TableSignature, Function>() {
    @Override
    public Function apply(TableSignature input) {
      return new WithOptionsTableMacro(input, WorkspaceSchema.this);
    }
  });
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitFunctionToBuilder(
        ImmutableList.Builder<Function> builder) {
    // Add implicit functions, case-insensitive.
    for (String name2
            : find(implicitFunctionCache.get(System.currentTimeMillis()), getName())) {
        final Collection<Function> functions = getSchema().getFunctions(name2);
        if (functions != null) {
            builder.addAll(functions);
        }
    }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
                                                            boolean caseSensitive) {
    for (String s : getSchema().getFunctionNames()) {
        for (Function function : getSchema().getFunctions(s)) {
            if (function instanceof TableMacro
                    && function.getParameters().isEmpty()) {
                final Table table = ((TableMacro) function).apply(ImmutableList.of());
                return tableEntry(tableName, table);
            }
        }
    }
    return null;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
private FunctionEntry add(String funcName, Function function) {
    final FunctionEntryImpl entry =
            new FunctionEntryImpl(this, funcName, function);
    functionMap.put(funcName, entry);
    functionNames.add(funcName);
    if (function.getParameters().isEmpty()) {
        nullaryFunctionMap.put(funcName, entry);
    }
    return entry;
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitFunctionsToBuilder(
    ImmutableList.Builder<Function> builder,
    String name, boolean caseSensitive) {
  // Add implicit functions, case-insensitive.
  final long now = System.currentTimeMillis();
  final NameSet set = implicitFunctionCache.get(now);
  for (String name2 : set.range(name, caseSensitive)) {
    final Collection<Function> functions = schema.getFunctions(name2);
    if (functions != null) {
      builder.addAll(functions);
    }
  }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected void addImplicitFunctionsToBuilder(
    ImmutableList.Builder<Function> builder,
    String name, boolean caseSensitive) {
  Collection<Function> functions = schema.getFunctions(name);
  if (functions != null) {
    builder.addAll(functions);
  }
}
 

import org.apache.calcite.schema.Function; //导入依赖的package包/类
protected TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
    boolean caseSensitive) {
  Collection<Function> functions = schema.getFunctions(tableName);
  if (functions != null) {
    for (Function function : functions) {
      if (function instanceof TableMacro
          && function.getParameters().isEmpty()) {
        final Table table = ((TableMacro) function).apply(ImmutableList.of());
        return tableEntry(tableName, table);
      }
    }
  }
  return null;
}