Java Code Examples for org.apache.calcite.plan.RelOptTable#ViewExpander

protected SqlToRelConverter createSqlToRelConverter(
    final SqlValidator validator,
    final Prepare.CatalogReader catalogReader,
    final RelDataTypeFactory typeFactory,
    final SqlToRelConverter.Config config) {
  final RexBuilder rexBuilder = new RexBuilder(typeFactory);
  RelOptCluster cluster =
      RelOptCluster.create(getPlanner(), rexBuilder);
  if (clusterFactory != null) {
    cluster = clusterFactory.apply(cluster);
  }
  RelOptTable.ViewExpander viewExpander =
      new MockViewExpander(validator, catalogReader, cluster, config);
  return new SqlToRelConverter(viewExpander, validator, catalogReader, cluster,
      StandardConvertletTable.INSTANCE, config);
}
 

/**
 * Ensures that relational algebra ({@link RelBuilder}) works with SQL views.
 *
 * <p>This test currently fails (thus ignored).
 */
@Test void testExpandViewInRelBuilder() throws SQLException {
  try (Connection connection = DriverManager.getConnection("jdbc:calcite:")) {
    final Frameworks.ConfigBuilder configBuilder =
        expandingConfig(connection);
    final RelOptTable.ViewExpander viewExpander =
        (RelOptTable.ViewExpander) Frameworks.getPlanner(configBuilder.build());
    configBuilder.context(Contexts.of(viewExpander));
    final RelBuilder builder = RelBuilder.create(configBuilder.build());
    RelNode node = builder.scan("MYVIEW").build();

    int count = 0;
    try (PreparedStatement statement =
             connection.unwrap(RelRunner.class).prepare(node);
         ResultSet resultSet = statement.executeQuery()) {
      while (resultSet.next()) {
        count++;
      }
    }

    assertTrue(count > 1);
  }
}
 

@Test void testExpandViewShouldKeepAlias() throws SQLException {
  try (Connection connection = DriverManager.getConnection("jdbc:calcite:")) {
    final Frameworks.ConfigBuilder configBuilder =
        expandingConfig(connection);
    final RelOptTable.ViewExpander viewExpander =
        (RelOptTable.ViewExpander) Frameworks.getPlanner(configBuilder.build());
    configBuilder.context(Contexts.of(viewExpander));
    final RelBuilder builder = RelBuilder.create(configBuilder.build());
    RelNode node =
        builder.scan("MYVIEW")
            .project(
                builder.field(1, "MYVIEW", "EMPNO"),
                builder.field(1, "MYVIEW", "ENAME"))
            .build();
    String expected =
        "LogicalProject(EMPNO=[$0], ENAME=[$1])\n"
            + "  LogicalFilter(condition=[=(1, 1)])\n"
                + "    LogicalTableScan(table=[[scott, EMP]])\n";
    assertThat(node, hasTree(expected));
  }
}
 

static RelNode testSqlToRelConverter(RelOptPlanner planner) throws Exception {
    RexBuilder rexBuilder = createRexBuilder();
    RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder);
    RelOptTable.ViewExpander viewExpander = ViewExpanders.simpleContext(cluster);

    Pair<SqlNode, SqlValidator> pair = testSqlValidator();
    SqlNode sqlNode = pair.left;
    SqlValidator validator = pair.right;
    CatalogReader catalogReader = createCalciteCatalogReader();
    SqlRexConvertletTable convertletTable = StandardConvertletTable.INSTANCE;
    SqlToRelConverter.Config config = SqlToRelConverter.Config.DEFAULT;
    // 不转换成EnumerableTableScan，而是LogicalTableScan
    config = SqlToRelConverter.configBuilder().withConvertTableAccess(false).build();

    SqlToRelConverter converter = new SqlToRelConverter(viewExpander, validator, catalogReader, cluster,
            convertletTable, config);

    boolean needsValidation = false;
    boolean top = false;
    RelRoot root = converter.convertQuery(sqlNode, needsValidation, top);
    RelNode relNode = root.rel;

    String plan = RelOptUtil.toString(relNode);
    System.out.println("Logical Plan:");
    System.out.println("------------------------------------------------------------------");
    System.out.println(plan);
    System.out.println();

    // testPrograms(root.rel);

    return relNode;
}
 

/**
 * Creates a {@link TableScanFactory} that uses a
 * {@link org.apache.calcite.plan.RelOptTable.ViewExpander} to handle
 * {@link TranslatableTable} instances, and falls back to a default
 * factory for other tables.
 *
 * @param viewExpander View expander
 * @param tableScanFactory Factory for non-translatable tables
 * @return Table scan factory
 */
public static TableScanFactory expandingScanFactory(
    RelOptTable.ViewExpander viewExpander,
    TableScanFactory tableScanFactory) {
  return (cluster, table) -> {
    final TranslatableTable translatableTable =
        table.unwrap(TranslatableTable.class);
    if (translatableTable != null) {
      final RelOptTable.ToRelContext toRelContext =
          ViewExpanders.toRelContext(viewExpander, cluster);
      return translatableTable.toRel(toRelContext, table);
    }
    return tableScanFactory.createScan(cluster, table);
  };
}
 

RelOptTable.ToRelContext toRelContext() {
  if (preparingStmt instanceof RelOptTable.ViewExpander) {
    final RelOptTable.ViewExpander viewExpander =
        (RelOptTable.ViewExpander) this.preparingStmt;
    return ViewExpanders.toRelContext(viewExpander, cluster);
  } else {
    return ViewExpanders.simpleContext(cluster);
  }
}
 

StdFrameworkConfig(Context context,
    SqlRexConvertletTable convertletTable,
    SqlOperatorTable operatorTable,
    ImmutableList<Program> programs,
    ImmutableList<RelTraitDef> traitDefs,
    SqlParser.Config parserConfig,
    SqlValidator.Config sqlValidatorConfig,
    SqlToRelConverter.Config sqlToRelConverterConfig,
    SchemaPlus defaultSchema,
    RelOptCostFactory costFactory,
    RelDataTypeSystem typeSystem,
    RexExecutor executor,
    boolean evolveLattice,
    SqlStatisticProvider statisticProvider,
    RelOptTable.ViewExpander viewExpander) {
  this.context = context;
  this.convertletTable = convertletTable;
  this.operatorTable = operatorTable;
  this.programs = programs;
  this.traitDefs = traitDefs;
  this.parserConfig = parserConfig;
  this.sqlValidatorConfig = sqlValidatorConfig;
  this.sqlToRelConverterConfig = sqlToRelConverterConfig;
  this.defaultSchema = defaultSchema;
  this.costFactory = costFactory;
  this.typeSystem = typeSystem;
  this.executor = executor;
  this.evolveLattice = evolveLattice;
  this.statisticProvider = statisticProvider;
  this.viewExpander = viewExpander;
}
 

@Override
public RelOptTable.ViewExpander getViewExpander() {
    return MycatCalciteSupport.INSTANCE.config.getViewExpander();
}
 

public RelOptTable.ViewExpander getViewExpander() {
  return viewExpander;
}
 

/**
 * Returns a view expander.
 */
RelOptTable.ViewExpander getViewExpander();
 

/**
 * Returns a view expander.
 */
RelOptTable.ViewExpander getViewExpander();
 

/**
 * Derives the view expander
 * {@link org.apache.calcite.plan.RelOptTable.ViewExpander}
 * to be used for this RelBuilder.
 *
 * <p>The ViewExpander instance is used for expanding views in the default
 * table scan factory {@code RelFactories.TableScanFactoryImpl}.
 * You can also define a new table scan factory in the {@code struct}
 * to override the whole table scan creation.
 *
 * <p>The default view expander does not support expanding views.
 */
private RelOptTable.ViewExpander getViewExpander(RelOptCluster cluster, Context context) {
  return Util.first(context.unwrap(RelOptTable.ViewExpander.class),
      ViewExpanders.simpleContext(cluster));
}