Java CalciteSchema.LatticeEntry方法代码示例

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
private void populateMaterializationsAndLattice(
    QuarkMaterializeCluster.RelOptPlannerHolder plannerHolder,
    CalciteSchema rootSchema) {
  if (materializations == null) {
    materializations =
        MaterializationService.instance().query(rootSchema);
  }
  Materializer materializer = new Materializer(materializations);

  materializer.populateMaterializations(context.getPrepareContext(), plannerHolder);

  List<CalciteSchema.LatticeEntry> lattices = Schemas.getLatticeEntries(rootSchema);

  for (CalciteSchema.LatticeEntry lattice : lattices) {
    final CalciteSchema.TableEntry starTable = lattice.getStarTable();
    final JavaTypeFactory typeFactory = context.getTypeFactory();
    final RelOptTableImpl starRelOptTable =
        RelOptTableImpl.create(catalogReader,
            starTable.getTable().getRowType(typeFactory), starTable, null);
    plannerHolder.getPlanner().addLattice(
        new RelOptLattice(lattice.getLattice(), starRelOptTable));
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
/**
 * Called after the constructor has completed and the model has been
 * loaded.
 */
void init() {
    final MaterializationService service = MaterializationService.instance();
    for (CalciteSchema.LatticeEntry e : Schemas.getLatticeEntries(rootSchema)) {
        final Lattice lattice = e.getLattice();
        for (Lattice.Tile tile : lattice.computeTiles()) {
            service.defineTile(lattice, tile.bitSet(), tile.measures, e.schema,
                    true, true);
        }
    }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
/** Returns the lattices defined in a schema.
 *
 * @param schema Schema */
public static List<CalciteSchema.LatticeEntry> getLatticeEntries(
    CalciteSchema schema) {
  final List<CalciteSchema.LatticeEntry> list = Lists.newArrayList();
  gatherLattices(schema, list);
  return list;
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
private static void gatherLattices(CalciteSchema schema,
    List<CalciteSchema.LatticeEntry> list) {
  list.addAll(schema.getLatticeMap().values());
  for (CalciteSchema subSchema : schema.getSubSchemaMap().values()) {
    gatherLattices(subSchema, list);
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
private PreparedResult prepare_(Supplier<RelNode> fn,
    RelDataType resultType) {
  Class runtimeContextClass = Object.class;
  init(runtimeContextClass);

  final RelNode rel = fn.get();
  final RelDataType rowType = rel.getRowType();
  final List<Pair<Integer, String>> fields =
      Pair.zip(ImmutableIntList.identity(rowType.getFieldCount()),
          rowType.getFieldNames());
  final RelCollation collation =
      rel instanceof Sort
          ? ((Sort) rel).collation
          : RelCollations.EMPTY;
  RelRoot root = new RelRoot(rel, resultType, SqlKind.SELECT, fields,
      collation);

  if (timingTracer != null) {
    timingTracer.traceTime("end sql2rel");
  }

  final RelDataType jdbcType =
      makeStruct(rexBuilder.getTypeFactory(), resultType);
  fieldOrigins = Collections.nCopies(jdbcType.getFieldCount(), null);
  parameterRowType = rexBuilder.getTypeFactory().builder().build();

  // Structured type flattening, view expansion, and plugging in
  // physical storage.
  root = root.withRel(flattenTypes(root.rel, true));

  // Trim unused fields.
  root = trimUnusedFields(root);

  final List<Materialization> materializations = ImmutableList.of();
  final List<CalciteSchema.LatticeEntry> lattices = ImmutableList.of();
  root = optimize(root, materializations, lattices);

  if (timingTracer != null) {
    timingTracer.traceTime("end optimization");
  }

  return implement(root);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
/** Returns the star tables defined in a schema.
 *
 * @param schema Schema */
public static List<CalciteSchema.TableEntry> getStarTables(
    CalciteSchema schema) {
  final List<CalciteSchema.LatticeEntry> list = getLatticeEntries(schema);
  return Lists.transform(list, TO_TABLE_ENTRY);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入方法依赖的package包/类
/** Returns the lattices defined in a schema.
 *
 * @param schema Schema */
public static List<Lattice> getLattices(CalciteSchema schema) {
  final List<CalciteSchema.LatticeEntry> list = getLatticeEntries(schema);
  return Lists.transform(list, TO_LATTICE);
}