Java ScannableTable类代码示例

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public Profiler.Profile get() {
  final ProfilerImpl profiler =
      ProfilerImpl.builder()
          .withPassSize(200)
          .withMinimumSurprise(0.3D)
          .build();
  final List<Profiler.Column> columns = new ArrayList<>();
  for (Lattice.Column column : lattice.columns) {
    columns.add(new Profiler.Column(column.ordinal, column.alias));
  }
  final String sql =
      lattice.sql(ImmutableBitSet.range(lattice.columns.size()),
          false, ImmutableList.<Lattice.Measure>of());
  final Table table =
      new MaterializationService.DefaultTableFactory()
          .createTable(lattice.rootSchema, sql,
              ImmutableList.<String>of());
  final ImmutableList<ImmutableBitSet> initialGroups =
      ImmutableList.of();
  final Enumerable<List<Comparable>> rows =
      ((ScannableTable) table).scan(null).select(TO_LIST);
  return profiler.profile(rows, columns, initialGroups);
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public static Class deduceElementType(Table table) {
  if (table instanceof QueryableTable) {
    final QueryableTable queryableTable = (QueryableTable) table;
    final Type type = queryableTable.getElementType();
    if (type instanceof Class) {
      return (Class) type;
    } else {
      return Object[].class;
    }
  } else if (table instanceof ScannableTable
      || table instanceof FilterableTable
      || table instanceof ProjectableFilterableTable
      || table instanceof StreamableTable) {
    return Object[].class;
  } else {
    return Object.class;
  }
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
private Expression toRows(PhysType physType, Expression expression) {
  if (physType.getFormat() == JavaRowFormat.SCALAR
      && Object[].class.isAssignableFrom(elementType)
      && getRowType().getFieldCount() == 1
      && (table.unwrap(ScannableTable.class) != null
          || table.unwrap(FilterableTable.class) != null
          || table.unwrap(ProjectableFilterableTable.class) != null)) {
    return Expressions.call(BuiltInMethod.SLICE0.method, expression);
  }
  JavaRowFormat oldFormat = format();
  if (physType.getFormat() == oldFormat && !hasCollectionField(rowType)) {
    return expression;
  }
  final ParameterExpression row_ =
      Expressions.parameter(elementType, "row");
  final int fieldCount = table.getRowType().getFieldCount();
  List<Expression> expressionList = new ArrayList<>(fieldCount);
  for (int i = 0; i < fieldCount; i++) {
    expressionList.add(fieldExpression(row_, i, physType, oldFormat));
  }
  return Expressions.call(expression,
      BuiltInMethod.SELECT.method,
      Expressions.lambda(Function1.class, physType.record(expressionList),
          row_));
}
 

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

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
private double cardinality(Lattice lattice, Lattice.Column column) {
  final String sql = lattice.countSql(ImmutableBitSet.of(column.ordinal));
  final Table table =
      new MaterializationService.DefaultTableFactory()
          .createTable(lattice.rootSchema, sql, ImmutableList.<String>of());
  final Object[] values =
      Iterables.getOnlyElement(((ScannableTable) table).scan(null));
  return ((Number) values[0]).doubleValue();
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
/** Returns whether EnumerableTableScan can generate code to handle a
 * particular variant of the Table SPI. */
public static boolean canHandle(Table table) {
  // FilterableTable and ProjectableFilterableTable cannot be handled in
  // enumerable convention because they might reject filters and those filters
  // would need to be handled dynamically.
  return table instanceof QueryableTable
      || table instanceof ScannableTable;
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public Type getElementType(List<Object> arguments) {
  final Table table = apply(arguments);
  if (table instanceof QueryableTable) {
    QueryableTable queryableTable = (QueryableTable) table;
    return queryableTable.getElementType();
  } else if (table instanceof ScannableTable) {
    return Object[].class;
  }
  throw new AssertionError("Invalid table class: " + table + " "
      + table.getClass());
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
/** Creates a TableScanNode.
 *
 * <p>Tries various table SPIs, and negotiates with the table which filters
 * and projects it can implement. Adds to the Enumerable implementations of
 * any filters and projects that cannot be implemented by the table. */
static TableScanNode create(Compiler compiler, TableScan rel,
    ImmutableList<RexNode> filters, ImmutableIntList projects) {
  final RelOptTable relOptTable = rel.getTable();
  final ProjectableFilterableTable pfTable =
      relOptTable.unwrap(ProjectableFilterableTable.class);
  if (pfTable != null) {
    return createProjectableFilterable(compiler, rel, filters, projects,
        pfTable);
  }
  final FilterableTable filterableTable =
      relOptTable.unwrap(FilterableTable.class);
  if (filterableTable != null) {
    return createFilterable(compiler, rel, filters, projects,
        filterableTable);
  }
  final ScannableTable scannableTable =
      relOptTable.unwrap(ScannableTable.class);
  if (scannableTable != null) {
    return createScannable(compiler, rel, filters, projects,
        scannableTable);
  }
  //noinspection unchecked
  final Enumerable<Row> enumerable = relOptTable.unwrap(Enumerable.class);
  if (enumerable != null) {
    return createEnumerable(compiler, rel, enumerable, null, filters,
        projects);
  }
  final QueryableTable queryableTable =
      relOptTable.unwrap(QueryableTable.class);
  if (queryableTable != null) {
    return createQueryable(compiler, rel, filters, projects,
        queryableTable);
  }
  throw new AssertionError("cannot convert table " + relOptTable
      + " to enumerable");
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
private static TableScanNode createScannable(Compiler compiler, TableScan rel,
    ImmutableList<RexNode> filters, ImmutableIntList projects,
    ScannableTable scannableTable) {
  final Enumerable<Row> rowEnumerable =
      Enumerables.toRow(scannableTable.scan(compiler.getDataContext()));
  return createEnumerable(compiler, rel, rowEnumerable, null, filters,
      projects);
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public static ScannableTable generate2(
    @Parameter(name = "WIDTH") int width,
    @Parameter(name = "HEIGHT") int height,
    @Parameter(name = "SEED", optional = true) Integer seed) {
  return new MazeTable(
      String.format(Locale.ROOT, "generate2(w=%d, h=%d, s=%d)", width,
          height, seed));
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
@Override public Enumerable<Object[]> bind(DataContext dataContext) {
  return table.unwrap(ScannableTable.class).scan(dataContext);
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public static boolean canHandle(RelOptTable table) {
  return table.unwrap(ScannableTable.class) != null
      || table.unwrap(FilterableTable.class) != null
      || table.unwrap(ProjectableFilterableTable.class) != null;
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public Enumerable<Object[]> bind(DataContext dataContext) {
  // TODO: filterable and projectable
  return table.unwrap(ScannableTable.class).scan(dataContext);
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
/** A function that generates the Fibonacci sequence.
 * Interesting because it has one column and no arguments. */
public static ScannableTable fibonacciTable() {
  return fibonacciTableWithLimit(-1L);
}
 

import org.apache.calcite.schema.ScannableTable; //导入依赖的package包/类
public static ScannableTable generate(int width, int height, int seed) {
  return new MazeTable(
      String.format(Locale.ROOT, "generate(w=%d, h=%d, s=%d)", width,
          height, seed));
}