Java TranslatableTable类代码示例

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"));
}