com.hazelcast.shaded.org.apache.calcite.jdbc.CalciteSchema Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.shaded.org.apache.calcite.jdbc;
import com.hazelcast.shaded.org.apache.calcite.adapter.jdbc.JdbcCatalogSchema;
import com.hazelcast.shaded.org.apache.calcite.adapter.jdbc.JdbcSchema;
import com.hazelcast.shaded.org.apache.calcite.linq4j.function.Experimental;
import com.hazelcast.shaded.org.apache.calcite.linq4j.tree.Expression;
import com.hazelcast.shaded.org.apache.calcite.materialize.Lattice;
import com.hazelcast.shaded.org.apache.calcite.rel.type.RelProtoDataType;
import com.hazelcast.shaded.org.apache.calcite.schema.Function;
import com.hazelcast.shaded.org.apache.calcite.schema.Schema;
import com.hazelcast.shaded.org.apache.calcite.schema.SchemaPlus;
import com.hazelcast.shaded.org.apache.calcite.schema.SchemaVersion;
import com.hazelcast.shaded.org.apache.calcite.schema.Table;
import com.hazelcast.shaded.org.apache.calcite.schema.TableMacro;
import com.hazelcast.shaded.org.apache.calcite.schema.impl.MaterializedViewTable;
import com.hazelcast.shaded.org.apache.calcite.schema.impl.StarTable;
import com.hazelcast.shaded.org.apache.calcite.util.NameMap;
import com.hazelcast.shaded.org.apache.calcite.util.NameMultimap;
import com.hazelcast.shaded.org.apache.calcite.util.NameSet;
import com.hazelcast.shaded.org.apache.calcite.util.Pair;
import com.hazelcast.shaded.com.google.common.base.Preconditions;
import com.hazelcast.shaded.com.google.common.collect.ImmutableList;
import com.hazelcast.shaded.com.google.common.collect.ImmutableSortedMap;
import com.hazelcast.shaded.com.google.common.collect.ImmutableSortedSet;
import com.hazelcast.shaded.com.google.common.collect.Lists;
import com.hazelcast.shaded.org.checkerframework.checker.nullness.qual.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Objects;
import java.util.Set;
import javax.sql.DataSource;
/**
* Schema.
*
* Wrapper around user-defined schema used internally.
*/
public abstract class CalciteSchema {
private final @Nullable CalciteSchema parent;
public final Schema schema;
public final String name;
/** Tables explicitly defined in this schema. Does not include tables in
* {@link #schema}. */
protected final NameMap tableMap;
protected final NameMultimap functionMap;
protected final NameMap typeMap;
protected final NameMap latticeMap;
protected final NameSet functionNames;
protected final NameMap nullaryFunctionMap;
protected final NameMap subSchemaMap;
private @Nullable List> path;
protected CalciteSchema(@Nullable CalciteSchema parent, Schema schema,
String name,
@Nullable NameMap subSchemaMap,
@Nullable NameMap tableMap,
@Nullable NameMap latticeMap,
@Nullable NameMap typeMap,
@Nullable NameMultimap functionMap,
@Nullable NameSet functionNames,
@Nullable NameMap nullaryFunctionMap,
@Nullable List> path) {
this.parent = parent;
this.schema = schema;
this.name = name;
if (tableMap == null) {
this.tableMap = new NameMap<>();
} else {
this.tableMap = Objects.requireNonNull(tableMap, "tableMap");
}
if (latticeMap == null) {
this.latticeMap = new NameMap<>();
} else {
this.latticeMap = Objects.requireNonNull(latticeMap, "latticeMap");
}
if (subSchemaMap == null) {
this.subSchemaMap = new NameMap<>();
} else {
this.subSchemaMap = Objects.requireNonNull(subSchemaMap, "subSchemaMap");
}
if (functionMap == null) {
this.functionMap = new NameMultimap<>();
this.functionNames = new NameSet();
this.nullaryFunctionMap = new NameMap<>();
} else {
// If you specify functionMap, you must also specify functionNames and
// nullaryFunctionMap.
this.functionMap = Objects.requireNonNull(functionMap, "functionMap");
this.functionNames = Objects.requireNonNull(functionNames, "functionNames");
this.nullaryFunctionMap = Objects.requireNonNull(nullaryFunctionMap, "nullaryFunctionMap");
}
if (typeMap == null) {
this.typeMap = new NameMap<>();
} else {
this.typeMap = Objects.requireNonNull(typeMap, "typeMap");
}
this.path = path;
}
/** Returns a sub-schema with a given name that is defined implicitly
* (that is, by the underlying {@link Schema} object, not explicitly
* by a call to {@link #add(String, Schema)}), or null. */
protected abstract @Nullable CalciteSchema getImplicitSubSchema(String schemaName,
boolean caseSensitive);
/** Returns a table with a given name that is defined implicitly
* (that is, by the underlying {@link Schema} object, not explicitly
* by a call to {@link #add(String, Table)}), or null. */
protected abstract @Nullable TableEntry getImplicitTable(String tableName,
boolean caseSensitive);
/** Returns a type with a given name that is defined implicitly
* (that is, by the underlying {@link Schema} object, not explicitly
* by a call to {@link #add(String, RelProtoDataType)}), or null. */
protected abstract @Nullable TypeEntry getImplicitType(String name,
boolean caseSensitive);
/** Returns table function with a given name and zero arguments that is
* defined implicitly (that is, by the underlying {@link Schema} object,
* not explicitly by a call to {@link #add(String, Function)}), or null. */
protected abstract @Nullable TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
boolean caseSensitive);
/** Adds implicit sub-schemas to a builder. */
protected abstract void addImplicitSubSchemaToBuilder(
ImmutableSortedMap.Builder builder);
/** Adds implicit tables to a builder. */
protected abstract void addImplicitTableToBuilder(
ImmutableSortedSet.Builder builder);
/** Adds implicit functions to a builder. */
protected abstract void addImplicitFunctionsToBuilder(
ImmutableList.Builder builder,
String name, boolean caseSensitive);
/** Adds implicit function names to a builder. */
protected abstract void addImplicitFuncNamesToBuilder(
ImmutableSortedSet.Builder builder);
/** Adds implicit type names to a builder. */
protected abstract void addImplicitTypeNamesToBuilder(
ImmutableSortedSet.Builder builder);
/** Adds implicit table functions to a builder. */
protected abstract void addImplicitTablesBasedOnNullaryFunctionsToBuilder(
ImmutableSortedMap.Builder builder);
/** Returns a snapshot representation of this CalciteSchema. */
protected abstract CalciteSchema snapshot(
@Nullable CalciteSchema parent, SchemaVersion version);
protected abstract boolean isCacheEnabled();
public abstract void setCache(boolean cache);
/** Creates a TableEntryImpl with no SQLs. */
protected TableEntryImpl tableEntry(String name, Table table) {
return new TableEntryImpl(this, name, table, ImmutableList.of());
}
/** Creates a TableEntryImpl with no SQLs. */
protected TypeEntryImpl typeEntry(String name, RelProtoDataType relProtoDataType) {
return new TypeEntryImpl(this, name, relProtoDataType);
}
/** Defines a table within this schema. */
public TableEntry add(String tableName, Table table) {
return add(tableName, table, ImmutableList.of());
}
/** Defines a table within this schema. */
public TableEntry add(String tableName, Table table,
ImmutableList sqls) {
final TableEntryImpl entry =
new TableEntryImpl(this, tableName, table, sqls);
tableMap.put(tableName, entry);
return entry;
}
/** Defines a type within this schema. */
public TypeEntry add(String name, RelProtoDataType type) {
final TypeEntry entry =
new TypeEntryImpl(this, name, type);
typeMap.put(name, entry);
return entry;
}
private FunctionEntry add(String name, Function function) {
final FunctionEntryImpl entry =
new FunctionEntryImpl(this, name, function);
functionMap.put(name, entry);
functionNames.add(name);
if (function.getParameters().isEmpty()) {
nullaryFunctionMap.put(name, entry);
}
return entry;
}
private LatticeEntry add(String name, Lattice lattice) {
if (latticeMap.containsKey(name, false)) {
throw new RuntimeException("Duplicate lattice '" + name + "'");
}
final LatticeEntryImpl entry = new LatticeEntryImpl(this, name, lattice);
latticeMap.put(name, entry);
return entry;
}
public CalciteSchema root() {
for (CalciteSchema schema = this;;) {
if (schema.parent == null) {
return schema;
}
schema = schema.parent;
}
}
/** Returns whether this is a root schema. */
public boolean isRoot() {
return parent == null;
}
/** Returns the path of an object in this schema. */
public List path(@Nullable String name) {
final List list = new ArrayList<>();
if (name != null) {
list.add(name);
}
for (CalciteSchema s = this; s != null; s = s.parent) {
if (s.parent != null || !s.name.equals("")) {
// Omit the root schema's name from the path if it's the empty string,
// which it usually is.
list.add(s.name);
}
}
return ImmutableList.copyOf(Lists.reverse(list));
}
public final @Nullable CalciteSchema getSubSchema(String schemaName,
boolean caseSensitive) {
// Check explicit schemas.
//noinspection LoopStatementThatDoesntLoop
for (Map.Entry entry
: subSchemaMap.range(schemaName, caseSensitive).entrySet()) {
return entry.getValue();
}
return getImplicitSubSchema(schemaName, caseSensitive);
}
/** Adds a child schema of this schema. */
public abstract CalciteSchema add(String name, Schema schema);
/** Returns a table that materializes the given SQL statement. */
public final @Nullable TableEntry getTableBySql(String sql) {
for (TableEntry tableEntry : tableMap.map().values()) {
if (tableEntry.sqls.contains(sql)) {
return tableEntry;
}
}
return null;
}
/** Returns a table with the given name. Does not look for views. */
public final @Nullable TableEntry getTable(String tableName, boolean caseSensitive) {
// Check explicit tables.
//noinspection LoopStatementThatDoesntLoop
for (Map.Entry entry
: tableMap.range(tableName, caseSensitive).entrySet()) {
return entry.getValue();
}
return getImplicitTable(tableName, caseSensitive);
}
public String getName() {
return name;
}
public SchemaPlus plus() {
return new SchemaPlusImpl();
}
public static CalciteSchema from(SchemaPlus plus) {
return ((SchemaPlusImpl) plus).calciteSchema();
}
/** Returns the default path resolving functions from this schema.
*
* The path consists is a list of lists of strings.
* Each list of strings represents the path of a schema from the root schema.
* For example, [[], [foo], [foo, bar, baz]] represents three schemas: the
* root schema "/" (level 0), "/foo" (level 1) and "/foo/bar/baz" (level 3).
*
* @return Path of this schema; never null, may be empty
*/
public List> getPath() {
if (path != null) {
return path;
}
// Return a path consisting of just this schema.
return ImmutableList.of(path(null));
}
/** Returns a collection of sub-schemas, both explicit (defined using
* {@link #add(String, com.hazelcast.shaded.org.apache.calcite.schema.Schema)}) and implicit
* (defined using {@link com.hazelcast.shaded.org.apache.calcite.schema.Schema#getSubSchemaNames()}
* and {@link Schema#getSubSchema(String)}). */
public final NavigableMap getSubSchemaMap() {
// Build a map of implicit sub-schemas first, then explicit sub-schemas.
// If there are implicit and explicit with the same name, explicit wins.
final ImmutableSortedMap.Builder builder =
new ImmutableSortedMap.Builder<>(NameSet.COMPARATOR);
builder.putAll(subSchemaMap.map());
addImplicitSubSchemaToBuilder(builder);
return builder.build();
}
/** Returns a collection of lattices.
*
* All are explicit (defined using {@link #add(String, Lattice)}). */
public NavigableMap getLatticeMap() {
return ImmutableSortedMap.copyOf(latticeMap.map());
}
/** Returns the set of all table names. Includes implicit and explicit tables
* and functions with zero parameters. */
public final NavigableSet getTableNames() {
final ImmutableSortedSet.Builder builder =
new ImmutableSortedSet.Builder<>(NameSet.COMPARATOR);
// Add explicit tables, case-sensitive.
builder.addAll(tableMap.map().keySet());
// Add implicit tables, case-sensitive.
addImplicitTableToBuilder(builder);
return builder.build();
}
/** Returns the set of all types names. */
public final NavigableSet getTypeNames() {
final ImmutableSortedSet.Builder builder =
new ImmutableSortedSet.Builder<>(NameSet.COMPARATOR);
// Add explicit types.
builder.addAll(typeMap.map().keySet());
// Add implicit types.
addImplicitTypeNamesToBuilder(builder);
return builder.build();
}
/** Returns a type, explicit and implicit, with a given
* name. Never null. */
public final @Nullable TypeEntry getType(String name, boolean caseSensitive) {
for (Map.Entry entry
: typeMap.range(name, caseSensitive).entrySet()) {
return entry.getValue();
}
return getImplicitType(name, caseSensitive);
}
/** Returns a collection of all functions, explicit and implicit, with a given
* name. Never null. */
public final Collection getFunctions(String name, boolean caseSensitive) {
final ImmutableList.Builder builder = ImmutableList.builder();
// Add explicit functions.
for (FunctionEntry functionEntry
: Pair.right(functionMap.range(name, caseSensitive))) {
builder.add(functionEntry.getFunction());
}
// Add implicit functions.
addImplicitFunctionsToBuilder(builder, name, caseSensitive);
return builder.build();
}
/** Returns the list of function names in this schema, both implicit and
* explicit, never null. */
public final NavigableSet getFunctionNames() {
final ImmutableSortedSet.Builder builder =
new ImmutableSortedSet.Builder<>(NameSet.COMPARATOR);
// Add explicit functions, case-sensitive.
builder.addAll(functionMap.map().keySet());
// Add implicit functions, case-sensitive.
addImplicitFuncNamesToBuilder(builder);
return builder.build();
}
/** Returns tables derived from explicit and implicit functions
* that take zero parameters. */
public final NavigableMap getTablesBasedOnNullaryFunctions() {
ImmutableSortedMap.Builder builder =
new ImmutableSortedMap.Builder<>(NameSet.COMPARATOR);
for (Map.Entry entry
: nullaryFunctionMap.map().entrySet()) {
final Function function = entry.getValue().getFunction();
if (function instanceof TableMacro) {
assert function.getParameters().isEmpty();
final Table table = ((TableMacro) function).apply(ImmutableList.of());
builder.put(entry.getKey(), table);
}
}
// add tables derived from implicit functions
addImplicitTablesBasedOnNullaryFunctionsToBuilder(builder);
return builder.build();
}
/** Returns a tables derived from explicit and implicit functions
* that take zero parameters. */
public final @Nullable TableEntry getTableBasedOnNullaryFunction(String tableName,
boolean caseSensitive) {
for (Map.Entry entry
: nullaryFunctionMap.range(tableName, caseSensitive).entrySet()) {
final Function function = entry.getValue().getFunction();
if (function instanceof TableMacro) {
assert function.getParameters().isEmpty();
final Table table = ((TableMacro) function).apply(ImmutableList.of());
return tableEntry(tableName, table);
}
}
return getImplicitTableBasedOnNullaryFunction(tableName, caseSensitive);
}
/** Creates a snapshot of this CalciteSchema as of the specified time. All
* explicit objects in this CalciteSchema will be copied into the snapshot
* CalciteSchema, while the contents of the snapshot of the underlying schema
* should not change as specified in {@link Schema#snapshot(SchemaVersion)}.
* Snapshots of explicit sub schemas will be created and copied recursively.
*
* Currently, to accommodate the requirement of creating tables on the fly
* for materializations, the snapshot will still use the same table map and
* lattice map as in the original CalciteSchema instead of making copies.
*
* @param version The current schema version
*
* @return the schema snapshot.
*/
public CalciteSchema createSnapshot(SchemaVersion version) {
Preconditions.checkArgument(this.isRoot(), "must be root schema");
return snapshot(null, version);
}
/** Returns a subset of a map whose keys match the given string
* case-insensitively.
*
* @deprecated use NameMap
*/
@Deprecated // to be removed before 2.0
protected static NavigableMap find(NavigableMap map,
String s) {
return NameMap.immutableCopyOf(map).range(s, false);
}
/** Returns a subset of a set whose values match the given string
* case-insensitively.
*
* @deprecated use NameSet
*/
@Deprecated // to be removed before 2.0
protected static Iterable find(NavigableSet set, String name) {
return NameSet.immutableCopyOf(set).range(name, false);
}
/** Creates a root schema.
*
* When addMetadataSchema argument is true adds a "metadata"
* schema containing definitions of tables, columns etc. to root schema.
* By default, creates a {@link CachingCalciteSchema}.
*/
public static CalciteSchema createRootSchema(boolean addMetadataSchema) {
return createRootSchema(addMetadataSchema, true);
}
/** Creates a root schema.
*
* @param addMetadataSchema Whether to add a "metadata" schema containing
* definitions of tables, columns etc.
* @param cache If true create {@link CachingCalciteSchema};
* if false create {@link SimpleCalciteSchema}
*/
public static CalciteSchema createRootSchema(boolean addMetadataSchema,
boolean cache) {
return createRootSchema(addMetadataSchema, cache, "");
}
/** Creates a root schema.
*
* @param addMetadataSchema Whether to add a "metadata" schema containing
* definitions of tables, columns etc.
* @param cache If true create {@link CachingCalciteSchema};
* if false create {@link SimpleCalciteSchema}
* @param name Schema name
*/
public static CalciteSchema createRootSchema(boolean addMetadataSchema,
boolean cache, String name) {
final Schema rootSchema = new CalciteConnectionImpl.RootSchema();
return createRootSchema(addMetadataSchema, cache, name, rootSchema);
}
@Experimental
public static CalciteSchema createRootSchema(boolean addMetadataSchema,
boolean cache, String name, Schema schema) {
CalciteSchema rootSchema;
if (cache) {
rootSchema = new CachingCalciteSchema(null, schema, name);
} else {
rootSchema = new SimpleCalciteSchema(null, schema, name);
}
if (addMetadataSchema) {
rootSchema.add("metadata", MetadataSchema.INSTANCE);
}
return rootSchema;
}
@Experimental
public boolean removeSubSchema(String name) {
return subSchemaMap.remove(name) != null;
}
@Experimental
public boolean removeTable(String name) {
return tableMap.remove(name) != null;
}
@Experimental
public boolean removeFunction(String name) {
final FunctionEntry remove = nullaryFunctionMap.remove(name);
if (remove == null) {
return false;
}
functionMap.remove(name, remove);
return true;
}
@Experimental
public boolean removeType(String name) {
return typeMap.remove(name) != null;
}
/**
* Entry in a schema, such as a table or sub-schema.
*
*
Each object's name is a property of its membership in a schema;
* therefore in principle it could belong to several schemas, or
* even the same schema several times, with different names. In this
* respect, it is like an inode in a Unix file system.
*
*
The members of a schema must have unique names.
*/
public abstract static class Entry {
public final CalciteSchema schema;
public final String name;
protected Entry(CalciteSchema schema, String name) {
this.schema = Objects.requireNonNull(schema, "schema");
this.name = Objects.requireNonNull(name, "name");
}
/** Returns this object's path. For example ["hr", "emps"]. */
public final List path() {
return schema.path(name);
}
}
/** Membership of a table in a schema. */
public abstract static class TableEntry extends Entry {
public final ImmutableList sqls;
protected TableEntry(CalciteSchema schema, String name,
ImmutableList sqls) {
super(schema, name);
this.sqls = Objects.requireNonNull(sqls, "sqls");
}
public abstract Table getTable();
}
/** Membership of a type in a schema. */
public abstract static class TypeEntry extends Entry {
protected TypeEntry(CalciteSchema schema, String name) {
super(schema, name);
}
public abstract RelProtoDataType getType();
}
/** Membership of a function in a schema. */
public abstract static class FunctionEntry extends Entry {
protected FunctionEntry(CalciteSchema schema, String name) {
super(schema, name);
}
public abstract Function getFunction();
/** Whether this represents a materialized view. (At a given point in time,
* it may or may not be materialized as a table.) */
public abstract boolean isMaterialization();
}
/** Membership of a lattice in a schema. */
public abstract static class LatticeEntry extends Entry {
protected LatticeEntry(CalciteSchema schema, String name) {
super(schema, name);
}
public abstract Lattice getLattice();
public abstract TableEntry getStarTable();
}
/** Implementation of {@link SchemaPlus} based on a
* {@link com.hazelcast.shaded.org.apache.calcite.jdbc.CalciteSchema}. */
private class SchemaPlusImpl implements SchemaPlus {
CalciteSchema calciteSchema() {
return CalciteSchema.this;
}
@Override public @Nullable SchemaPlus getParentSchema() {
return parent == null ? null : parent.plus();
}
@Override public String getName() {
return CalciteSchema.this.getName();
}
@Override public boolean isMutable() {
return schema.isMutable();
}
@Override public void setCacheEnabled(boolean cache) {
CalciteSchema.this.setCache(cache);
}
@Override public boolean isCacheEnabled() {
return CalciteSchema.this.isCacheEnabled();
}
@Override public Schema snapshot(SchemaVersion version) {
throw new UnsupportedOperationException();
}
@Override public Expression getExpression(@Nullable SchemaPlus parentSchema, String name) {
return schema.getExpression(parentSchema, name);
}
@Override public @Nullable Table getTable(String name) {
final TableEntry entry = CalciteSchema.this.getTable(name, true);
return entry == null ? null : entry.getTable();
}
@Override public NavigableSet getTableNames() {
return CalciteSchema.this.getTableNames();
}
@Override public @Nullable RelProtoDataType getType(String name) {
final TypeEntry entry = CalciteSchema.this.getType(name, true);
return entry == null ? null : entry.getType();
}
@Override public Set getTypeNames() {
return CalciteSchema.this.getTypeNames();
}
@Override public Collection getFunctions(String name) {
return CalciteSchema.this.getFunctions(name, true);
}
@Override public NavigableSet getFunctionNames() {
return CalciteSchema.this.getFunctionNames();
}
@Override public @Nullable SchemaPlus getSubSchema(String name) {
final CalciteSchema subSchema =
CalciteSchema.this.getSubSchema(name, true);
return subSchema == null ? null : subSchema.plus();
}
@Override public Set getSubSchemaNames() {
//noinspection RedundantCast
return (Set) CalciteSchema.this.getSubSchemaMap().keySet();
}
@Override public SchemaPlus add(String name, Schema schema) {
final CalciteSchema calciteSchema = CalciteSchema.this.add(name, schema);
return calciteSchema.plus();
}
@Override public T unwrap(Class clazz) {
if (clazz.isInstance(this)) {
return clazz.cast(this);
}
if (clazz.isInstance(CalciteSchema.this)) {
return clazz.cast(CalciteSchema.this);
}
if (clazz.isInstance(CalciteSchema.this.schema)) {
return clazz.cast(CalciteSchema.this.schema);
}
if (clazz == DataSource.class) {
if (schema instanceof JdbcSchema) {
return clazz.cast(((JdbcSchema) schema).getDataSource());
}
if (schema instanceof JdbcCatalogSchema) {
return clazz.cast(((JdbcCatalogSchema) schema).getDataSource());
}
}
throw new ClassCastException("not a " + clazz);
}
@Override public void setPath(ImmutableList> path) {
CalciteSchema.this.path = path;
}
@Override public void add(String name, Table table) {
CalciteSchema.this.add(name, table);
}
@Override public boolean removeTable(String name) {
return CalciteSchema.this.removeTable(name);
}
@Override public void add(String name, Function function) {
CalciteSchema.this.add(name, function);
}
@Override public void add(String name, RelProtoDataType type) {
CalciteSchema.this.add(name, type);
}
@Override public void add(String name, Lattice lattice) {
CalciteSchema.this.add(name, lattice);
}
}
/**
* Implementation of {@link CalciteSchema.TableEntry}
* where all properties are held in fields.
*/
public static class TableEntryImpl extends TableEntry {
private final Table table;
/** Creates a TableEntryImpl. */
public TableEntryImpl(CalciteSchema schema, String name, Table table,
ImmutableList sqls) {
super(schema, name, sqls);
this.table = Objects.requireNonNull(table, "table");
}
@Override public Table getTable() {
return table;
}
}
/**
* Implementation of {@link TypeEntry}
* where all properties are held in fields.
*/
public static class TypeEntryImpl extends TypeEntry {
private final RelProtoDataType protoDataType;
/** Creates a TypeEntryImpl. */
public TypeEntryImpl(CalciteSchema schema, String name, RelProtoDataType protoDataType) {
super(schema, name);
this.protoDataType = protoDataType;
}
@Override public RelProtoDataType getType() {
return protoDataType;
}
}
/**
* Implementation of {@link FunctionEntry}
* where all properties are held in fields.
*/
public static class FunctionEntryImpl extends FunctionEntry {
private final Function function;
/** Creates a FunctionEntryImpl. */
public FunctionEntryImpl(CalciteSchema schema, String name,
Function function) {
super(schema, name);
this.function = function;
}
@Override public Function getFunction() {
return function;
}
@Override public boolean isMaterialization() {
return function
instanceof MaterializedViewTable.MaterializedViewTableMacro;
}
}
/**
* Implementation of {@link LatticeEntry}
* where all properties are held in fields.
*/
public static class LatticeEntryImpl extends LatticeEntry {
private final Lattice lattice;
private final CalciteSchema.TableEntry starTableEntry;
/** Creates a LatticeEntryImpl. */
public LatticeEntryImpl(CalciteSchema schema, String name,
Lattice lattice) {
super(schema, name);
this.lattice = lattice;
// Star table has same name as lattice and is in same schema.
final StarTable starTable = lattice.createStarTable();
starTableEntry = schema.add(name, starTable);
}
@Override public Lattice getLattice() {
return lattice;
}
@Override public TableEntry getStarTable() {
return starTableEntry;
}
}
}