public RelOptTableImpl getTable(final String[] names) {
List<Pair<String, Object>> pairs = new ArrayList<Pair<String, Object>>();
Schema schema2 = schema;
for (int i = 0; i < names.length; i++) {
final String name = names[i];
Schema subSchema = schema2.getSubSchema(name);
if (subSchema != null) {
pairs.add(Pair.<String, Object>of(name, subSchema));
schema2 = subSchema;
continue;
}
final Table table = schema2.getTable(name);
if (table != null) {
pairs.add(Pair.<String, Object>of(name, table));
if (i != names.length - 1) {
// not enough objects to match all names
return null;
}
return new RelOptTableImpl(
this, typeFactory.createType(table.getElementType()), names, table);
}
return null;
}
return null;
}
/**
* Returns whether this trait set subsumes another trait set.
*
* <p>For that to happen, each trait subsumes the corresponding trait in the other set. In
* particular, each trait set subsumes itself, because each trait subsumes itself.
*
* <p>Intuitively, if a relational expression is needed that has trait set S, and trait set S1
* subsumes S, then a relational expression R in S1 meets that need. For example, if we need a
* relational expression that has trait set S = {enumerable convention, sorted on [C1 asc]}, and R
* has {enumerable convention, sorted on [C1 asc, C2]}
*
* @param that another RelTraitSet
* @return whether this trait set subsumes other trait set
*/
public boolean subsumes(RelTraitSet that) {
for (Pair<RelTrait, RelTrait> pair : Pair.zip(traits, that.traits)) {
if (!pair.left.subsumes(pair.right)) {
return false;
}
}
return true;
}
private RelOptTableImpl getTableFrom(List<String> names, List<String> schemaNames) {
OptiqSchema schema = getSchema(Iterables.concat(schemaNames, Util.skipLast(names)));
if (schema == null) {
return null;
}
final String name = Util.last(names);
Pair<String, Table> pair = schema.getTable(name, caseSensitive);
if (pair == null) {
pair = schema.getTableBasedOnNullaryFunction(name, caseSensitive);
}
if (pair != null) {
final Table table = pair.getValue();
final String name2 = pair.getKey();
return RelOptTableImpl.create(this, table.getRowType(typeFactory), schema.add(name2, table));
}
return null;
}
/** Creates a result based on a single relational expression. */
public Result result(SqlNode node, Collection<Clause> clauses, RelNode rel) {
final String alias2 = SqlValidatorUtil.getAlias(node, -1);
final String alias3 = alias2 != null ? alias2 : "t";
final String alias4 =
SqlValidatorUtil.uniquify(alias3, aliasSet, SqlValidatorUtil.EXPR_SUGGESTER);
final String alias5 = alias2 == null || !alias2.equals(alias4) ? alias4 : null;
return new Result(
node, clauses, alias5, Collections.singletonList(Pair.of(alias4, rel.getRowType())));
}
private List<Object> getList(List<Pair<String, Object>> values, String tag) {
for (Pair<String, Object> value : values) {
if (value.left.equals(tag)) {
//noinspection unchecked
return (List<Object>) value.right;
}
}
final List<Object> list = new ArrayList<Object>();
values.add(Pair.of(tag, (Object) list));
return list;
}
/** @return true if all tuples match rowType; otherwise, assert on mismatch */
private boolean assertRowType() {
for (List<RexLiteral> tuple : tuples) {
assert tuple.size() == rowType.getFieldCount();
for (Pair<RexLiteral, RelDataTypeField> pair : Pair.zip(tuple, rowType.getFieldList())) {
RexLiteral literal = pair.left;
RelDataType fieldType = pair.right.getType();
// TODO jvs 19-Feb-2006: strengthen this a bit. For example,
// overflow, rounding, and padding/truncation must already have
// been dealt with.
if (!RexLiteral.isNullLiteral(literal)) {
assert (SqlTypeUtil.canAssignFrom(fieldType, literal.getType()));
}
}
}
return true;
}
public Object freeze(ColumnLoader.ValueSet valueSet) {
final int n = valueSet.map.keySet().size();
int extra = valueSet.containsNull ? 1 : 0;
Comparable[] codeValues = valueSet.map.keySet().toArray(new Comparable[n + extra]);
Arrays.sort(codeValues, 0, n);
ColumnLoader.ValueSet codeValueSet = new ColumnLoader.ValueSet(int.class);
for (Comparable value : valueSet.values) {
int code;
if (value == null) {
code = n;
} else {
code = Arrays.binarySearch(codeValues, value);
assert code >= 0 : code + ", " + value;
}
codeValueSet.add(code);
}
Object codes = representation.freeze(codeValueSet);
return Pair.of(codes, codeValues);
}
public List<String> getFieldNames() {
return Pair.left(fieldList);
}
/**
* Creates a relational expression which projects an array of expressions.
*
* @param child input relational expression
* @param projectList list of (expression, name) pairs
* @param optimize Whether to optimize
*/
public static RelNode createProject(
RelNode child, List<Pair<RexNode, String>> projectList, boolean optimize) {
return createProject(child, Pair.left(projectList), Pair.right(projectList), optimize);
}
public RelWriter item(String term, Object value) {
values.add(Pair.of(term, value));
return this;
}
public Object freeze(ColumnLoader.ValueSet valueSet) {
final int size = valueSet.values.size();
return Pair.of(size == 0 ? null : valueSet.values.get(0), size);
}
public void addColumn(String name, RelDataType type) {
columnList.add(Pair.of(name, type));
}
public void addColumn(int index, String name, RelDataType type) {
columnList.add(index, Pair.of(name, type));
}
