import org.apache.calcite.schema.TranslatableTable; //导入依赖的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.TranslatableTable; //导入依赖的package包/类
RelNode toRel(Queryable<T> queryable) {
  if (queryable instanceof QueryableDefaults.Replayable) {
    //noinspection unchecked
    ((QueryableDefaults.Replayable) queryable).replay(this);
    return rel;
  }
  if (queryable instanceof AbstractTableQueryable) {
    final AbstractTableQueryable tableQueryable =
        (AbstractTableQueryable) queryable;
    final QueryableTable table = tableQueryable.table;
    final CalciteSchema.TableEntry tableEntry =
        CalciteSchema.from(tableQueryable.schema)
            .add(tableQueryable.tableName, tableQueryable.table);
    final RelOptTableImpl relOptTable =
        RelOptTableImpl.create(null, table.getRowType(translator.typeFactory),
            tableEntry, null);
    if (table instanceof TranslatableTable) {
      return ((TranslatableTable) table).toRel(translator, relOptTable);
    } else {
      return LogicalTableScan.create(translator.cluster, relOptTable);
    }
  }
  return translator.translate(queryable.getExpression());
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的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.TranslatableTable; //导入依赖的package包/类
public TranslatableTable apply(List<Object> arguments) {
  final CalciteConnection connection =
      MaterializedViewTable.MATERIALIZATION_CONNECTION;
  CalcitePrepare.AnalyzeViewResult parsed =
      Schemas.analyzeView(connection, schema, schemaPath, viewSql, viewPath,
          modifiable != null && modifiable);
  final List<String> schemaPath1 =
      schemaPath != null ? schemaPath : schema.path(null);
  if ((modifiable == null || modifiable)
      && parsed.modifiable
      && parsed.table != null) {
    return modifiableViewTable(parsed, viewSql, schemaPath1, viewPath, schema);
  } else {
    return viewTable(parsed, viewSql, schemaPath1, viewPath);
  }
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
@Override
public TranslatableTable apply(final List<Object> arguments) {
  try {
    SourceTableDefinition definition = plugin.getStoragePlugin2().getDatasetWithOptions(new NamespaceKey
        (tableSchemaPath),
      new TableInstance(sig, arguments), schemaConfig.getIgnoreAuthErrors(), schemaConfig.getUserName());
    if(definition == null){
      throw UserException.validationError().message("Unable to read table %s using provided options.",  new NamespaceKey(tableSchemaPath).toString()).build(logger);
    }
    return new MaterializedDatasetTable(plugin, schemaConfig.getUserName(), new QuietAccessor(definition));

  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
@Override
public TranslatableTable apply(List<Object> arguments) {
  DrillTable drillTable = schema.getDrillTable(new TableInstance(sig, arguments));
  if (drillTable == null) {
    throw UserException
        .validationError()
        .message("Unable to find table [%s] in schema [%s]", sig.name, schema.getFullSchemaName())
        .build(logger);
}
  return new DrillTranslatableTable(drillTable);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public void execute(CalcitePrepare.Context context) {
  final Pair<CalciteSchema, String> pair =
      SqlDdlNodes.schema(context, true, name);
  if (pair.left.plus().getTable(pair.right) != null) {
    // Materialized view exists.
    if (!ifNotExists) {
      // They did not specify IF NOT EXISTS, so give error.
      throw SqlUtil.newContextException(name.getParserPosition(),
          RESOURCE.tableExists(pair.right));
    }
    return;
  }
  final SqlNode q = SqlDdlNodes.renameColumns(columnList, query);
  final String sql = q.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
  final List<String> schemaPath = pair.left.path(null);
  final ViewTableMacro viewTableMacro =
      ViewTable.viewMacro(pair.left.plus(), sql, schemaPath,
          context.getObjectPath(), false);
  final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
  final RelDataType rowType = x.getRowType(context.getTypeFactory());

  // Table does not exist. Create it.
  final MaterializedViewTable table =
      new MaterializedViewTable(pair.right, RelDataTypeImpl.proto(rowType));
  pair.left.add(pair.right, table);
  SqlDdlNodes.populate(name, query, context);
  table.key =
      MaterializationService.instance().defineMaterialization(pair.left, null,
          sql, schemaPath, pair.right, true, true);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public TranslatableTable apply(final List<Object> arguments) {
  try {
    final Object o = method.invoke(schema.getTarget(), arguments.toArray());
    return (TranslatableTable) o;
  } catch (IllegalAccessException | InvocationTargetException e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
/** Returns the table in this UDF, or null if there is no table. */
public TranslatableTable getTable(RelDataTypeFactory typeFactory,
    List<SqlNode> operandList) {
  List<Object> arguments = convertArguments(typeFactory, operandList,
      tableMacro, getNameAsId(), true);
  return tableMacro.apply(arguments);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
/** Creates a {@code TableMacro} from a method. */
public static TableMacro create(final Method method) {
  Class clazz = method.getDeclaringClass();
  if (!Modifier.isStatic(method.getModifiers())) {
    if (!classHasPublicZeroArgsConstructor(clazz)) {
      throw RESOURCE.requireDefaultConstructor(clazz.getName()).ex();
    }
  }
  final Class<?> returnType = method.getReturnType();
  if (!TranslatableTable.class.isAssignableFrom(returnType)) {
    return null;
  }
  return new TableMacroImpl(method);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
@Override public RelNode toRel(RelOptTable.ToRelContext context,
    RelOptTable relOptTable) {
  final CalciteSchema.TableEntry tableEntry =
      MaterializationService.instance().checkValid(key);
  if (tableEntry != null) {
    Table materializeTable = tableEntry.getTable();
    if (materializeTable instanceof TranslatableTable) {
      TranslatableTable table = (TranslatableTable) materializeTable;
      return table.toRel(context, relOptTable);
    }
  }
  return super.toRel(context, relOptTable);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
@Override public TranslatableTable apply(List<Object> arguments) {
  assert arguments.isEmpty();
  CalcitePrepare.ParseResult parsed =
      Schemas.parse(MATERIALIZATION_CONNECTION, schema, schemaPath,
          viewSql);
  final List<String> schemaPath1 =
      schemaPath != null ? schemaPath : schema.path(null);
  final JavaTypeFactory typeFactory =
      MATERIALIZATION_CONNECTION.getTypeFactory();
  return new MaterializedViewTable(typeFactory.getJavaClass(parsed.rowType),
      RelDataTypeImpl.proto(parsed.rowType), viewSql, schemaPath1, viewPath, key);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public static TranslatableTable view(String s) {
  return new ViewTable(Object.class,
      new RelProtoDataType() {
        public RelDataType apply(RelDataTypeFactory typeFactory) {
          return typeFactory.builder().add("c", SqlTypeName.INTEGER)
              .build();
        }
      }, "values (1), (3), " + s, ImmutableList.<String>of(), Arrays.asList("view"));
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public static TranslatableTable strView(String s) {
  return new ViewTable(Object.class,
      new RelProtoDataType() {
        public RelDataType apply(RelDataTypeFactory typeFactory) {
          return typeFactory.builder().add("c", SqlTypeName.VARCHAR, 100)
                  .build();
        }
      }, "values (" + CalciteSqlDialect.DEFAULT.quoteStringLiteral(s) + ")",
      ImmutableList.<String>of(), Arrays.asList("view"));
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public static TranslatableTable str(Object o, Object p) {
  assertThat(RexLiteral.validConstant(o, Litmus.THROW), is(true));
  assertThat(RexLiteral.validConstant(p, Litmus.THROW), is(true));
  return new ViewTable(Object.class,
      new RelProtoDataType() {
        public RelDataType apply(RelDataTypeFactory typeFactory) {
          return typeFactory.builder().add("c", SqlTypeName.VARCHAR, 100)
              .build();
        }
      },
      "values " + CalciteSqlDialect.DEFAULT.quoteStringLiteral(o.toString())
          + ", " + CalciteSqlDialect.DEFAULT.quoteStringLiteral(p.toString()),
      ImmutableList.<String>of(), Arrays.asList("view"));
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public TranslatableTable eval(
    @Parameter(name = "R", optional = true) String r,
    @Parameter(name = "S") String s,
    @Parameter(name = "T", optional = true) Integer t) {
  final StringBuilder sb = new StringBuilder();
  abc(sb, r);
  abc(sb, s);
  abc(sb, t);
  return view(sb.toString());
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public TranslatableTable view(String s) {
  return Smalls.view(s);
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
public TranslatableTable matview() {
  return Smalls.strView("noname");
}
 

import org.apache.calcite.schema.TranslatableTable; //导入依赖的package包/类
/** Adds some extra tables to the mock catalog. These increase the time and
 * complexity of initializing the catalog (because they contain views whose
 * SQL needs to be parsed) and so are not used for all tests. */
public MockCatalogReader init2() {
  MockSchema salesSchema = new MockSchema("SALES");
  // Same as "EMP_20" except it uses ModifiableViewTable which populates
  // constrained columns with default values on INSERT and has a single constraint on DEPTNO.
  List<String> empModifiableViewNames = ImmutableList.of(
      salesSchema.getCatalogName(), salesSchema.name, "EMP_MODIFIABLEVIEW");
  TableMacro empModifiableViewMacro = MockModifiableViewRelOptTable.viewMacro(rootSchema,
      "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, SLACKER from EMPDEFAULTS"
          + " where DEPTNO = 20", empModifiableViewNames.subList(0, 2),
      ImmutableList.of(empModifiableViewNames.get(2)), true);
  TranslatableTable empModifiableView = empModifiableViewMacro.apply(ImmutableList.of());
  MockModifiableViewRelOptTable mockEmpViewTable = MockModifiableViewRelOptTable.create(
      (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView, this,
      empModifiableViewNames.get(0), empModifiableViewNames.get(1),
      empModifiableViewNames.get(2), false, 20, null);
  registerTable(mockEmpViewTable);

  // Same as "EMP_MODIFIABLEVIEW" except that all columns are in the view, columns are reordered,
  // and there is an `extra` extended column.
  List<String> empModifiableViewNames2 = ImmutableList.of(
      salesSchema.getCatalogName(), salesSchema.name, "EMP_MODIFIABLEVIEW2");
  TableMacro empModifiableViewMacro2 = MockModifiableViewRelOptTable.viewMacro(rootSchema,
      "select ENAME, EMPNO, JOB, DEPTNO, SLACKER, SAL, EXTRA, HIREDATE, MGR, COMM"
          + " from EMPDEFAULTS extend (EXTRA boolean)"
          + " where DEPTNO = 20", empModifiableViewNames2.subList(0, 2),
      ImmutableList.of(empModifiableViewNames.get(2)), true);
  TranslatableTable empModifiableView2 = empModifiableViewMacro2.apply(ImmutableList.of());
  MockModifiableViewRelOptTable mockEmpViewTable2 = MockModifiableViewRelOptTable.create(
      (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView2, this,
      empModifiableViewNames2.get(0), empModifiableViewNames2.get(1),
      empModifiableViewNames2.get(2), false, 20, null);
  registerTable(mockEmpViewTable2);

  // Same as "EMP_MODIFIABLEVIEW" except that comm is not in the view.
  List<String> empModifiableViewNames3 = ImmutableList.of(
      salesSchema.getCatalogName(), salesSchema.name, "EMP_MODIFIABLEVIEW3");
  TableMacro empModifiableViewMacro3 = MockModifiableViewRelOptTable.viewMacro(rootSchema,
      "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, SLACKER from EMPDEFAULTS"
          + " where DEPTNO = 20", empModifiableViewNames3.subList(0, 2),
      ImmutableList.of(empModifiableViewNames3.get(2)), true);
  TranslatableTable empModifiableView3 = empModifiableViewMacro3.apply(ImmutableList.of());
  MockModifiableViewRelOptTable mockEmpViewTable3 = MockModifiableViewRelOptTable.create(
      (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView3, this,
      empModifiableViewNames3.get(0), empModifiableViewNames3.get(1),
      empModifiableViewNames3.get(2), false, 20, null);
  registerTable(mockEmpViewTable3);

  MockSchema structTypeSchema = new MockSchema("STRUCT");
  registerSchema(structTypeSchema);
  final Fixture f = new Fixture();
  final List<CompoundNameColumn> columnsExtended = Arrays.asList(
      new CompoundNameColumn("", "K0", f.varchar20TypeNull),
      new CompoundNameColumn("", "C1", f.varchar20TypeNull),
      new CompoundNameColumn("F0", "C0", f.intType),
      new CompoundNameColumn("F1", "C1", f.intTypeNull));
  final List<CompoundNameColumn> extendedColumns =
      new ArrayList<CompoundNameColumn>(columnsExtended);
  extendedColumns.add(new CompoundNameColumn("F2", "C2", f.varchar20Type));
  final CompoundNameColumnResolver structExtendedTableResolver =
      new CompoundNameColumnResolver(extendedColumns, "F0");
  final MockTable structExtendedTypeTable =
      MockTable.create(this, structTypeSchema, "T_EXTEND", false, 100,
          structExtendedTableResolver);
  for (CompoundNameColumn column : columnsExtended) {
    structExtendedTypeTable.addColumn(column.getName(), column.type);
  }
  registerTable(structExtendedTypeTable);

  return this;
}