All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbstractConverter |
Converts a relational expression to any given output convention.
|
AbstractConverter.ExpandConversionRule |
Rule which converts an AbstractConverter into a chain of
converters from the source relation to the target traits.
|
AbstractEnumerable<T> |
Abstract implementation of the Enumerable interface that
implements the extension methods.
|
AbstractEnumerable2<T> |
Abstract implementation of the Enumerable
interface that implements the extension methods.
|
AbstractImmutableList<E> |
Base class for lists whose contents are constant after creation.
|
AbstractJoinExtractFilterRule |
|
AbstractMaterializedViewRule |
Planner rule that converts a Project
followed by Aggregate or an
Aggregate to a scan (and possibly
other operations) over a materialized view.
|
AbstractMaterializedViewRule.Edge |
Edge for graph
|
AbstractMaterializedViewRule.EquivalenceClasses |
Class representing an equivalence class, i.e., a set of equivalent columns
|
AbstractMaterializedViewRule.MatchModality |
Complete, view partial, or query partial.
|
AbstractMaterializedViewRule.MaterializedViewAggregateRule |
Materialized view rewriting for aggregate
|
AbstractMaterializedViewRule.MaterializedViewJoinRule |
Materialized view rewriting for join
|
AbstractMaterializedViewRule.MaterializedViewOnlyAggregateRule |
Rule that matches Aggregate.
|
AbstractMaterializedViewRule.MaterializedViewOnlyFilterRule |
Rule that matches Filter.
|
AbstractMaterializedViewRule.MaterializedViewOnlyJoinRule |
Rule that matches Join.
|
AbstractMaterializedViewRule.MaterializedViewProjectAggregateRule |
Rule that matches Project on Aggregate.
|
AbstractMaterializedViewRule.MaterializedViewProjectFilterRule |
Rule that matches Project on Filter.
|
AbstractMaterializedViewRule.MaterializedViewProjectJoinRule |
Rule that matches Project on Join.
|
AbstractMaterializedViewRule.NodeLineage |
Expression lineage details.
|
AbstractMaterializedViewRule.ViewPartialRewriting |
View partitioning result
|
AbstractNamespace |
|
AbstractNode |
Abstract implementation of Node .
|
AbstractQueryable<T> |
Abstract implementation of the Queryable interface that implements
the extension methods.
|
AbstractQueryableTable |
Abstract base class for implementing Table .
|
AbstractRelNode |
Base class for every relational expression ( RelNode ).
|
AbstractRelOptPlanner |
Abstract base for implementations of the RelOptPlanner interface.
|
AbstractSchema |
Abstract implementation of Schema .
|
AbstractSchema.Factory |
|
AbstractSingleNode<T extends SingleRel> |
An interpreter that takes expects one incoming source relational expression.
|
AbstractSourceMapping |
Simple implementation of
Mappings.TargetMapping where the
number of sources and targets are specified as constructor parameters and you
just need to implement one method,
|
AbstractSqlType |
Abstract base class for SQL implementations of RelDataType .
|
AbstractTable |
Abstract base class for implementing Table .
|
AbstractTableQueryable<T> |
|
AbstractTargetMapping |
Simple implementation of
Mappings.TargetMapping where the
number of sources and targets are specified as constructor parameters and you
just need to implement one method,
|
AccessSqlDialect |
A SqlDialect implementation for the Access database.
|
AggAddContext |
|
AggAddContextImpl |
|
AggChecker |
Visitor which throws an exception if any component of the expression is not a
group expression.
|
AggContext |
Information on the aggregate calculation context.
|
AggFinder |
Visitor that looks for an aggregate function inside a tree of
SqlNode objects and throws Util.FoundOne when it finds
one.
|
AggFinder.AggIterable |
Iterates over all aggregates.
|
AggImplementor |
Implements an aggregate function by generating expressions to
initialize, add to, and get a result from, an accumulator.
|
AggImpState |
Represents internal state when implementing aggregate functions.
|
Aggregate |
Relational operator that eliminates
duplicates and computes totals.
|
Aggregate.AggCallBinding |
|
Aggregate.Group |
What kind of roll-up is it?
|
AggregateCall |
Call to an aggregate function within an
Aggregate .
|
AggregateExpandDistinctAggregatesRule |
Planner rule that expands distinct aggregates
(such as COUNT(DISTINCT x) ) from a
Aggregate .
|
AggregateExtractProjectRule |
|
AggregateFilterTransposeRule |
Planner rule that matches an Aggregate
on a Filter and transposes them,
pushing the aggregate below the filter.
|
AggregateFunction |
Function that combines several values into a scalar result.
|
AggregateFunctionImpl |
|
AggregateJoinTransposeRule |
|
AggregateJoinTransposeRule.Side |
Work space for an input to a join.
|
AggregateLambdaFactory<TSource,TOrigAccumulate,TAccumulate,TResult,TKey> |
|
AggregateNode |
Interpreter node that implements an
Aggregate .
|
AggregateNode.Accumulator |
Defines function implementation for
things like count() and sum() .
|
AggregateNode.AccumulatorFactory |
|
AggregateNode.AccumulatorList |
A list of accumulators used during grouping.
|
AggregateNode.CountAccumulator |
Accumulator for calls to the COUNT function.
|
AggregateNode.DoubleSum |
Implementation of SUM over DOUBLE values as a user-defined
aggregate.
|
AggregateNode.FilterAccumulator |
Accumulator that applies a filter to another accumulator.
|
AggregateNode.IntSum |
Implementation of SUM over INTEGER values as a user-defined
aggregate.
|
AggregateNode.LongSum |
Implementation of SUM over BIGINT values as a user-defined
aggregate.
|
AggregateNode.MaxDouble |
Implementation of MAX function to calculate the minimum of
double and real values as a user-defined aggregate.
|
AggregateNode.MaxFloat |
Implementation of MAX function to calculate the minimum of
float values as a user-defined aggregate.
|
AggregateNode.MaxInt |
Implementation of MAX function to calculate the minimum of
integer values as a user-defined aggregate.
|
AggregateNode.MaxLong |
Implementation of MAX function to calculate the minimum of
long values as a user-defined aggregate.
|
AggregateNode.MinDouble |
Implementation of MIN function to calculate the minimum of
double and real values as a user-defined aggregate.
|
AggregateNode.MinFloat |
Implementation of MIN function to calculate the minimum of
float values as a user-defined aggregate.
|
AggregateNode.MinInt |
Implementation of MIN function to calculate the minimum of
integer values as a user-defined aggregate.
|
AggregateNode.MinLong |
Implementation of MIN function to calculate the minimum of
long values as a user-defined aggregate.
|
AggregateNode.NumericComparison<T> |
Common implementation of comparison aggregate methods over numeric
values as a user-defined aggregate.
|
AggregateNode.ScalarAccumulator |
Accumulator powered by Scalar code fragments.
|
AggregateNode.ScalarAccumulatorDef |
Accumulator powered by Scalar code fragments.
|
AggregateNode.UdaAccumulator |
Accumulator based upon a user-defined aggregate.
|
AggregateNode.UdaAccumulatorFactory |
Accumulator factory based on a user-defined aggregate function.
|
AggregateProjectMergeRule |
Planner rule that recognizes a Aggregate
on top of a Project and if possible
aggregate through the project or removes the project.
|
AggregateProjectPullUpConstantsRule |
Planner rule that removes constant keys from an
Aggregate .
|
AggregateReduceFunctionsRule |
Planner rule that reduces aggregate functions in
Aggregate s to simpler forms.
|
AggregateRemoveRule |
Planner rule that removes
a Aggregate
if it computes no aggregate functions
(that is, it is implementing SELECT DISTINCT )
and the underlying relational expression is already distinct.
|
AggregateStarTableRule |
|
AggregateUnionAggregateRule |
Planner rule that matches
Aggregate s beneath a
Union and pulls them up, so
that a single
Aggregate removes duplicates.
|
AggregateUnionTransposeRule |
|
AggregateValuesRule |
|
AggregatingScope |
An extension to the SqlValidatorScope interface which indicates that
the scope is aggregating.
|
AggregatingSelectScope |
Scope for resolving identifiers within a SELECT statement that has a
GROUP BY clause.
|
AggResetContext |
|
AggResetContextImpl |
|
AggResultContext |
|
AggResultContextImpl |
|
AggVisitor |
Visitor that can find aggregate and windowed aggregate functions.
|
AliasNamespace |
Namespace for an AS t(c1, c2, ...) clause.
|
AnsiSqlDialect |
A SqlDialect implementation for an unknown ANSI compatible database.
|
Array |
Annotation that indicates that a field is an array type.
|
ArrayBindable |
Extension to Bindable that returns rows that are arrays of objects.
|
ArrayComparator |
Compares arrays.
|
ArrayEnumeratorCursor |
Implementation of Cursor on top of an
Enumerator that
returns an array of Object for each row.
|
ArrayLengthRecordField |
Represents a length field of a RecordType
|
ArraySqlType |
SQL array type.
|
ArrayTable |
Implementation of table that reads rows from column stores, one per column.
|
ArrayTable.BitSlicedPrimitiveArray |
Representation that stores numeric values in a bit-sliced
array.
|
ArrayTable.ByteStringDictionary |
Representation that stores byte-string column values.
|
ArrayTable.Column |
Column definition and value set.
|
ArrayTable.Constant |
Representation of a column that has the same value for every row.
|
ArrayTable.Content |
Contents of a table.
|
ArrayTable.Content.ArrayEnumerator |
Enumerator over a table with more than one column; each element
returned is an array.
|
ArrayTable.Content.ObjectEnumerator |
Enumerator over a table with a single column; each element
returned is an object.
|
ArrayTable.ObjectArray |
Representation that stores the column values in an array.
|
ArrayTable.ObjectDictionary |
Representation that stores the values of a column as a
dictionary of objects.
|
ArrayTable.PrimitiveArray |
Representation that stores the values of a column in an array of
primitive values.
|
ArrayTable.PrimitiveDictionary |
Representation that stores column values in a dictionary of
primitive values, then uses a short code for each row.
|
ArrayTable.Representation |
Representation of the values of a column.
|
ArrayTable.RepresentationType |
How a column's values are represented.
|
ArrayTable.StringDictionary |
Representation that stores string column values.
|
AssignableOperandTypeChecker |
AssignableOperandTypeChecker implements SqlOperandTypeChecker by
verifying that the type of each argument is assignable to a predefined set of
parameter types (under the SQL definition of "assignable").
|
Ast |
Abstract syntax tree.
|
Ast.Assignment |
Abstract base class for statements that assign to a named relation.
|
Ast.Assignment1 |
Abstract base class for an assignment with one source relation.
|
Ast.BagType |
Parse tree for a bag type.
|
Ast.Call |
Parse tree node for a call to a function or operator.
|
Ast.DescribeStmt |
Parse tree node for DESCRIBE statement.
|
Ast.Direction |
Sort direction.
|
Ast.DistinctStmt |
Parse tree node for DISTINCT statement.
|
Ast.DumpStmt |
Parse tree node for DUMP statement.
|
Ast.FieldSchema |
Parse tree for field schema.
|
Ast.FilterStmt |
Parse tree node for FILTER statement.
|
Ast.ForeachNestedStmt |
Parse tree node for FOREACH statement (nested).
|
Ast.ForeachStmt |
Parse tree node for FOREACH statement (non-nested).
|
Ast.GroupStmt |
Parse tree node for GROUP statement.
|
Ast.Identifier |
Parse tree node for Identifier.
|
Ast.LimitStmt |
Parse tree node for LIMIT statement.
|
Ast.Literal |
Parse tree node for Literal.
|
Ast.LoadStmt |
Parse tree node for LOAD statement.
|
Ast.MapType |
Parse tree for a map type.
|
Ast.Node |
Abstract base class for parse tree node.
|
Ast.NumericLiteral |
Parse tree node for NumericLiteral.
|
Ast.Op |
Parse tree node type.
|
Ast.OrderStmt |
Parse tree node for ORDER statement.
|
Ast.Program |
Parse tree node for a program.
|
Ast.ScalarType |
Parse tree for scalar type such as int .
|
Ast.Schema |
Parse tree for schema.
|
Ast.SpecialIdentifier |
Parse tree node for "*", a special kind of identifier.
|
Ast.Stmt |
Abstract base class for parse tree node representing a statement.
|
Ast.TupleType |
Parse tree for a tuple type.
|
Ast.Type |
Parse tree for type.
|
Ast.UnParser |
Contains output and indentation level while a tree of nodes is
being converted to text.
|
Ast.ValuesStmt |
Parse tree node for VALUES statement.
|
AttributedDirectedGraph<V,E extends DefaultEdge> |
Directed graph where edges have attributes and allows multiple edges between
any two vertices provided that their attributes are different.
|
AttributedDirectedGraph.AttributedEdgeFactory<V,E> |
Factory for edges that have attributes.
|
AuxiliaryConverter |
Converts an expression for a group window function (e.g.
|
AuxiliaryConverter.Impl |
|
Babel |
SQL parser that accepts a wide variety of dialects.
|
BarfingInvocationHandler |
A class derived from BarfingInvocationHandler handles a method
call by looking for a method in itself with identical parameters.
|
BaseQueryable<TSource> |
|
BasicSqlType |
BasicSqlType represents a standard atomic SQL type (excluding interval
types).
|
Benchmark |
Helps to run benchmarks by running the same task repeatedly and averaging
the running times.
|
Benchmark.Statistician |
Collects statistics for a test that is run multiple times.
|
BigDecimalFunction1<T0> |
Function that takes one parameter and returns a BigDecimal value.
|
BigQuerySqlDialect |
A SqlDialect implementation for Google BigQuery's "Standard SQL"
dialect.
|
BinaryExpression |
Represents an expression that has a binary operator.
|
BinaryOperatorConversion |
Binary operator conversion utility class used to convert expression like exp1 Operator exp2
|
BinarySearch |
Binary search for the implementation of
RANGE BETWEEN XXX PRECEDING/FOLLOWING clause.
|
Bindable<T> |
Statement that can be bound to a DataContext and then executed.
|
BindableConvention |
Calling convention that returns results as an
Enumerable of object arrays.
|
BindableRel |
Relational expression that can implement itself in Bindable
convention.
|
Bindables |
|
Bindables.BindableAggregate |
Implementation of Aggregate
in bindable calling convention.
|
Bindables.BindableAggregateRule |
Rule that converts an Aggregate to bindable convention.
|
Bindables.BindableFilter |
Implementation of Filter
in bindable convention.
|
Bindables.BindableFilterRule |
Rule that converts a Filter to bindable convention.
|
Bindables.BindableJoin |
Implementation of Join in
bindable calling convention.
|
Bindables.BindableJoinRule |
|
Bindables.BindableProject |
Implementation of Project in
bindable calling convention.
|
Bindables.BindableProjectRule |
|
Bindables.BindableSort |
Implementation of Sort
bindable calling convention.
|
Bindables.BindableSortRule |
|
Bindables.BindableTableScan |
|
Bindables.BindableTableScanRule |
Rule that converts a TableScan
to bindable convention.
|
Bindables.BindableUnion |
Implementation of Union in
bindable calling convention.
|
Bindables.BindableUnionRule |
|
Bindables.BindableValues |
Implementation of Values
in bindable calling convention.
|
Bindables.BindableValuesRule |
Rule that converts a Values to bindable convention.
|
Bindables.BindableWindow |
Implementation of Window
in bindable convention.
|
Bindables.BindableWindowRule |
|
BiRel |
Abstract base class for relational expressions with a two inputs.
|
BitSets |
Utility functions for BitSet .
|
BitSets.Closure |
Setup equivalence Sets for each position.
|
BitString |
String of bits.
|
BlockBuilder |
|
BlockBuilder.InlineVariableVisitor |
Inline Variable Visitor.
|
BlockBuilder.Slot |
Holds the number of times a declaration was used.
|
BlockBuilder.SubstituteVariableVisitor |
Substitute Variable Visitor.
|
BlockBuilder.UseCounter |
Use counter.
|
Blocks |
|
BlockStatement |
Represents a block that contains a sequence of expressions where variables
can be defined.
|
BreadthFirstIterator<V,E extends DefaultEdge> |
Iterates over the vertices in a directed graph in breadth-first order.
|
Bug |
Holder for a list of constants describing which bugs which have not been
fixed.
|
BuiltInMetadata |
Contains the interfaces for several common forms of metadata.
|
BuiltInMetadata.All |
The built-in forms of metadata.
|
BuiltInMetadata.AllPredicates |
Metadata about the predicates that hold in the rows emitted from a
relational expression.
|
BuiltInMetadata.AllPredicates.Handler |
Handler API.
|
BuiltInMetadata.Collation |
Metadata about which columns are sorted.
|
BuiltInMetadata.Collation.Handler |
Handler API.
|
BuiltInMetadata.ColumnOrigin |
Metadata about the origins of columns.
|
BuiltInMetadata.ColumnOrigin.Handler |
Handler API.
|
BuiltInMetadata.ColumnUniqueness |
Metadata about whether a set of columns uniquely identifies a row.
|
BuiltInMetadata.ColumnUniqueness.Handler |
Handler API.
|
BuiltInMetadata.CumulativeCost |
Metadata about the cost of evaluating a relational expression, including
all of its inputs.
|
BuiltInMetadata.CumulativeCost.Handler |
Handler API.
|
BuiltInMetadata.DistinctRowCount |
Metadata about the number of distinct rows returned by a set of columns
in a relational expression.
|
BuiltInMetadata.DistinctRowCount.Handler |
Handler API.
|
BuiltInMetadata.Distribution |
Metadata about how a relational expression is distributed.
|
BuiltInMetadata.Distribution.Handler |
Handler API.
|
BuiltInMetadata.ExplainVisibility |
Metadata about whether a relational expression should appear in a plan.
|
BuiltInMetadata.ExplainVisibility.Handler |
Handler API.
|
BuiltInMetadata.ExpressionLineage |
Metadata about the origins of expressions.
|
BuiltInMetadata.ExpressionLineage.Handler |
Handler API.
|
BuiltInMetadata.MaxRowCount |
Metadata about the maximum number of rows returned by a relational
expression.
|
BuiltInMetadata.MaxRowCount.Handler |
Handler API.
|
BuiltInMetadata.Memory |
Metadata about the memory use of an operator.
|
BuiltInMetadata.Memory.Handler |
Handler API.
|
BuiltInMetadata.MinRowCount |
Metadata about the minimum number of rows returned by a relational
expression.
|
BuiltInMetadata.MinRowCount.Handler |
Handler API.
|
BuiltInMetadata.NodeTypes |
Metadata about the node types in a relational expression.
|
BuiltInMetadata.NodeTypes.Handler |
Handler API.
|
BuiltInMetadata.NonCumulativeCost |
Metadata about the cost of evaluating a relational expression, not
including its inputs.
|
BuiltInMetadata.NonCumulativeCost.Handler |
Handler API.
|
BuiltInMetadata.Parallelism |
Metadata about the degree of parallelism of a relational expression, and
how its operators are assigned to processes with independent resource
pools.
|
BuiltInMetadata.Parallelism.Handler |
Handler API.
|
BuiltInMetadata.PercentageOriginalRows |
Metadata about the proportion of original rows that remain in a relational
expression.
|
BuiltInMetadata.PercentageOriginalRows.Handler |
Handler API.
|
BuiltInMetadata.PopulationSize |
Metadata about the number of distinct values in the original source of a
column or set of columns.
|
BuiltInMetadata.PopulationSize.Handler |
Handler API.
|
BuiltInMetadata.Predicates |
Metadata about the predicates that hold in the rows emitted from a
relational expression.
|
BuiltInMetadata.Predicates.Handler |
Handler API.
|
BuiltInMetadata.RowCount |
Metadata about the number of rows returned by a relational expression.
|
BuiltInMetadata.RowCount.Handler |
Handler API.
|
BuiltInMetadata.Selectivity |
Metadata about the selectivity of a predicate.
|
BuiltInMetadata.Selectivity.Handler |
Handler API.
|
BuiltInMetadata.Size |
Metadata about the size of rows and columns.
|
BuiltInMetadata.Size.Handler |
Handler API.
|
BuiltInMetadata.TableReferences |
Metadata to obtain references to tables used by a given expression.
|
BuiltInMetadata.TableReferences.Handler |
Handler API.
|
BuiltInMetadata.UniqueKeys |
Metadata about which combinations of columns are unique identifiers.
|
BuiltInMetadata.UniqueKeys.Handler |
Handler API.
|
BuiltInMethod |
Built-in methods.
|
CachingCalciteSchema |
Concrete implementation of CalciteSchema that caches tables,
functions and sub-schemas.
|
CachingCalciteSchema.Cached<T> |
Strategy for caching the value of an object and re-creating it if its
value is out of date as of a given timestamp.
|
CachingCalciteSchema.SubSchemaCache |
|
CachingLatticeStatisticProvider |
Implementation of LatticeStatisticProvider that caches single-column
statistics and computes multi-column statistics from these.
|
CachingRelMetadataProvider |
Implementation of the RelMetadataProvider
interface that caches results from an underlying provider.
|
CachingRelMetadataProvider.CacheEntry |
An entry in the cache.
|
Calc |
Calc is an abstract base class for implementations of
LogicalCalc .
|
CalciteCatalogReader |
|
CalciteConnection |
Extension to Calcite's implementation of
JDBC connection allows schemas to be defined
dynamically.
|
CalciteConnectionConfig |
Interface for reading connection properties within Calcite code.
|
CalciteConnectionConfigImpl |
|
CalciteConnectionImpl |
Implementation of JDBC connection
in the Calcite engine.
|
CalciteConnectionImpl.CalciteQueryable<T> |
Implementation of Queryable.
|
CalciteConnectionImpl.CalciteServerImpl |
Implementation of Server.
|
CalciteConnectionImpl.CalciteServerStatementImpl |
|
CalciteConnectionImpl.ContextImpl |
Implementation of Context.
|
CalciteConnectionImpl.DataContextImpl |
Implementation of DataContext.
|
CalciteConnectionImpl.RootSchema |
Schema that has no parents.
|
CalciteConnectionImpl.SlimDataContext |
Implementation of DataContext that has few variables and is
Serializable .
|
CalciteConnectionProperty |
Properties that may be specified on the JDBC connect string.
|
CalciteConnectionProvider |
Provider of calcite connections for end-to-end tests.
|
CalciteContextException |
Exception which contains information about the textual context of the causing
exception.
|
CalciteException |
Base class for all exceptions originating from Farrago.
|
CalciteFactory |
Extension of AvaticaFactory
for Calcite.
|
CalciteJdbc41Factory |
Implementation of AvaticaFactory
for Calcite and JDBC 4.1 (corresponds to JDK 1.7).
|
CalciteJdbc41Factory.CalciteJdbc41Connection |
Implementation of connection for JDBC 4.1.
|
CalciteJdbc41Factory.CalciteJdbc41DatabaseMetaData |
Implementation of database metadata for JDBC 4.1.
|
CalciteJdbc41Factory.CalciteJdbc41PreparedStatement |
Implementation of prepared statement for JDBC 4.1.
|
CalciteJdbc41Factory.CalciteJdbc41Statement |
Implementation of statement for JDBC 4.1.
|
CalciteLogger |
Small extension to Logger with some performance improvements.
|
CalciteMaterializer |
|
CalciteMaterializer.Callback |
Called when we discover a star table that matches.
|
CalciteMaterializer.RelNullShuttle |
Implementation of RelShuttle that returns each relational
expression unchanged.
|
CalciteMetaImpl |
Helper for implementing the getXxx methods such as
AvaticaDatabaseMetaData.getTables(java.lang.String, java.lang.String, java.lang.String, java.lang.String[]) .
|
CalciteMetaImpl.CalciteMetaSchema |
Metadata describing a Calcite schema.
|
CalciteMetaImpl.CalciteMetaTable |
Metadata describing a Calcite table.
|
CalciteMetaImpl.LimitIterator<E> |
Iterator that returns at most limit rows from an underlying
Iterator .
|
CalciteMetaImpl.MetadataTable<E> |
Table whose contents are metadata.
|
CalciteParserException |
Tagging interface to allow a
SqlParseException
to be identified without adding a
dependency on it from client-side code.
|
CalcitePrepare |
API for a service that prepares statements for execution.
|
CalcitePrepare.AnalyzeViewResult |
The result of analyzing a view.
|
CalcitePrepare.CalciteSignature<T> |
The result of preparing a query.
|
CalcitePrepare.Context |
Context for preparing a statement.
|
CalcitePrepare.ConvertResult |
The result of parsing and validating a SQL query and converting it to
relational algebra.
|
CalcitePrepare.Dummy |
Namespace that allows us to define non-abstract methods inside an
interface.
|
CalcitePrepare.Dummy.TrivialSparkHandler |
|
CalcitePrepare.ParseResult |
The result of parsing and validating a SQL query.
|
CalcitePrepare.Query<T> |
A union type of the three possible ways of expressing a query: as a SQL
string, a Queryable or a RelNode .
|
CalcitePrepare.SparkHandler |
Callback to register Spark as the main engine.
|
CalcitePrepare.SparkHandler.RuleSetBuilder |
Allows Spark to declare the rules it needs.
|
CalcitePreparedStatement |
Implementation of PreparedStatement
for the Calcite engine.
|
CalcitePrepareImpl |
Shit just got real.
|
CalcitePrepareImpl.CalcitePreparedExplain |
An EXPLAIN statement, prepared and ready to execute.
|
CalcitePrepareImpl.CalcitePreparingStmt |
Holds state for the process of preparing a SQL statement.
|
CalcitePrepareImpl.EmptyScalarTranslator |
Basic translator.
|
CalcitePrepareImpl.LambdaScalarTranslator |
Translator that looks for parameters.
|
CalcitePrepareImpl.ScalarTranslator |
Translator from Java AST to RexNode .
|
CalciteResource |
Compiler-checked resources for the Calcite project.
|
CalciteResultSet |
Implementation of ResultSet
for the Calcite engine.
|
CalciteRootSchema |
Deprecated. |
CalciteSchema |
Schema.
|
CalciteSchema.Entry |
Entry in a schema, such as a table or sub-schema.
|
CalciteSchema.FunctionEntry |
Membership of a function in a schema.
|
CalciteSchema.FunctionEntryImpl |
|
CalciteSchema.LatticeEntry |
Membership of a lattice in a schema.
|
CalciteSchema.LatticeEntryImpl |
|
CalciteSchema.TableEntry |
Membership of a table in a schema.
|
CalciteSchema.TableEntryImpl |
|
CalciteSchema.TypeEntry |
Membership of a type in a schema.
|
CalciteSchema.TypeEntryImpl |
|
CalciteServer |
Server.
|
CalciteServerStatement |
Statement within a Calcite server.
|
CalciteSqlDialect |
A SqlDialect implementation that produces SQL that can be parsed
by Apache Calcite.
|
CalciteSqlValidator |
Validator.
|
CalciteStatement |
Implementation of Statement
for the Calcite engine.
|
CalciteTimingTracer |
CalciteTimingTracer provides a mechanism for tracing the timing of a call
sequence at nanosecond resolution.
|
CalciteTrace |
Contains all of the tracers used within
org.apache.calcite class libraries.
|
CalciteValidatorException |
Tagging interface to allow a
SqlValidatorException
to be identified without
adding a dependency on it from client-side code.
|
CalcMergeRule |
|
CalcRelSplitter |
CalcRelSplitter operates on a
Calc with multiple RexCall
sub-expressions that cannot all be implemented by a single concrete
RelNode .
|
CalcRelSplitter.CannotImplement |
|
CalcRelSplitter.HighestUsageFinder |
Builds an array of the highest level which contains an expression which
uses each expression as an input.
|
CalcRelSplitter.ImplementTester |
Visitor which returns whether an expression can be implemented in a given
type of relational expression.
|
CalcRelSplitter.InputToCommonExprConverter |
Shuttle which converts every reference to an input field in an expression
to a reference to a common sub-expression.
|
CalcRelSplitter.MaxInputFinder |
Finds the highest level used by any of the inputs of a given expression.
|
CalcRelSplitter.RelType |
Type of relational expression.
|
CalcRemoveRule |
|
CalcSplitRule |
|
CallImplementor |
Implements a call via given translator.
|
CallSiteBinder |
Creates a DynamicExpression that represents a dynamic operation bound
by the provided CallSiteBinder .
|
CancelFlag |
CancelFlag is used to post and check cancellation requests.
|
CartesianProductEnumerator<T,E> |
Enumerator over the cartesian product of enumerators.
|
CaseInsensitiveComparator |
Comparator that compares all strings differently, but if two strings are
equal in case-insensitive match they are right next to each other.
|
CaseInsensitiveComparator.Key |
Enables to create floor and ceiling keys for given string.
|
CassandraEnumerator |
Enumerator that reads from a Cassandra column family.
|
CassandraFilter |
Implementation of a Filter
relational expression in Cassandra.
|
CassandraFilter.Translator |
Translates RexNode expressions into Cassandra expression strings.
|
CassandraLimit |
Implementation of limits in Cassandra.
|
CassandraMethod |
Builtin methods in the Cassandra adapter.
|
CassandraProject |
Implementation of Project
relational expression in Cassandra.
|
CassandraRel |
Relational expression that uses Cassandra calling convention.
|
CassandraRel.Implementor |
Callback for the implementation process that converts a tree of
CassandraRel nodes into a CQL query.
|
CassandraRules |
|
CassandraRules.CassandraConverterRule |
Base class for planner rules that convert a relational expression to
Cassandra calling convention.
|
CassandraRules.CassandraFilterRule |
|
CassandraRules.CassandraLimitRule |
|
CassandraRules.CassandraProjectRule |
|
CassandraRules.CassandraSortRule |
|
CassandraRules.RexToCassandraTranslator |
Translator from RexNode to strings in Cassandra's expression
language.
|
CassandraSchema |
Schema mapped onto a Cassandra column family
|
CassandraSchemaFactory |
|
CassandraSort |
Implementation of Sort
relational expression in Cassandra.
|
CassandraTable |
Table based on a Cassandra column family
|
CassandraTable.CassandraQueryable<T> |
|
CassandraTableScan |
Relational expression representing a scan of a Cassandra collection.
|
CassandraToEnumerableConverter |
Relational expression representing a scan of a table in a Cassandra data source.
|
CassandraToEnumerableConverterRule |
|
CastingList<E> |
Converts a list whose members are automatically down-cast to a given type.
|
CatalogScope |
|
CatchBlock |
Represents a catch statement in a try block.
|
CeilOperatorConversion |
DruidSqlOperatorConverter implementation that handles Ceil operations conversions
|
ChainedPhaseRuleMappingInitializer |
|
ChainedRelMetadataProvider |
|
ChainedRelMetadataProvider.ChainedInvocationHandler |
Invocation handler that calls a list of Metadata objects,
returning the first non-null value.
|
ChainedSqlOperatorTable |
ChainedSqlOperatorTable implements the SqlOperatorTable interface by
chaining together any number of underlying operator table instances.
|
Chi |
Relational operator that converts a stream to a relation.
|
ChinookAvaticaServer |
Wrapping Calcite engine with Avatica tansport for testing JDBC capabilities
between Avatica JDBC transport and Calcite.
|
ChinookAvaticaServer.CalciteChinookMetaFactory |
Factory for Chinook Calcite database wrapped in meta for Avatica.
|
ChinookAvaticaServer.RawChinookMetaFactory |
Factory for Chinook Calcite database wrapped in meta for Avatica.
|
ChosenCustomerEmail |
Example UDF for where clause to check pushing to JDBC
|
ChunkList<E> |
Implementation of list similar to LinkedList , but stores elements
in chunks of 32 elements.
|
ClassDeclaration |
Declaration of a class.
|
ClassDeclarationFinder |
Entry point for optimizers that factor ou deterministic expressions to
final static fields.
|
CloneSchema |
Schema that contains in-memory copies of tables from a JDBC schema.
|
CloneSchema.Factory |
|
ClosableAllocation |
ClosableAllocation represents an object which requires a call in order to
release resources early rather than waiting for finalization.
|
ClosableAllocationOwner |
ClosableAllocationOwner represents an object which can take ownership of
ClosableAllocations and guarantee that they will be cleaned up correctly when
its own closeAllocation() is called.
|
Closer |
Helper that holds onto AutoCloseable resources and releases them
when its #close method is called.
|
CodesFunction |
Example Table Function for lateral join checks
|
CoerceInputsRule |
CoerceInputsRule pre-casts inputs to a particular type.
|
Collect |
A relational expression that collapses multiple rows into one.
|
CollectNamespace |
Namespace for COLLECT and TABLE constructs.
|
CollectScope |
The name-resolution context for expression inside a multiset call.
|
ColumnLoader<T> |
Column loader.
|
ColumnLoader.Kev |
Key-value pair.
|
ColumnLoader.ValueSet |
Set of values of a column, created during the load process, and converted
to a serializable (and more compact) form before load completes.
|
ColumnStrategy |
Describes how a column gets populated.
|
CommonRelSubExprRule |
A CommonRelSubExprRule is an abstract base class for rules
that are fired only on relational expressions that appear more than once
in a query tree.
|
ComparableOperandTypeChecker |
Type checking strategy which verifies that types have the required attributes
to be used as arguments to comparison operators.
|
Compiler |
Context while converting a tree of RelNode to a program
that can be run by an Interpreter .
|
ComplexMetric |
Used to store information about available complex metrics in the Druid Adapter
|
CompositeList<T> |
Read-only list that is the concatenation of sub-lists.
|
CompositeMap<K,V> |
Unmodifiable view onto multiple backing maps.
|
CompositeOperandTypeChecker |
|
CompositeOperandTypeChecker.Composition |
How operands are composed.
|
CompositeSingleOperandTypeChecker |
|
CompoundClosableAllocation |
CompoundClosableAllocation represents a collection of ClosableAllocations
which share a common lifecycle.
|
ConditionalExpression |
Represents an expression that has a conditional operator.
|
ConditionalStatement |
Represents an expression that has a conditional operator.
|
ConnectionFactory |
Wrapping connection factory for quidem
|
ConnectionFactory.DatabaseWrapper |
Wrapping with Fairy environmental decoration
|
ConsList<E> |
List that consists of a head element and an immutable non-empty list.
|
ConstantExpression |
Represents an expression that has a constant value.
|
ConstantUntypedNull |
Represents a constant null of unknown type
Java allows type inference for such nulls, thus "null" cannot always be
replaced to (Object)null and vise versa.
|
ConstructorDeclaration |
Declaration of a constructor.
|
Context |
Context for executing a scalar expression in an interpreter.
|
Context |
Provides library users a way to store data within the planner session and
access it within rules.
|
Contexts |
|
Contexts.ChainContext |
Context that wraps a chain of contexts.
|
Contexts.EmptyContext |
Empty context.
|
Contexts.WrapContext |
Context that wraps an object.
|
ControlFlowException |
Exception intended to be used for control flow, as opposed to the usual
use of exceptions which is to signal an error condition.
|
Convention |
Calling convention trait.
|
Convention.Impl |
Default implementation.
|
ConventionTraitDef |
Definition of the the convention trait.
|
ConventionTraitDef.ConversionData |
Workspace for converting from one convention to another.
|
ConversionUtil |
Utility functions for converting from one type to another
|
Converter |
A relational expression implements the interface Converter to
indicate that it converts a physical attribute, or
trait , of a relational expression
from one value to another.
|
ConverterImpl |
|
ConverterRule |
Abstract base class for a rule which converts from one calling convention to
another without changing semantics.
|
Correlate |
A relational operator that performs nested-loop joins.
|
CorrelateJoinType |
Specifies the type of correlation operation: inner, left, semi, or anti.
|
CorrelationId |
Describes the necessary parameters for an implementation in order to
identify and set dynamic variables
|
CorrelationReferenceFinder |
|
CorrelationReferenceFinder.MyRexVisitor |
Replaces alternative names of correlation variable to its canonical name.
|
CsvEnumerator<E> |
Enumerator that reads from a CSV file.
|
CsvEnumerator.ArrayRowConverter |
Array row converter.
|
CsvEnumerator.RowConverter<E> |
Row converter.
|
CsvEnumerator.SingleColumnRowConverter |
Single column row converter.
|
CsvFieldType |
Type of a field in a CSV file.
|
CsvFilterableTable |
Table based on a CSV file that can implement simple filtering.
|
CsvProjectTableScanRule |
Planner rule that projects from a CsvTableScan scan just the columns
needed to satisfy a projection.
|
CsvScannableTable |
Table based on a CSV file.
|
CsvSchema |
Schema mapped onto a directory of CSV files.
|
CsvSchemaFactory |
|
CsvStreamReader |
Extension to CSVReader that can read newly appended file content.
|
CsvStreamReader.CsvContentListener |
Watches for content being appended to a CSV file.
|
CsvStreamScannableTable |
Table based on a CSV file.
|
CsvStreamTableFactory |
|
CsvTable |
Base class for table that reads CSV files.
|
CsvTable.Flavor |
Various degrees of table "intelligence".
|
CsvTableFactory |
|
CsvTableScan |
Relational expression representing a scan of a CSV file.
|
CsvTranslatableTable |
Table based on a CSV file.
|
CursorReturnTypeInference |
Returns the rowtype of a cursor of the operand at a particular 0-based
ordinal position.
|
CustomColumnResolvingTable |
Extension to Table that specifies a custom way to resolve column
names.
|
CycleDetector<V,E extends DefaultEdge> |
Detects cycles in directed graphs.
|
CyclicDefinitionException |
Thrown when an object, such as a view, is found to have a cylic
definition.
|
CyclicMetadataException |
Exception that indicates that a cycle has been detected while
computing metadata.
|
DataContext |
Runtime context allowing access to the tables in a database.
|
DataContext.Variable |
|
DateRangeRules |
Collection of planner rules that convert
EXTRACT(timeUnit FROM dateTime) = constant ,
FLOOR(dateTime to timeUnit = constant} and
CEIL(dateTime to timeUnit = constant} to
dateTime BETWEEN lower AND upper .
|
DateRangeRules.ExtractFinder |
Visitor that searches for calls to EXTRACT , FLOOR or
CEIL , building a list of distinct time units.
|
DateRangeRules.ExtractShuttle |
Walks over an expression, replacing calls to
EXTRACT , FLOOR and CEIL with date ranges.
|
DateRangeRules.FilterDateRangeRule |
Rule that converts EXTRACT, FLOOR and CEIL in a Filter into a date
range.
|
DateString |
Date literal.
|
DateTimeStringUtils |
Utility methods to manipulate String representation of DateTime values.
|
Db2SqlDialect |
A SqlDialect implementation for the IBM DB2 database.
|
DeclarationStatement |
Expression that declares and optionally initializes a variable.
|
DeduplicateCorrelateVariables |
Rewrites relations to ensure the same correlation is referenced by the same
correlation variable.
|
DeduplicateCorrelateVariables.DeduplicateCorrelateVariablesShuttle |
Replaces alternative names of correlation variable to its canonical name.
|
DefaultDimensionSpec |
Default implementation of DimensionSpec.
|
DefaultDirectedGraph<V,E extends DefaultEdge> |
|
DefaultDirectedGraph.VertexInfo<V,E> |
Information about an edge.
|
DefaultEdge |
Default implementation of Edge.
|
DefaultEnumerable<T> |
Implementation of the Enumerable interface
that implements the extension methods by calling into the Extensions
class.
|
DefaultExpression |
Represents the default value of a type or an empty expression.
|
DefaultQueryable<T> |
Implementation of the Queryable interface that
implements the extension methods by calling into the Extensions
class.
|
DefaultRelMetadataProvider |
DefaultRelMetadataProvider supplies a default implementation of the
RelMetadataProvider interface.
|
DelegatingEnumerator<T> |
Simple enumerator that just delegates all calls to the passed enumerator.
|
DelegatingInvocationHandler |
A class derived from DelegatingInvocationHandler handles a
method call by looking for a method in itself with identical parameters.
|
DelegatingLatticeStatisticProvider |
|
DelegatingNamespace |
|
DelegatingSchema |
Implementation of Schema that delegates to
an underlying schema.
|
DelegatingScope |
A scope which delegates all requests to its parent scope.
|
DelegatingSqlValidatorCatalogReader |
|
DelegatingSqlValidatorTable |
|
DelegatingTypeSystem |
|
Delta |
Relational operator that converts a relation to a stream.
|
Demo |
Demo.
|
DepthFirstIterator<V,E extends DefaultEdge> |
Iterates over the vertices in a directed graph in depth-first order.
|
DerbySqlDialect |
A SqlDialect implementation for the Apache Derby database.
|
Deterministic |
Specifies that function is deterministic (i.e.
|
DeterministicCodeOptimizer |
Factors out deterministic expressions to final static fields.
|
DimensionSpec |
Interface for Druid DimensionSpec.
|
DirectedGraph<V,E> |
Directed graph.
|
DirectedGraph.EdgeFactory<V,E> |
Factory for edges.
|
DirectOperatorConversion |
Direct operator conversion for expression like Function(exp_1,...exp_n)
|
DoubleFunction1<T0> |
Function that takes one parameter and returns a native double value.
|
Driver |
Calcite JDBC driver.
|
DruidConnection |
Connection to Druid.
|
DruidConnectionImpl |
|
DruidConnectionImpl.BlockingQueueEnumerator<E> |
An Enumerator that gets its rows from a BlockingQueue .
|
DruidConnectionImpl.JsonAggregator |
Element of the "aggregators" collection in the result of a
"segmentMetadata" call, populated by Jackson.
|
DruidConnectionImpl.JsonColumn |
Element of the "columns" collection in the result of a
"segmentMetadata" call, populated by Jackson.
|
DruidConnectionImpl.JsonSegmentMetadata |
Result of a "segmentMetadata" call, populated by Jackson.
|
DruidConnectionImpl.Page |
Progress through a large fetch.
|
DruidConnectionImpl.RunnableQueueSink |
A Sink that is also Runnable .
|
DruidDateTimeUtils |
Utilities for generating intervals from RexNode.
|
DruidExpressions |
Expression utility class to transform Calcite expressions to Druid expressions when possible.
|
DruidJson |
Object that knows how to write itself to a
JsonGenerator .
|
DruidJsonFilter |
Filter element of a Druid "groupBy" or "topN" query.
|
DruidJsonFilter.JsonBound |
Bound filter.
|
DruidJsonFilter.JsonCompositeFilter |
Filter that combines other filters using a boolean operator.
|
DruidJsonFilter.JsonDimHavingFilter |
Druid Having Filter spec
|
DruidJsonFilter.JsonExpressionFilter |
Druid Expression filter.
|
DruidJsonFilter.JsonInFilter |
IN filter.
|
DruidJsonFilter.JsonSelector |
Equality filter.
|
DruidJsonFilter.Type |
Supported filter types
|
DruidQuery |
Relational expression representing a scan of a Druid data set.
|
DruidQuery.DruidQueryNode |
Interpreter node that executes a Druid query and sends the results to a
Sink .
|
DruidQuery.JsonAggregation |
Aggregation element of a Druid "groupBy" or "topN" query.
|
DruidQuery.JsonCardinalityAggregation |
Aggregation element that calls the "cardinality" function.
|
DruidQuery.JsonCollation |
Collation element of a Druid "groupBy" query.
|
DruidQuery.JsonExpressionPostAgg |
Druid Json Expression post aggregate.
|
DruidQuery.JsonFilteredAggregation |
Aggregation element that contains a filter
|
DruidQuery.JsonLimit |
Collation element of a Druid "groupBy" query.
|
DruidQuery.JsonPostAggregation |
Post-Aggregator Post aggregator abstract writer
|
DruidQuery.QuerySpec |
Druid query specification.
|
DruidQuery.ScanQuery |
Druid Scan Query Body
|
DruidRules |
|
DruidRules.DruidAggregateExtractProjectRule |
|
DruidRules.DruidAggregateFilterTransposeRule |
|
DruidRules.DruidAggregateProjectRule |
|
DruidRules.DruidAggregateRule |
|
DruidRules.DruidFilterAggregateTransposeRule |
|
DruidRules.DruidFilterProjectTransposeRule |
|
DruidRules.DruidFilterRule |
|
DruidRules.DruidHavingFilterRule |
|
DruidRules.DruidPostAggregationProjectRule |
|
DruidRules.DruidProjectFilterTransposeRule |
|
DruidRules.DruidProjectRule |
|
DruidRules.DruidProjectSortTransposeRule |
|
DruidRules.DruidSortProjectTransposeRule |
|
DruidRules.DruidSortRule |
|
DruidSchema |
Schema mapped onto a Druid instance.
|
DruidSchemaFactory |
Schema factory that creates Druid schemas.
|
DruidSqlCastConverter |
Druid cast converter operator used to translates calcite casts to Druid expression cast
|
DruidSqlOperatorConverter |
Defines how to convert RexNode with a given calcite SQL operator to Druid expressions
|
DruidTable |
Table mapped onto a Druid table.
|
DruidTable.MapRelProtoDataType |
Creates a RelDataType from a map of
field names and types.
|
DruidTableFactory |
|
DruidType |
Druid type.
|
DuTableFunction |
Table function that executes the OS "du" ("disk usage") command
to compute file sizes.
|
DynamicExpression |
Represents a dynamic operation.
|
DynamicRecordType |
Specific type of RelRecordType that corresponds to a dynamic table,
where columns are created as they are requested.
|
DynamicRecordTypeImpl |
|
ElasticsearchAggregate |
Implementation of
Aggregate relational expression
for ElasticSearch.
|
ElasticsearchConstants |
Internal constants referenced in this package.
|
ElasticsearchEnumerators |
|
ElasticsearchFilter |
Implementation of a Filter
relational expression in Elasticsearch.
|
ElasticsearchFilter.PredicateAnalyzerTranslator |
New version of translator which uses visitor pattern
and allow to process more complex (boolean) predicates.
|
ElasticsearchFilter.Translator |
Translates RexNode expressions into Elasticsearch expression strings.
|
ElasticsearchJson |
Internal objects (and deserializers) used to parse Elasticsearch results
(which are in JSON format).
|
ElasticsearchJson.Aggregation |
Identifies all aggregations
|
ElasticsearchJson.Aggregations |
|
ElasticsearchJson.AggregationsDeserializer |
Allows to de-serialize nested aggregation structures.
|
ElasticsearchJson.Bucket |
A bucket represents a criteria to which all documents that fall in it adhere to.
|
ElasticsearchJson.GroupValue |
|
ElasticsearchJson.HasAggregations |
Allows traversing aggregations tree
|
ElasticsearchJson.MultiBucketsAggregation |
An aggregation that returns multiple buckets
|
ElasticsearchJson.MultiValue |
Multi value aggregatoin like
Stats
|
ElasticsearchJson.Result |
Response from Elastic
|
ElasticsearchJson.RowKey |
Identifies a calcite row (as in relational algebra)
|
ElasticsearchJson.SearchHit |
Concrete result record which matched the query.
|
ElasticsearchJson.SearchHits |
Similar to SearchHits in ES.
|
ElasticsearchMapping |
Stores Elasticsearch
mapping information for particular index/type.
|
ElasticsearchMapping.Datatype |
Represents elastic data-type, like long , keyword ,
date etc.
|
ElasticsearchMethod |
Builtin methods in the Elasticsearch adapter.
|
ElasticsearchProject |
Implementation of Project
relational expression in Elasticsearch.
|
ElasticsearchRel |
Relational expression that uses Elasticsearch calling convention.
|
ElasticsearchRel.Implementor |
Callback for the implementation process that converts a tree of
ElasticsearchRel nodes into an Elasticsearch query.
|
ElasticsearchRules |
Rules and relational operators for
ELASTICSEARCH
calling convention.
|
ElasticsearchRules.ElasticsearchAggregateRule |
|
ElasticsearchRules.ElasticsearchConverterRule |
Base class for planner rules that convert a relational expression to
Elasticsearch calling convention.
|
ElasticsearchRules.ElasticsearchFilterRule |
|
ElasticsearchRules.ElasticsearchProjectRule |
|
ElasticsearchRules.ElasticsearchSortRule |
|
ElasticsearchRules.RexToElasticsearchTranslator |
Translator from RexNode to strings in Elasticsearch's expression
language.
|
ElasticsearchSchema |
Schema mapped onto an index of ELASTICSEARCH types.
|
ElasticsearchSchemaFactory |
|
ElasticsearchSearchResult |
Internal object used to parse elastic search result.
|
ElasticsearchSearchResult.SearchHit |
Concrete result record which matched the query.
|
ElasticsearchSearchResult.SearchHits |
Similar to SearchHits in ES.
|
ElasticsearchSort |
Implementation of Sort
relational expression in Elasticsearch.
|
ElasticsearchTable |
Table based on an Elasticsearch type.
|
ElasticsearchTable.ElasticsearchQueryable<T> |
|
ElasticsearchTableScan |
Relational expression representing a scan of an Elasticsearch type.
|
ElasticsearchToEnumerableConverter |
Relational expression representing a scan of a table in an Elasticsearch data source.
|
ElasticsearchToEnumerableConverterRule |
|
ElasticsearchTransport |
Set of predefined functions for REST interaction with elastic search API.
|
ElasticsearchTransport.HttpFunction |
Basic rest operations interacting with elastic cluster.
|
ElasticsearchTransport.JsonParserFn<T> |
Parses HTTP response into some class using jackson API.
|
ElasticsearchVersion |
Identifies current ES version at runtime.
|
ElementInit |
Represents an initializer for a single element of an
Enumerable collection.
|
EmptyScope |
|
Enumerable<T> |
Exposes the enumerator, which supports a simple iteration over a collection.
|
EnumerableAggregate |
|
EnumerableAggregateRule |
|
EnumerableBindable |
Relational expression that converts an enumerable input to interpretable
calling convention.
|
EnumerableBindable.EnumerableToBindableConverterRule |
Rule that converts any enumerable relational expression to bindable.
|
EnumerableCalc |
|
EnumerableCalcRule |
|
EnumerableCollect |
|
EnumerableCollectRule |
|
EnumerableConvention |
Family of calling conventions that return results as an
Enumerable .
|
EnumerableCorrelate |
|
EnumerableCorrelateRule |
Implementation of nested loops over enumerable inputs.
|
EnumerableDefaults |
Default implementations of methods in the Enumerable interface.
|
EnumerableDefaults.CastingEnumerator<T> |
Enumerator that casts each value.
|
EnumerableDefaults.LookupResultEnumerable<TResult,TKey,TAccumulate> |
Reads a populated map, applying a selector function.
|
EnumerableDefaults.MergeJoinEnumerator<TResult,TSource,TInner,TKey extends java.lang.Comparable<TKey>> |
Enumerator that performs a merge join on its sorted inputs.
|
EnumerableDefaults.SkipWhileEnumerator<TSource> |
Enumerator that implements skip-while.
|
EnumerableDefaults.TakeWhileEnumerator<TSource> |
Enumerable that implements take-while.
|
EnumerableDefaults.TakeWhileLongEnumerator<TSource> |
Enumerable that implements take-while.
|
EnumerableDefaults.WrapMap<K,V> |
Map that wraps each value.
|
EnumerableDefaults.Wrapped<T> |
Value wrapped with a comparer.
|
EnumerableFilter |
|
EnumerableFilterRule |
|
EnumerableFilterToCalcRule |
|
EnumerableInterpretable |
Relational expression that converts an enumerable input to interpretable
calling convention.
|
EnumerableInterpretable.EnumerableNode |
|
EnumerableInterpreter |
Relational expression that executes its children using an interpreter.
|
EnumerableInterpreterRule |
|
EnumerableIntersect |
|
EnumerableIntersectRule |
|
EnumerableJoin |
|
EnumerableJoinRule |
|
EnumerableLimit |
Relational expression that applies a limit and/or offset to its input.
|
EnumerableLimitRule |
Rule to convert an Sort that has
offset or fetch set to an
EnumerableLimit
on top of a "pure" Sort that has no offset or fetch.
|
EnumerableMergeJoin |
|
EnumerableMergeJoinRule |
|
EnumerableMinus |
|
EnumerableMinusRule |
|
EnumerableOrderedQueryable<T> |
|
EnumerableProject |
|
EnumerableProjectRule |
|
EnumerableProjectToCalcRule |
|
EnumerableQueryable<T> |
|
EnumerableRel |
|
EnumerableRel.Prefer |
Preferred physical type.
|
EnumerableRel.Result |
Result of implementing an enumerable relational expression by generating
Java code.
|
EnumerableRelImplementor |
|
EnumerableRelImplementor.TypeFinder |
|
EnumerableRules |
|
Enumerables |
|
EnumerableSemiJoin |
|
EnumerableSemiJoinRule |
|
EnumerableSort |
|
EnumerableSortRule |
|
EnumerableTableFunctionScan |
|
EnumerableTableFunctionScanRule |
|
EnumerableTableModify |
|
EnumerableTableModifyRule |
|
EnumerableTableScan |
|
EnumerableTableScanRule |
|
EnumerableThetaJoin |
|
EnumerableToSparkConverter |
|
EnumerableToSparkConverterRule |
|
EnumerableUncollect |
|
EnumerableUncollectRule |
|
EnumerableUnion |
|
EnumerableUnionRule |
|
EnumerableValues |
|
EnumerableValuesRule |
|
EnumerableWindow |
|
EnumerableWindow.WindowRelInputGetter |
|
EnumerableWindowRule |
|
Enumerator<T> |
Supports a simple iteration over a collection.
|
EnumeratorCursor<T> |
Implementation of Cursor on top of an
Enumerator that
returns a record for each row.
|
EnumUtils |
Utilities for generating programs in the Enumerable (functional)
style.
|
EnvironmentFairy |
Fairy simulates environment around Calcite.
|
EnvironmentFairy.User |
Who is emulated to being logged in?
|
EqualityComparer<T> |
Compares values for equality.
|
EquiJoin |
Base class for any join whose condition is based on column equality.
|
EquiJoin |
Deprecated.
|
EquivalenceSet<E extends java.lang.Comparable<E>> |
Set of elements organized into equivalence classes.
|
Evaluator |
Holds context for evaluating expressions.
|
Exchange |
Relational expression that imposes a particular distribution on its input
without otherwise changing its content.
|
Experimental |
Annotation that indicates that a class, interface, field or method
is experimental, not part of the public API, and subject to change
or removal.
|
ExplicitOperandTypeInference |
ExplicitOperandTypeInferences implements SqlOperandTypeInference by
explicitly supplying a type for each parameter.
|
ExplicitOperatorBinding |
ExplicitOperatorBinding implements SqlOperatorBinding
via an underlying array of known operand types.
|
ExplicitReturnTypeInference |
|
Expression |
Analogous to LINQ's System.Linq.Expression.
|
ExpressionNotAnalyzableException |
Thrown when RelNode expression can't be processed
(or converted into ES query)
|
Expressions |
Utility methods for expressions, including a lot of factory methods.
|
Expressions.FluentArrayList<T> |
Fluent array list.
|
Expressions.FluentList<T> |
Fluent list.
|
Expressions.PropertyInfo |
Property info.
|
Expressions.RuntimeVariablesExpression |
Runtime variables expression.
|
Expressions.SymbolDocumentInfo |
Symbol document info.
|
ExpressionType |
Analogous to LINQ's System.Linq.Expressions.ExpressionType.
|
ExpressionVisitor |
Represents a visitor or rewriter for expression trees.
|
ExpressionWriter |
Converts an expression to Java code.
|
ExpressionWriter.Indent |
Helps generate strings of spaces, to indent text.
|
ExtendedEnumerable<TSource> |
|
ExtendedOrderedEnumerable<T> |
|
ExtendedOrderedQueryable<T> |
|
ExtendedQueryable<TSource> |
Extension methods in Queryable.
|
ExtensibleTable |
Table whose row type can be extended to include extra fields.
|
Extensions |
Contains what, in LINQ.NET, would be extension methods.
|
ExtractionDimensionSpec |
Implementation of extraction function DimensionSpec.
|
ExtractionFunction |
Interface for Druid extraction functions.
|
ExtractOperatorConversion |
Time extract operator conversion for expressions like EXTRACT(timeUnit FROM arg)
Unit can be SECOND, MINUTE, HOUR, DAY (day of month),
DOW (day of week), DOY (day of year), WEEK (week of week year),
MONTH (1 through 12), QUARTER (1 through 4), or YEAR
|
ExtraSqlTypes |
Holds constants associated with SQL types introduced after the earliest
version of Java supported by Farrago (this currently means anything
introduced in JDK 1.6 or later).
|
FamilyOperandTypeChecker |
Operand type-checking strategy which checks operands for inclusion in type
families.
|
Feature |
SQL language feature.
|
FieldDeclaration |
Declaration of a field.
|
FieldNamespace |
|
FileEnumerator |
|
FileFieldType |
Type of a field in a Web (HTML) table.
|
FileReader |
Scrapes HTML tables from URLs using Jsoup.
|
FileReader.FileReaderIterator |
Iterates over HTML tables, returning an Elements per row.
|
FileReaderException |
Indicates that the FileReader failed.
|
FileRowConverter |
FileRowConverter.
|
FileSchema |
Schema mapped onto a set of URLs / HTML tables.
|
FileSchemaFactory |
|
FilesTableFunction |
Table function that executes the OS "find" command to find files under a
particular path.
|
FileTable |
Table implementation wrapping a URL / HTML table.
|
FileTableScan |
Relational expression representing a scan of an HTML table.
|
Filter |
Relational expression that iterates over its input
and returns elements for which condition evaluates to
true .
|
FilterableTable |
Table that can be scanned, optionally applying supplied filter expressions,
without creating an intermediate relational expression.
|
FilterAggregateTransposeRule |
|
Filterator<E> |
Filtered iterator class: an iterator that includes only elements that are
instanceof a specified class.
|
FilterCalcMergeRule |
|
FilterCorrelateRule |
Planner rule that pushes a Filter above a Correlate into the
inputs of the Correlate.
|
FilterJoinRule |
Planner rule that pushes filters above and
within a join node into the join node and/or its children nodes.
|
FilterJoinRule.FilterIntoJoinRule |
Rule that tries to push filter expressions into a join
condition and into the inputs of the join.
|
FilterJoinRule.JoinConditionPushRule |
Rule that pushes parts of the join condition to its inputs.
|
FilterJoinRule.Predicate |
Predicate that returns whether a filter is valid in the ON clause of a
join for this particular kind of join.
|
FilterMergeRule |
|
FilterMultiJoinMergeRule |
|
FilterNode |
Interpreter node that implements a
Filter .
|
FilterProjectTransposeRule |
|
FilterRemoveIsNotDistinctFromRule |
Planner rule that replaces IS NOT DISTINCT FROM
in a Filter with logically equivalent operations.
|
FilterSetOpTransposeRule |
|
FilterTableFunctionTransposeRule |
|
FilterTableScanRule |
|
FilterToCalcRule |
|
FirebirdSqlDialect |
A SqlDialect implementation for the Firebird database.
|
FlatLists |
Space-efficient, comparable, immutable lists.
|
FlatLists.AbstractFlatList<T> |
Base class for flat lists.
|
FlatLists.ComparableEmptyList<T> |
Empty list that implements the Comparable interface.
|
FlatLists.ComparableList<T> |
List that is also comparable.
|
FlatLists.ComparableListImpl<T extends java.lang.Comparable<T>> |
Wrapper around a list that makes it implement the Comparable
interface using lexical ordering.
|
FlatLists.Flat1List<T> |
List that stores its one elements in the one members of the class.
|
FlatLists.Flat2List<T> |
List that stores its two elements in the two members of the class.
|
FlatLists.Flat3List<T> |
List that stores its three elements in the three members of the class.
|
FlatLists.Flat4List<T> |
List that stores its four elements in the four members of the class.
|
FlatLists.Flat5List<T> |
List that stores its five elements in the five members of the class.
|
FlatLists.Flat6List<T> |
List that stores its six elements in the six members of the class.
|
FlightRecorderProfiler |
Captures Flight Recorder log.
|
FloatFunction1<T0> |
Function that takes one parameter and returns a native float value.
|
FloorOperatorConversion |
DruidSqlOperatorConverter implementation that handles Floor operations conversions
|
ForStatement |
Represents an infinite loop.
|
FrameworkConfig |
Interface that describes how to configure planning sessions generated
using the Frameworks tools.
|
Frameworks |
Tools for invoking Calcite functionality without initializing a container /
server first.
|
Frameworks.ConfigBuilder |
A builder to help you build a FrameworkConfig using defaults
where values aren't required.
|
Frameworks.PlannerAction<R> |
Piece of code to be run in a context where a planner is available.
|
Frameworks.PrepareAction<R> |
Piece of code to be run in a context where a planner and statement are
available.
|
Frameworks.StdFrameworkConfig |
An implementation of FrameworkConfig that uses standard Calcite
classes to provide basic planner functionality.
|
Function<R> |
Base interface for all functions.
|
Function |
Named expression that accepts parameters and returns a result.
|
Function0<R> |
Function with no parameters.
|
Function1<T0,R> |
Function with one parameter.
|
Function2<T0,T1,R> |
Function with two parameters.
|
FunctionExpression<F extends Function<?>> |
Represents a strongly typed lambda expression as a data structure in the form
of an expression tree.
|
FunctionExpression.Invokable |
Function that can be invoked with a variable number of arguments.
|
FunctionParameter |
|
Functions |
Utilities relating to functions.
|
Functions.ArrayEqualityComparer |
Array equality comparer.
|
Functions.GeneratingList<E> |
List that generates each element using a function.
|
Functions.IdentityEqualityComparer |
Identity equality comparer.
|
Functions.Ignore<R,T0,T1> |
Ignore.
|
Functions.NullsFirstComparator |
Nulls first comparator.
|
Functions.NullsFirstReverseComparator |
Nulls first reverse comparator.
|
Functions.NullsLastComparator |
Nulls last comparator.
|
Functions.NullsLastReverseComparator |
Nulls last reverse comparator.
|
Functions.SelectorEqualityComparer<T,T2> |
Selector equality comparer.
|
GeodeAggregate |
Implementation of
Aggregate relational expression
in Geode.
|
GeodeEnumerator |
Enumerator that reads from a Geode Regions.
|
GeodeFilter |
Implementation of
Filter relational expression in Geode.
|
GeodeFilter.Translator |
Translates RexNode expressions into Geode expression strings.
|
GeodeProject |
Implementation of
Project
relational expression in Geode.
|
GeodeRel |
Relational expression that uses Geode calling convention.
|
GeodeRel.GeodeImplementContext |
Shared context used by the GeodeRel relations.
|
GeodeRules |
|
GeodeRules.GeodeAggregateRule |
|
GeodeRules.GeodeConverterRule |
Base class for planner rules that convert a relational
expression to Geode calling convention.
|
GeodeRules.GeodeFilterRule |
|
GeodeRules.GeodeProjectRule |
|
GeodeRules.GeodeSortLimitRule |
|
GeodeRules.RexToGeodeTranslator |
Translator from RexNode to strings in Geode's expression language.
|
GeodeSchema |
Schema mapped onto a Geode Region.
|
GeodeSchemaFactory |
|
GeodeSimpleEnumerator<E> |
Geode Simple Enumerator.
|
GeodeSimpleScannableTable |
Geode Simple Scannable Table Abstraction
|
GeodeSimpleSchema |
Geode Simple Schema.
|
GeodeSimpleSchemaFactory |
Geode Simple Table Schema Factory.
|
GeodeSort |
Implementation of
Sort
relational expression in Geode.
|
GeodeTable |
Table based on a Geode Region
|
GeodeTable.GeodeQueryable<T> |
|
GeodeTableScan |
Relational expression representing a scan of a Geode collection.
|
GeodeToEnumerableConverter |
Relational expression representing a scan of a table in a Geode data source.
|
GeodeToEnumerableConverterRule |
|
GeodeUtils |
Utilities for the Geode adapter.
|
GeoFunctions |
Helper methods to implement Geo-spatial functions in generated code.
|
GeoFunctions.CapStyle |
How the "buffer" command terminates the end of a line.
|
GeoFunctions.Geom |
Geometry.
|
GeoFunctions.JoinStyle |
How the "buffer" command decorates junctions between line segments.
|
GeoFunctions.MapGeom |
Sub-class of geometry that has a spatial reference.
|
GeoFunctions.SimpleGeom |
Sub-class of geometry that has no spatial reference.
|
GeoFunctions.Type |
Geometry types, with the names and codes assigned by OGC.
|
GitCommitsTableFunction |
Table function that executes the OS "git log" command
to discover git commits.
|
Glossary |
A collection of terms.
|
GotoExpressionKind |
|
GotoStatement |
Represents an unconditional jump.
|
Granularities |
|
Granularities.AllGranularity |
|
Granularities.PeriodGranularity |
|
Granularity |
A strategy by which Druid rolls up rows into sub-totals based on their
timestamp values.
|
Granularity.Type |
Type of supported periods for granularity.
|
Graphs |
Miscellaneous graph utilities.
|
Graphs.FrozenGraph<V,E extends DefaultEdge> |
Immutable grap.
|
GroupByScope |
Represents the name-resolution context for expressions in an GROUP BY clause.
|
Grouping<K,V> |
Represents a collection of objects that have a common key.
|
GroupingImpl<K,V> |
|
H2SqlDialect |
A SqlDialect implementation for the H2 database.
|
Handler |
Walks over a Piglet AST and calls the corresponding methods in a
PigRelBuilder .
|
HepInstruction |
HepInstruction represents one instruction in a HepProgram.
|
HepInstruction.BeginGroup |
Instruction that begins a group.
|
HepInstruction.CommonRelSubExprRules |
Instruction that finds common relational sub-expressions.
|
HepInstruction.ConverterRules |
Instruction that executes converter rules.
|
HepInstruction.EndGroup |
Instruction that ends a group.
|
HepInstruction.MatchLimit |
Instruction that sets match limit.
|
HepInstruction.MatchOrder |
Instruction that sets match order.
|
HepInstruction.RuleClass<R extends RelOptRule> |
Instruction that executes all rules of a given class.
|
HepInstruction.RuleCollection |
Instruction that executes all rules in a given collection.
|
HepInstruction.RuleInstance |
Instruction that executes a given rule.
|
HepInstruction.Subprogram |
Instruction that executes a sub-program.
|
HepMatchOrder |
HepMatchOrder specifies the order of graph traversal when looking for rule
matches.
|
HepPlanner |
HepPlanner is a heuristic implementation of the RelOptPlanner
interface.
|
HepProgram |
HepProgram specifies the order in which rules should be attempted by
HepPlanner .
|
HepProgramBuilder |
HepProgramBuilder creates instances of HepProgram .
|
HepRelMetadataProvider |
|
HepRelVertex |
HepRelVertex wraps a real RelNode as a vertex in a DAG representing
the entire query expression.
|
HepRuleCall |
|
HiveSqlDialect |
A SqlDialect implementation for the Apache Hive database.
|
Holder |
Implementation of MutableRel whose only purpose is to have a
child.
|
Holder<E> |
A mutable slot that can contain one object.
|
Hook |
Collection of hooks that can be set by observers and are executed at various
parts of the query preparation process.
|
Hook.Closeable |
Removes a Hook after use.
|
HsqldbSqlDialect |
A SqlDialect implementation for the Hsqldb database.
|
HttpServer |
An HTTP server for static content used to allow worker nodes to access JARs.
|
HttpUtils |
Utilities for connecting to REST services such as Splunk via HTTP.
|
IdentifierNamespace |
Namespace whose contents are defined by the type of an
identifier .
|
ImmutableBitSet |
An immutable list of bits.
|
ImmutableBitSet.Builder |
Builder.
|
ImmutableBitSet.Closure |
Setup equivalence Sets for each position.
|
ImmutableBitSet.Rebuilder |
|
ImmutableIntList |
An immutable list of Integer values backed by an array of
int s.
|
ImmutableIntList.AbstractIndexedListIterator<E> |
Extension to UnmodifiableListIterator
that operates by index.
|
ImmutableIntList.EmptyImmutableIntList |
Special sub-class of ImmutableIntList that is always
empty and has only one instance.
|
ImmutableNullableList<E> |
An immutable list that may contain null values.
|
ImmutableNullableList.Builder<E> |
A builder for creating immutable nullable list instances.
|
ImplementableAggFunction |
Function that can be translated to java code.
|
ImplementableFunction |
Function that can be translated to java code.
|
IndexExpression |
Represents indexing a property or array.
|
InferTypes |
Strategies for inferring operand types.
|
InfobrightSqlDialect |
A SqlDialect implementation for the Infobright database.
|
InformixSqlDialect |
A SqlDialect implementation for the Informix database.
|
IngresSqlDialect |
A SqlDialect implementation for the Ingres database.
|
InitializerContext |
|
InitializerExpressionFactory |
InitializerExpressionFactory supplies default values for INSERT, UPDATE, and NEW.
|
IntegerFunction1<T0> |
Function that takes one parameter and returns a native int value.
|
IntegerIntervalSet |
A set of non-negative integers defined by a sequence of points, intervals,
and exclusions.
|
IntegerIntervalSet.Handler |
A callback.
|
InterbaseSqlDialect |
A SqlDialect implementation for the Interbase database.
|
InterpretableConvention |
Calling convention that returns results as an
Enumerable of object arrays.
|
InterpretableConverter |
Relational expression that converts any relational expression input to
InterpretableConvention , by wrapping
it in an interpreter.
|
InterpretableRel |
Relational expression that can implement itself using an interpreter.
|
InterpretableRel.InterpreterImplementor |
Context when a RelNode is being converted to an interpreter
Node .
|
Interpreter |
Interpreter.
|
Interpreter.CompilerImpl |
Walks over a tree of RelNode and, for each,
creates a Node that can be
executed in the interpreter.
|
Interpreter.DuplicatingSink |
Implementation of Sink using a ArrayDeque .
|
Interpreter.Edge |
Edge between a RelNode and one of its inputs.
|
Interpreter.EnumeratorSource |
|
Interpreter.ListSink |
Implementation of Sink using a ArrayDeque .
|
Interpreter.ListSource |
Implementation of Source using a ArrayDeque .
|
Interpreter.NodeInfo |
Information about a node registered in the data flow graph.
|
Interpreter.ScalarCompiler |
Converts a list of expressions to a scalar that can compute their
values.
|
Interpreters |
|
Intersect |
Relational expression that returns the intersection of the rows of its
inputs.
|
IntersectToDistinctRule |
Planner rule that translates a distinct
Intersect
( all = false )
into a group of operators composed of
Union ,
Aggregate , etc.
|
IntervalSqlType |
IntervalSqlType represents a standard SQL datetime interval type.
|
IntList |
Deprecated. |
IntPair |
An immutable pair of integers.
|
InvalidRelException |
Exception that indicates that a relational expression would be invalid
with given parameters.
|
InvocationExpression |
Represents an expression that applies a delegate or lambda expression to a
list of argument expressions.
|
JaninoCompiler |
|
JaninoCompiler.AccountingClassLoader |
Refinement of JavaSourceClassLoader which keeps track of the total
bytecode length of the classes it has compiled.
|
JaninoCompiler.JaninoCompilerArgs |
Arguments to an invocation of the Janino compiler.
|
JaninoRelMetadataProvider |
Implementation of the RelMetadataProvider interface that generates
a class that dispatches to the underlying providers.
|
JaninoRelMetadataProvider.Key |
Key for the cache.
|
JaninoRelMetadataProvider.NoHandler |
Exception that indicates there there should be a handler for
this class but there is not.
|
JaninoRexCompiler |
Compiles a scalar expression ( RexNode ) to an expression that
can be evaluated ( Scalar ) by generating a Java AST and compiling it
to a class using Janino.
|
Java9Workaround |
JavaDoc from Java 9 seems to fail when package contents is empty.
|
JavaCompiler |
The interface JavaCompiler represents an interface to invoke a
regular Java compiler.
|
JavaCompilerArgs |
|
JavaRecordType |
Record type based on a Java class.
|
JavaRelImplementor |
Abstract base class for implementations of RelImplementor
that generate java code.
|
JavaRowFormat |
How a row is represented as a Java value.
|
JavaToSqlTypeConversionRules |
JavaToSqlTypeConversionRules defines mappings from common Java types to
corresponding SQL types.
|
JavaToSqlTypeConversionRules.ColumnList |
Make this public when needed.
|
JavaTypeFactory |
Type factory that can register Java classes as record types.
|
JavaTypeFactoryExtImpl |
|
JavaTypeFactoryImpl |
|
JavaTypeFactoryImpl.RecordFieldImpl |
Implementation of a field.
|
JavaTypeFactoryImpl.SyntheticRecordType |
Synthetic record type.
|
JdbcConvention |
Calling convention for relational operations that occur in a JDBC
database.
|
JdbcImplementor |
State for generating a SQL statement.
|
JdbcQueryProvider |
|
JdbcRel |
Relational expression that uses JDBC calling convention.
|
JdbcRules |
|
JdbcRules.CheckingUserDefinedFunctionVisitor |
Visitor for checking whether part of projection is a user defined function or not
|
JdbcRules.JdbcAggregate |
Aggregate operator implemented in JDBC convention.
|
JdbcRules.JdbcAggregateRule |
|
JdbcRules.JdbcCalc |
Calc operator implemented in JDBC convention.
|
JdbcRules.JdbcCalcRule |
|
JdbcRules.JdbcConverterRule |
Abstract base class for rule that converts to JDBC.
|
JdbcRules.JdbcFilter |
|
JdbcRules.JdbcFilterRule |
|
JdbcRules.JdbcIntersect |
Intersect operator implemented in JDBC convention.
|
JdbcRules.JdbcIntersectRule |
|
JdbcRules.JdbcJoin |
Join operator implemented in JDBC convention.
|
JdbcRules.JdbcJoinRule |
Rule that converts a join to JDBC.
|
JdbcRules.JdbcMinus |
Minus operator implemented in JDBC convention.
|
JdbcRules.JdbcMinusRule |
|
JdbcRules.JdbcProject |
|
JdbcRules.JdbcProjectRule |
|
JdbcRules.JdbcSort |
Sort operator implemented in JDBC convention.
|
JdbcRules.JdbcSortRule |
|
JdbcRules.JdbcTableModificationRule |
Rule that converts a table-modification to JDBC.
|
JdbcRules.JdbcTableModify |
Table-modification operator implemented in JDBC convention.
|
JdbcRules.JdbcUnion |
Union operator implemented in JDBC convention.
|
JdbcRules.JdbcUnionRule |
|
JdbcRules.JdbcValues |
Values operator implemented in JDBC convention.
|
JdbcRules.JdbcValuesRule |
Rule that converts a values operator to JDBC.
|
JdbcSchema |
Implementation of Schema that is backed by a JDBC data source.
|
JdbcSchema.Factory |
|
JdbcTable |
Queryable that gets its data from a table within a JDBC connection.
|
JdbcTableScan |
Relational expression representing a scan of a table in a JDBC data source.
|
JdbcToEnumerableConverter |
Relational expression representing a scan of a table in a JDBC data source.
|
JdbcToEnumerableConverterRule |
|
JdbcToSparkConverter |
Relational expression representing a scan of a table in a JDBC data source
that returns its results as a Spark RDD.
|
JdbcToSparkConverterRule |
|
JdbcUtils |
Utilities for the JDBC provider.
|
JdbcUtils.DataSourcePool |
Ensures that if two data sources have the same definition, they will use
the same object.
|
JdbcUtils.DialectPool |
Pool of dialects.
|
JdbcUtils.ObjectArrayRowBuilder |
Builder that calls ResultSet.getObject(int) for every column,
or getXxx if the result type is a primitive xxx ,
and returns an array of objects for each row.
|
JethroDataSqlDialect |
A SqlDialect implementation for the JethroData database.
|
JethroDataSqlDialect.JethroInfo |
Information about the capabilities of a Jethro database.
|
JethroDataSqlDialect.JethroInfoCache |
Stores information about capabilities of Jethro databases.
|
JethroDataSqlDialect.JethroInfoCacheImpl |
Implementation of JethroInfoCache .
|
JethroDataSqlDialect.JethroSupportedFunction |
Information about a function supported by Jethro.
|
Join |
Relational expression that combines two relational expressions according to
some condition.
|
JoinAddRedundantSemiJoinRule |
Rule to add a semi-join into a join.
|
JoinAssociateRule |
Planner rule that changes a join based on the associativity rule.
|
JoinCommuteRule |
Planner rule that permutes the inputs to a
Join .
|
JoinCommuteRule.VariableReplacer |
Walks over an expression, replacing references to fields of the left and
right inputs.
|
JoinConditionType |
Enumerates the types of condition in a join expression.
|
JoinExtractFilterRule |
|
JoinInfo |
An analyzed join condition.
|
JoinInfo.EquiJoinInfo |
JoinInfo that represents an equi-join.
|
JoinInfo.NonEquiJoinInfo |
JoinInfo that represents a non equi-join.
|
JoinNamespace |
Namespace representing the row type produced by joining two relations.
|
JoinNode |
Interpreter node that implements a
Join .
|
JoinProjectTransposeRule |
Planner rule that matches a
Join one of whose inputs is a
LogicalProject , and
pulls the project up.
|
JoinPushExpressionsRule |
Planner rule that pushes down expressions in "equal" join condition.
|
JoinPushThroughJoinRule |
Rule that pushes the right input of a join into through the left input of
the join, provided that the left input is also a join.
|
JoinPushTransitivePredicatesRule |
Planner rule that infers predicates from on a
Join and creates
Filter s if those predicates can be pushed
to its inputs.
|
JoinRelType |
Enumeration of join types.
|
JoinScope |
The name-resolution context for expression inside a JOIN clause.
|
JoinToCorrelateRule |
|
JoinToMultiJoinRule |
|
JoinType |
Enumerates the types of join.
|
JoinUnionTransposeRule |
Planner rule that pushes a
Join
past a non-distinct Union .
|
JsonBuilder |
Builder for JSON documents (represented as List , Map ,
String , Boolean , Long ).
|
JsonColumn |
JSON object representing a column.
|
JsonCustomSchema |
JSON schema element that represents a custom schema.
|
JsonCustomTable |
Custom table schema element.
|
JsonEnumerator |
Enumerator that reads from a JSON file.
|
JsonFunction |
Function schema element.
|
JsonJdbcSchema |
JSON object representing a schema that maps to a JDBC database.
|
JsonLattice |
Element that describes a star schema and provides a framework for defining,
recognizing, and recommending materialized views at various levels of
aggregation.
|
JsonMapSchema |
JSON object representing a schema whose tables are explicitly specified.
|
JsonMaterialization |
Element that describes how a table is a materialization of a query.
|
JsonMeasure |
An aggregate function applied to a column (or columns) of a lattice.
|
JsonRoot |
Root schema element.
|
JsonSchema |
Schema schema element.
|
JsonSchema.Type |
Built-in schema types.
|
JsonStream |
Information about whether a table allows streaming.
|
JsonTable |
Table based on a JSON file.
|
JsonTable |
Table schema element.
|
JsonTile |
|
JsonType |
Type schema element.
|
JsonTypeAttribute |
JSON object representing a type attribute.
|
JsonView |
View schema element.
|
LabelStatement |
Represents a label, which can be put in any Expression context.
|
LabelTarget |
|
LambdaExpression |
Describes a lambda expression.
|
Lattice |
Structure that allows materialized views based upon a star schema to be
recognized and recommended.
|
Lattice.BaseColumn |
Column in a lattice.
|
Lattice.Builder |
Lattice builder.
|
Lattice.Builder.Fixer |
Work space for fixing up a tree of mutable nodes.
|
Lattice.Column |
Column in a lattice.
|
Lattice.DerivedColumn |
Column in a lattice that is based upon a SQL expression.
|
Lattice.Edge |
Edge in the temporary graph.
|
Lattice.Measure |
|
Lattice.SqlWriter |
The information necessary to convert a column to SQL.
|
Lattice.Tile |
Materialized aggregate within a lattice.
|
Lattice.TileBuilder |
Tile builder.
|
Lattice.Vertex |
Vertex in the temporary graph.
|
LatticeChildNode |
|
LatticeNode |
Source relation of a lattice.
|
LatticeRootNode |
|
Lattices |
|
LatticeSpace |
Space within which lattices exist.
|
LatticeStatisticProvider |
Estimates row counts for a lattice and its attributes.
|
LatticeStatisticProvider.Factory |
|
LatticeSuggester |
Algorithm that suggests a set of lattices.
|
LatticeSuggester.BaseColRef |
Reference to a base column.
|
LatticeSuggester.ColRef |
Column reference.
|
LatticeSuggester.DerivedColRef |
Reference to a derived column (that is, an expression).
|
LatticeSuggester.Frame |
Information about the parent of fields from a relational expression.
|
LatticeSuggester.Hop |
A hop is a join condition.
|
LatticeSuggester.MutableMeasure |
An aggregate call.
|
LatticeSuggester.Query |
Holds state for a particular query graph.
|
LatticeSuggester.StepRef |
Use of a step within a query.
|
LatticeSuggester.StepRef.Factory |
|
LatticeSuggester.TableRef |
Use of a table within a query.
|
LatticeTable |
Table registered in the graph.
|
Lex |
Named, built-in lexical policy.
|
Like |
Utilities for converting SQL LIKE and SIMILAR operators
to regular expressions.
|
Linq4j |
Utility and factory methods for Linq4j.
|
Linq4j.CartesianProductListEnumerator<E> |
Enumerates over the cartesian product of the given lists, returning
a list for each row.
|
Linq4j.CollectionEnumerable<T> |
Collection enumerable.
|
Linq4j.CompositeEnumerable<E> |
Composite enumerable.
|
Linq4j.EnumeratorIterator<T> |
Iterator that reads from an underlying Enumerator .
|
Linq4j.IterableEnumerable<T> |
Iterable enumerable.
|
Linq4j.IterableEnumerator<T> |
Iterable enumerator.
|
Linq4j.ListEnumerable<T> |
List enumerable.
|
Linq4j.ListEnumerator<V> |
Enumerator optimized for random-access list.
|
Linq4j.SingletonEnumerator<E> |
Enumerator that returns one element.
|
Linq4j.SingletonNullEnumerator<E> |
Enumerator that returns one null element.
|
ListInitExpression |
Represents a constructor call that has a collection initializer.
|
ListScope |
Abstract base for a scope which is defined by a list of child namespaces and
which inherits from a parent scope.
|
ListSqlOperatorTable |
|
ListTable |
Implementation of table that reads rows from a read-only list and returns
an enumerator of rows.
|
LiteralOperandTypeChecker |
Parameter type-checking strategy type must be a literal (whether null is
allowed is determined by the constructor).
|
Litmus |
Callback to be called when a test for validity succeeds or fails.
|
LixToRelTranslator |
|
LogicalAggregate |
LogicalAggregate is a relational operator which eliminates
duplicates and computes totals.
|
LogicalCalc |
A relational expression which computes project expressions and also filters.
|
LogicalChi |
Sub-class of Chi
not targeted at any particular engine or calling convention.
|
LogicalCorrelate |
A relational operator that performs nested-loop joins.
|
LogicalDelta |
Sub-class of Delta
not targeted at any particular engine or calling convention.
|
LogicalExchange |
Sub-class of Exchange not
targeted at any particular engine or calling convention.
|
LogicalFilter |
Sub-class of Filter
not targeted at any particular engine or calling convention.
|
LogicalIntersect |
Sub-class of Intersect
not targeted at any particular engine or calling convention.
|
LogicalJoin |
Sub-class of Join
not targeted at any particular engine or calling convention.
|
LogicalMatch |
Sub-class of Match
not targeted at any particular engine or calling convention.
|
LogicalMinus |
Sub-class of Minus
not targeted at any particular engine or calling convention.
|
LogicalProject |
Sub-class of Project not
targeted at any particular engine or calling convention.
|
LogicalSort |
Sub-class of Sort not
targeted at any particular engine or calling convention.
|
LogicalSortExchange |
Sub-class of SortExchange not
targeted at any particular engine or calling convention.
|
LogicalTableFunctionScan |
Sub-class of TableFunctionScan
not targeted at any particular engine or calling convention.
|
LogicalTableModify |
Sub-class of TableModify
not targeted at any particular engine or calling convention.
|
LogicalTableScan |
A LogicalTableScan reads all the rows from a
RelOptTable .
|
LogicalUnion |
Sub-class of Union
not targeted at any particular engine or calling convention.
|
LogicalValues |
Sub-class of Values
not targeted at any particular engine or calling convention.
|
LogicalWindow |
Sub-class of Window
not targeted at any particular engine or calling convention.
|
LogicalWindow.WindowKey |
Group specification.
|
LogicVisitor |
Visitor pattern for traversing a tree of RexNode objects.
|
LongFunction1<T0> |
Function that takes one parameter and returns a native long value.
|
LongSchemaVersion |
Implementation of SchemaVersion that uses a long value as representation.
|
Lookup<K,V> |
Represents a collection of keys each mapped to one or more values.
|
LookupImpl<K,V> |
Implementation of Lookup that uses an underlying map.
|
LoptJoinTree |
Utility class used to store a Join tree
and the factors that make up the tree.
|
LoptJoinTree.BinaryTree |
Simple binary tree class that stores an id in the leaf nodes and keeps
track of the parent LoptJoinTree object associated with the binary tree.
|
LoptJoinTree.Leaf |
Binary tree node that has no children.
|
LoptJoinTree.Node |
Binary tree node that has two children.
|
LoptMultiJoin |
Utility class that keeps track of the join factors that
make up a MultiJoin .
|
LoptMultiJoin.Edge |
Information about a join-condition.
|
LoptOptimizeJoinRule |
Planner rule that implements the heuristic planner for determining optimal
join orderings.
|
LoptSemiJoinOptimizer |
Implements the logic for determining the optimal
semi-joins to be used in processing joins in a query.
|
LoptSemiJoinOptimizer.FemLocalIndex |
Dummy class to allow code to compile.
|
LoptSemiJoinOptimizer.LcsIndexOptimizer |
Dummy class to allow code to compile.
|
LoptSemiJoinOptimizer.LcsTable |
Dummy class to allow code to compile.
|
LoptSemiJoinOptimizer.LcsTableScan |
Dummy class to allow code to compile.
|
LoptSemiJoinOptimizer.LucidDbSpecialOperators |
Dummy class to allow code to compile.
|
LucidDbSqlDialect |
A SqlDialect implementation for the LucidDB database.
|
Map |
Annotation that indicates that a field is a map type.
|
Mapping |
A Mapping is a relationship between a source domain to target
domain of integers.
|
Mappings |
Utility functions related to mappings.
|
Mappings.AbstractMapping |
Abstract implementation of Mapping .
|
Mappings.CoreMapping |
Core interface of all mappings.
|
Mappings.FiniteAbstractMapping |
Abstract implementation of mapping where both source and target
domains are finite.
|
Mappings.FunctionMapping |
Mapping where every source has a target.
|
Mappings.FunctionMappingIter |
|
Mappings.IdentityMapping |
The identity mapping, of a given size, or infinite.
|
Mappings.InverseMapping |
Decorator which converts any Mapping into the inverse of itself.
|
Mappings.NoElementException |
Thrown when a mapping is expected to return one element but returns none.
|
Mappings.OverridingSourceMapping |
Source mapping that returns the same result as a parent
Mappings.SourceMapping except for specific overriding elements.
|
Mappings.OverridingTargetMapping |
Target mapping that returns the same result as a parent
Mappings.TargetMapping except for specific overriding elements.
|
Mappings.PartialFunctionImpl |
Implementation of Mapping where a source can have at most one
target, and a target can have any number of sources.
|
Mappings.PartialMapping |
A mapping where a source has at most one target, and every target has at
most one source.
|
Mappings.SourceMapping |
Mapping suitable for sourcing columns.
|
Mappings.SurjectionWithInverse |
A surjection with inverse has precisely one source for each target.
|
Mappings.TargetMapping |
Mapping suitable for mapping columns to a target.
|
Mappings.TooManyElementsException |
Thrown when a mapping is expected to return one element but returns
several.
|
MappingType |
Describes the type of a mapping, from the most general
MappingType.MULTI_FUNCTION (every element in the source and target domain can
participate in many mappings) to the most retricted MappingType.BIJECTION (every
element in the source and target domain must be paired with precisely one
element in the other domain).
|
MapProjectionFieldVisitor |
Visitor that extracts the actual field name from an item expression.
|
MapSqlStatisticProvider |
|
MapSqlType |
SQL map type.
|
Match |
Relational expression that represent a MATCH_RECOGNIZE node.
|
Match.AggregateFinder |
Find aggregate functions in operands.
|
Match.PatternVarFinder |
Visits the operands of an aggregate call to retrieve relevant pattern
variables.
|
Match.RexMRAggCall |
Aggregate calls in match recognize.
|
MatchRecognizeNamespace |
Namespace for a MATCH_RECOGNIZE clause.
|
MatchRecognizeScope |
Scope for expressions in a MATCH_RECOGNIZE clause.
|
MatchReturnTypeInference |
Returns the first type that matches a set of given SqlTypeName s.
|
MaterializationActor |
Actor that manages the state of materializations in the system.
|
MaterializationActor.Materialization |
A query materialized in a table, so that reading from the table gives the
same results as executing the query.
|
MaterializationActor.QueryKey |
A materialization can be re-used if it is the same SQL, on the same
schema, with the same path for resolving functions.
|
MaterializationKey |
Unique identifier for a materialization.
|
MaterializationService |
Manages the collection of materialized tables known to the system,
and the process by which they become valid and invalid.
|
MaterializationService.DefaultTableFactory |
|
MaterializationService.TableFactory |
Creates tables that represent a materialized view.
|
MaterializedViewFilterScanRule |
|
MaterializedViewSubstitutionVisitor |
|
MaterializedViewSubstitutionVisitor.FilterToFilterUnifyRule1 |
|
MaterializedViewSubstitutionVisitor.FilterToProjectUnifyRule1 |
|
MaterializedViewSubstitutionVisitor.ProjectToProjectUnifyRule1 |
|
MaterializedViewTable |
Table that is a materialized view.
|
MaterializedViewTable.MaterializedViewTableMacro |
Table function that returns the table that materializes a view.
|
Maze |
Maze generator.
|
Maze.CellContent |
Callback to get what to print in a particular cell.
|
Maze.Direction |
Direction.
|
MazeTable |
User-defined table function that generates a Maze and prints it in text
form.
|
Member |
A named expression in a schema.
|
MemberAssignment |
Represents assignment operation for a field or property of an object.
|
MemberBinding |
Provides the base class from which the classes that represent bindings that
are used to initialize members of a newly created object derive.
|
MemberDeclaration |
Declaration of a member of a class.
|
MemberExpression |
Represents accessing a field or property.
|
MemberInitExpression |
Represents calling a constructor and initializing one or more members of the
new object.
|
MemberListBinding |
Represents initializing the elements of a collection member of a newly
created object.
|
MemberMemberBinding |
Represents initializing members of a member of a newly created object.
|
Metadata |
Metadata about a relational expression.
|
MetadataDef<M extends Metadata> |
Definition of metadata.
|
MetadataFactory |
Source of metadata about relational expressions.
|
MetadataFactoryImpl |
|
MetadataHandler<M extends Metadata> |
Marker interface for a handler of metadata.
|
MetadataSchema |
Schema that contains metadata tables such as "TABLES" and "COLUMNS".
|
MethodCallExpression |
Represents a call to either a static or an instance method.
|
MethodDeclaration |
Declaration of a method.
|
Minus |
Relational expression that returns the rows of its first input minus any
matching rows from its other inputs.
|
ModelHandler |
Reads a model and creates schema objects accordingly.
|
ModelHandler.ExtraOperand |
|
ModifiableTable |
A table that can be modified.
|
ModifiableView |
|
ModifiableViewTable |
|
MongoAggregate |
Implementation of
Aggregate relational expression
in MongoDB.
|
MongoEnumerator |
Enumerator that reads from a MongoDB collection.
|
MongoFilter |
Implementation of a Filter
relational expression in MongoDB.
|
MongoFilter.Translator |
Translates RexNode expressions into MongoDB expression strings.
|
MongoMethod |
Builtin methods in the MongoDB adapter.
|
MongoProject |
Implementation of Project
relational expression in MongoDB.
|
MongoRel |
Relational expression that uses Mongo calling convention.
|
MongoRel.Implementor |
Callback for the implementation process that converts a tree of
MongoRel nodes into a MongoDB query.
|
MongoRules |
Rules and relational operators for
MONGO
calling convention.
|
MongoRules.MongoAggregateRule |
|
MongoRules.MongoConverterRule |
Base class for planner rules that convert a relational expression to
MongoDB calling convention.
|
MongoRules.MongoFilterRule |
|
MongoRules.MongoProjectRule |
|
MongoRules.MongoSortRule |
|
MongoRules.RexToMongoTranslator |
Translator from RexNode to strings in MongoDB's expression
language.
|
MongoSchema |
Schema mapped onto a directory of MONGO files.
|
MongoSchemaFactory |
|
MongoSort |
Implementation of Sort
relational expression in MongoDB.
|
MongoTable |
Table based on a MongoDB collection.
|
MongoTable.MongoQueryable<T> |
|
MongoTableScan |
Relational expression representing a scan of a MongoDB collection.
|
MongoToEnumerableConverter |
Relational expression representing a scan of a table in a Mongo data source.
|
MongoToEnumerableConverterRule |
|
MssqlSqlDialect |
A SqlDialect implementation for the Microsoft SQL Server
database.
|
MulticastRelOptListener |
MulticastRelOptListener implements the RelOptListener interface by
forwarding events on to a collection of other listeners.
|
MultiJoin |
A MultiJoin represents a join of N inputs, whereas regular Joins
represent strictly binary joins.
|
MultiJoinOptimizeBushyRule |
Planner rule that finds an approximately optimal ordering for join operators
using a heuristic algorithm.
|
MultiJoinOptimizeBushyRule.JoinVertex |
Participant in a join which is itself a join.
|
MultiJoinOptimizeBushyRule.LeafVertex |
Relation participating in a join.
|
MultiJoinOptimizeBushyRule.Vertex |
Participant in a join (relation or join).
|
MultiJoinProjectTransposeRule |
|
MultisetOperandTypeChecker |
Parameter type-checking strategy types must be [nullable] Multiset,
[nullable] Multiset and the two types must have the same element type
|
MultisetSqlType |
MultisetSqlType represents a standard SQL2003 multiset type.
|
MutableAggregate |
|
MutableBiRel |
Mutable equivalent of BiRel .
|
MutableCalc |
Mutable equivalent of Calc .
|
MutableCollect |
|
MutableCorrelate |
|
MutableExchange |
|
MutableFilter |
|
MutableIntersect |
|
MutableJoin |
Mutable equivalent of Join .
|
MutableLeafRel |
Abstract base class for implementations of MutableRel that have
no inputs.
|
MutableMinus |
Mutable equivalent of Minus .
|
MutableMultiRel |
Base Class for relations with three or more inputs
|
MutableNode |
Mutable version of LatticeNode , used while a graph is being
built.
|
MutableProject |
|
MutableRel |
|
MutableRels |
|
MutableRelType |
Type of MutableRel .
|
MutableRelVisitor |
|
MutableSample |
|
MutableScan |
|
MutableSemiJoin |
|
MutableSetOp |
Mutable equivalent of SetOp .
|
MutableSingleRel |
|
MutableSort |
Mutable equivalent of Sort .
|
MutableTableFunctionScan |
|
MutableTableModify |
|
MutableUncollect |
|
MutableUnion |
Mutable equivalent of Union .
|
MutableValues |
|
MutableWindow |
|
MysqlSqlDialect |
A SqlDialect implementation for the MySQL database.
|
NameMap<V> |
Map whose keys are names and can be accessed with and without case
sensitivity.
|
NameMultimap<V> |
Multimap whose keys are names and can be accessed with and without case
sensitivity.
|
NameSet |
Set of names that can be accessed with and without case sensitivity.
|
NaryOperatorConverter |
Converts Calcite n-ary operators to druid expression eg (arg1 Op arg2 Op arg3)
|
NeoviewSqlDialect |
A SqlDialect implementation for the Neoview database.
|
NestedBlockBuilder |
Allows to build nested code blocks with tracking of current context and the
nullability of particular RexNode expressions.
|
NestedBlockBuilderImpl |
Allows to build nested code blocks with tracking of current context and the
nullability of particular RexNode expressions.
|
NetezzaSqlDialect |
A SqlDialect implementation for the Netezza database.
|
NewArrayExpression |
Represents creating a new array and possibly initializing the elements of the
new array.
|
NewExpression |
Represents a constructor call.
|
NlsString |
|
Node |
Relational expression that can be executed using an interpreter.
|
Node |
Parse tree node.
|
Nodes |
Helper methods for Node and implementations for core relational
expressions.
|
Nodes.CoreCompiler |
|
NonDeterministic |
Specifies that function is NOT deterministic (i.e.
|
NoneConverter |
|
NoneToBindableConverterRule |
|
NotNullImplementor |
Simplified version of
CallImplementor
that does not know about null semantics.
|
NullableBigDecimalFunction1<T0> |
Function that takes one parameter and returns a BigDecimal value that
may be null.
|
NullableDoubleFunction1<T0> |
Function that takes one parameter and returns a Double value that
may be null.
|
NullableFloatFunction1<T0> |
Function that takes one parameter and returns a Float value that
may be null.
|
NullableIntegerFunction1<T0> |
Function that takes one parameter and returns an Integer value that
may be null.
|
NullableLongFunction1<T0> |
Function that takes one parameter and returns a Long value that
may be null.
|
NullCollation |
Strategy for how NULL values are to be sorted if NULLS FIRST or NULLS LAST
are not specified in an item in the ORDER BY clause.
|
NullInitializerExpressionFactory |
|
NullPolicy |
Describes when a function/operator will return null.
|
NullSentinel |
Placeholder for null values.
|
NumberUtil |
Utility functions for working with numbers.
|
ObjectEnumeratorCursor |
Implementation of Cursor on top of an
Enumerator that
returns an Object for each row.
|
ObjectSqlType |
ObjectSqlType represents an SQL structured user-defined type.
|
OperandsTypeChecking |
Strategies to check for allowed operand types of an operator call.
|
OperandTypes |
Strategies for checking operand types.
|
OperandTypes.PeriodOperandTypeChecker |
Operand type checker that accepts period types:
PERIOD (DATETIME, DATETIME)
PERIOD (DATETIME, INTERVAL)
[ROW] (DATETIME, DATETIME)
[ROW] (DATETIME, INTERVAL)
|
OptimizeShuttle |
Shuttle that optimizes expressions.
|
Optionality |
Four states that describe whether a particular behavior or
property is allowed and/or not allowed.
|
OpType |
Operator type.
|
OracleSqlDialect |
A SqlDialect implementation for the Oracle database.
|
OracleSqlOperatorTable |
Operator table that contains only Oracle-specific functions and operators.
|
Ord<E> |
Pair of an element and an ordinal.
|
Ord.OrdArrayList<E> |
List of Ord backed by an array of elements.
|
Ord.OrdList<E> |
List of Ord backed by a list of elements.
|
Ord.OrdRandomAccessList<E> |
List of Ord backed by a random-access list of elements.
|
OrderByScope |
Represents the name-resolution context for expressions in an ORDER BY clause.
|
OrderedAggregateLambdaFactory<TSource,TKey,TSortKey,TOrigAccumulate,TResult> |
Generate aggregate lambdas that sorts the input source before calling each
aggregate adder.
|
OrderedAggregateLambdaFactory.LazySource<TSource> |
Cache the input sources.
|
OrderedEnumerable<T> |
Represents the result of applying a sorting operation to an
Enumerable .
|
OrderedQueryable<T> |
Represents the result of applying a sorting operation to a Queryable .
|
OrdinalReturnTypeInference |
Returns the type of the operand at a particular 0-based ordinal position.
|
OverScope |
The name-resolution scope of a OVER clause.
|
PackageMarker |
This is a dummy annotation that forces javac to produce output for
otherwise empty package-info.java.
|
Pair<T1,T2> |
Pair of objects.
|
Pair.AdjacentIterator<E> |
Iterator that returns consecutive pairs of elements from an underlying
iterator.
|
Pair.FirstAndIterator<E> |
Iterator that returns the first element of a collection paired with every
other element.
|
Pair.LeftIterator<L,R> |
Iterator that returns the left field of each pair.
|
Pair.RightIterator<L,R> |
Iterator that returns the right field of each pair.
|
Pair.ZipIterator<L,R> |
Iterator that pairs elements from two iterators.
|
ParaccelSqlDialect |
A SqlDialect implementation for the Paraccel database.
|
Parameter |
Annotation that supplies metadata about a function parameter.
|
ParameterExpression |
Represents a named parameter expression.
|
ParameterNamespace |
Namespace representing the type of a dynamic parameter.
|
ParameterScope |
A scope which contains nothing besides a few parameters.
|
ParserBenchmark |
Benchmarks JavaCC-generated SQL parser
|
PartiallyOrderedSet<E> |
Partially-ordered set.
|
PartiallyOrderedSet.Node<E> |
Holds a value, its parent nodes, and child nodes.
|
PartiallyOrderedSet.Ordering<E> |
Ordering relation.
|
PartiallyOrderedSet.TopBottomNode<E> |
Subclass of Node for top/bottom nodes.
|
Path |
A sequence of Step s from a root node (fact table) to another node
(dimension table), possibly via intermediate dimension tables.
|
Path |
Path from a root schema to a particular object (schema, table, function).
|
Permutation |
Represents a mapping which reorders elements in an array.
|
PhoenixSqlDialect |
A SqlDialect implementation for the Apache Phoenix database.
|
PhysType |
Physical type of a row.
|
PhysTypeImpl |
|
PigAggFunction |
Supported Pig aggregate functions and their Calcite counterparts.
|
PigAggregate |
|
PigDataType |
Supported Pig data types and their Calcite counterparts.
|
PigFilter |
|
PigJoin |
|
PigProject |
|
PigRel |
Relational expression that uses the Pig calling convention.
|
PigRel.Implementor |
Callback for the implementation process that converts a tree of
PigRel nodes into complete Pig Latin script.
|
PigRelBuilder |
Extension to RelBuilder for Pig relational operators.
|
PigRelBuilder.GroupOption |
Option for performing group efficiently if data set is already sorted
|
PigRelBuilder.Partitioner |
Partitioner for group and join
|
PigRelFactories |
Implementations of factories in RelFactories
for the Pig adapter.
|
PigRelFactories.PigAggregateFactory |
|
PigRelFactories.PigFilterFactory |
|
PigRelFactories.PigJoinFactory |
|
PigRelFactories.PigTableScanFactory |
|
PigRules |
|
PigRules.PigAggregateRule |
|
PigRules.PigFilterRule |
|
PigRules.PigJoinRule |
|
PigRules.PigProjectRule |
|
PigRules.PigTableScanRule |
|
PigSchema |
Schema that contains one more or more Pig tables.
|
PigSchemaFactory |
|
PigTable |
Represents a Pig relation that is created by Pig Latin
LOAD statement.
|
PigTableFactory |
|
PigTableScan |
|
PigToEnumerableConverter |
Relational expression representing a scan of a table in a Pig data source.
|
PigToEnumerableConverterRule |
|
Planner |
A façade that covers Calcite's query planning process: parse SQL,
validate the parse tree, convert the parse tree to a relational expression,
and optimize the relational expression.
|
PlannerImpl |
|
PlannerImpl.State |
Stage of a statement in the query-preparation lifecycle.
|
PostgresqlSqlDialect |
A SqlDialect implementation for the PostgreSQL database.
|
PrecedenceClimbingParser |
Parser that takes a collection of tokens (atoms and operators)
and groups them together according to the operators' precedence
and associativity.
|
PrecedenceClimbingParser.Builder |
Fluent helper to build a parser containing a list of tokens.
|
PrecedenceClimbingParser.Call |
A token that is a call to an operator with arguments.
|
PrecedenceClimbingParser.Op |
An operator token.
|
PrecedenceClimbingParser.Result |
|
PrecedenceClimbingParser.Special |
Callback defining the behavior of a special function.
|
PrecedenceClimbingParser.SpecialOp |
An token corresponding to a special operator.
|
PrecedenceClimbingParser.Token |
A token: either an atom, a call to an operator with arguments,
or an unmatched operator.
|
PrecedenceClimbingParser.Type |
Token type.
|
PreconditionTest |
Checks if silent precondition has noticeable overhead
|
Predicate1<T0> |
Function with one parameter returning a native boolean value.
|
Predicate2<T0,T1> |
Function with two parameters returning a native boolean value.
|
PredicateAnalyzer |
Query predicate analyzer.
|
PredicateAnalyzer.CastExpression |
SQL cast: cast(col as INTEGER)
|
PredicateAnalyzer.CompoundQueryExpression |
Builds conjunctions / disjunctions based on existing expressions
|
PredicateAnalyzer.Expression |
Empty interface; exists only to define type hierarchy
|
PredicateAnalyzer.ExpressionNotAnalyzableException |
Thrown when RelNode expression can't be processed
(or converted into ES query)
|
PredicateAnalyzer.LiteralExpression |
Literal like 'foo' or 42 or true etc.
|
PredicateAnalyzer.NamedFieldExpression |
Used for bind variables
|
PredicateAnalyzer.NotLikeConverter |
Converts expressions of the form NOT(LIKE(...)) into NOT_LIKE(...)
|
PredicateAnalyzer.PredicateAnalyzerException |
Internal exception
|
PredicateAnalyzer.QueryExpression |
Main expression operators (like equals , gt , exists etc.)
|
PredicateAnalyzer.SimpleQueryExpression |
Usually basic expression of type a = 'val' or b > 42 .
|
PredicateAnalyzer.TerminalExpression |
Empty interface; exists only to define type hierarchy
|
PredicateAnalyzer.Visitor |
Traverses RexNode tree and builds ES query.
|
PredicateAnalyzer.Visitor.SwapResult |
Holder class for a pair of expressions.
|
PredicateImpl<T> |
Deprecated.
|
PreferredAlbumsTableFactory |
Factory for the table of albums preferred by the current user.
|
PreferredGenresTableFactory |
Factory for the table of genres preferred by the current user.
|
Prepare |
Abstract base for classes that implement
the process of preparing and executing SQL expressions.
|
Prepare.AbstractPreparingTable |
|
Prepare.CatalogReader |
Interface by which validator and planner can read table metadata.
|
Prepare.Materialization |
Describes that a given SQL query is materialized by a given table.
|
Prepare.PreparedExplain |
PreparedExplanation is a PreparedResult for an EXPLAIN PLAN statement.
|
Prepare.PreparedResult |
|
Prepare.PreparedResultImpl |
|
Prepare.PreparingTable |
Definition of a table, for the purposes of the validator and planner.
|
Primitive |
Enumeration of Java's primitive types.
|
Primitive.Flavor |
What kind of type?
|
Primitive.Sink |
A place to send a value.
|
Primitive.Source |
A place from which to read a value.
|
ProcedureNamespace |
Namespace whose contents are defined by the result of a call to a
user-defined procedure.
|
Processes |
Utilities regarding operating system processes.
|
Processes.ProcessFactory |
Creates processes.
|
Processes.ProcessLinesEnumerator |
Enumerator that executes a process and returns each line as an element.
|
Processes.SeparatedLinesEnumerable |
Enumerator that executes a process and returns each line as an element.
|
Profiler |
Analyzes data sets.
|
Profiler.Column |
Column.
|
Profiler.Distribution |
Value distribution, including cardinality and optionally values, of a
column or set of columns.
|
Profiler.FunctionalDependency |
Functional dependency.
|
Profiler.Profile |
The result of profiling, contains various statistics about the
data in a table.
|
Profiler.RowCount |
Whole data set.
|
Profiler.Statistic |
Statistic produced by the profiler.
|
Profiler.Unique |
Unique key.
|
ProfilerImpl |
Implementation of Profiler that only investigates "interesting"
combinations of columns.
|
ProfilerImpl.Builder |
|
ProfilerImpl.Collector |
Collects values of a column or columns.
|
ProfilerImpl.CompositeCollector |
Collector that collects two or more column values in a tree set.
|
ProfilerImpl.HllCollector |
Collector that collects two or more column values into a HyperLogLog
sketch.
|
ProfilerImpl.HllCompositeCollector |
Collector that collects two or more column values into a HyperLogLog
sketch.
|
ProfilerImpl.HllSingletonCollector |
Collector that collects one column value into a HyperLogLog sketch.
|
ProfilerImpl.SingletonCollector |
Collector that collects values of a single column.
|
ProfilerImpl.Space |
Work space for a particular combination of columns.
|
ProfilerImpl.SurpriseQueue |
A priority queue of the last N surprise values.
|
ProfilerLatticeStatisticProvider |
|
Program |
Program that transforms a relational expression into another relational
expression.
|
Programs |
|
Programs.DecorrelateProgram |
Program that de-correlates a query.
|
Programs.RuleSetProgram |
|
Programs.SequenceProgram |
Program that runs sub-programs, sending the output of the previous as
input to the next.
|
Programs.TrimFieldsProgram |
Program that trims fields.
|
Project |
Relational expression that computes a set of
'select expressions' from its input relational expression.
|
Project.Flags |
Deprecated. |
ProjectableFilterableTable |
Table that can be scanned, optionally applying supplied filter expressions,
and projecting a given list of columns,
without creating an intermediate relational expression.
|
ProjectCalcMergeRule |
|
ProjectCorrelateTransposeRule |
Push Project under Correlate to apply on Correlate's left and right child
|
ProjectCorrelateTransposeRule.RelNodesExprsHandler |
Visitor for RelNodes which applies specified RexShuttle visitor
for every node in the tree.
|
ProjectCorrelateTransposeRule.RexFieldAccessReplacer |
|
ProjectFilterTransposeRule |
|
ProjectJoinTransposeRule |
Planner rule that pushes a Project
past a Join
by splitting the projection into a projection on top of each child of
the join.
|
ProjectMergeRule |
ProjectMergeRule merges a Project into
another Project ,
provided the projects aren't projecting identical sets of input references.
|
ProjectMultiJoinMergeRule |
|
ProjectNode |
Interpreter node that implements a
Project .
|
ProjectRemoveRule |
Planner rule that,
given a Project node that
merely returns its input, converts the node into its child.
|
ProjectSetOpTransposeRule |
|
ProjectSortTransposeRule |
|
ProjectTableScanRule |
|
ProjectToCalcRule |
|
ProjectToWindowRule |
Planner rule that slices a
Project
into sections which contain windowed
aggregate functions and sections which do not.
|
ProjectToWindowRule.CalcToWindowRule |
Instance of the rule that applies to a
Calc that contains
windowed aggregates and converts it into a mixture of
LogicalWindow and Calc .
|
ProjectToWindowRule.ProjectToLogicalProjectAndWindowRule |
Instance of the rule that can be applied to a
Project and that produces, in turn,
a mixture of LogicalProject
and LogicalWindow .
|
ProjectToWindowRule.WindowedAggRelSplitter |
Splitter that distinguishes between windowed aggregation expressions
(calls to RexOver ) and ordinary expressions.
|
ProjectWindowTransposeRule |
|
PruneEmptyRules |
Collection of rules which remove sections of a query plan known never to
produce any rows.
|
PruneEmptyRules.RemoveEmptySingleRule |
Planner rule that converts a single-rel (e.g.
|
PseudoField |
Contains the parts of the Field class needed
for code generation, but might be implemented differently.
|
PsTableFunction |
Table function that executes the OS "ps" command
to list processes.
|
PushProjector |
PushProjector is a utility class used to perform operations used in push
projection rules.
|
PushProjector.ExprCondition |
A functor that replies true or false for a given expression.
|
Queryable<T> |
Provides functionality to evaluate queries against a specific data source
wherein the type of the data is known.
|
QueryableDefaults |
Default implementations for methods in the Queryable interface.
|
QueryableDefaults.NonLeafReplayableQueryable<T> |
Non-leaf replayable queryable.
|
QueryableDefaults.Replayable<T> |
Replayable.
|
QueryableDefaults.ReplayableQueryable<T> |
Replayable queryable.
|
QueryableFactory<T> |
|
QueryableRecorder<T> |
|
QueryableRelBuilder<T> |
|
QueryableTable |
|
QueryBuilders |
Utility class to generate elastic search queries.
|
QueryBuilders.BoolQueryBuilder |
Query for boolean logic
|
QueryBuilders.ConstantScoreQueryBuilder |
A query that wraps a filter and simply returns a constant score equal to the
query boost for every document in the filter.
|
QueryBuilders.ExistsQueryBuilder |
Constructs a query that only match on documents that the field has a value in them.
|
QueryBuilders.MatchAllQueryBuilder |
A query that matches on all documents.
|
QueryBuilders.QueryBuilder |
Base class to build ES queries
|
QueryBuilders.RangeQueryBuilder |
A Query that matches documents within an range of terms.
|
QueryBuilders.RegexpQueryBuilder |
A Query that does fuzzy matching for a specific value.
|
QueryBuilders.TermQueryBuilder |
A Query that matches documents containing a term.
|
QueryBuilders.TermsQueryBuilder |
A filter for a field based on several terms matching on any of them.
|
QueryProvider |
Defines methods to create and execute queries that are described by a
Queryable object.
|
QueryProviderImpl |
|
QueryProviderImpl.QueryableImpl<T> |
Binds an expression to this query provider.
|
QueryType |
Type of Druid query.
|
RandomFunction |
Function object for RAND and RAND_INTEGER , with and without
seed.
|
RawEnumerable<T> |
Exposes the enumerator, which supports a simple iteration over a collection,
without the extension methods.
|
RawQueryable<T> |
|
RecordEnumeratorCursor<E> |
Implementation of Cursor on top of an
Enumerator that
returns a record for each row.
|
RedshiftSqlDialect |
A SqlDialect implementation for the Redshift database.
|
ReduceDecimalsRule |
ReduceDecimalsRule is a rule which reduces decimal operations (such as casts
or arithmetic) into operations involving more primitive types (such as longs
and doubles).
|
ReduceExpressionsRule |
Collection of planner rules that apply various simplifying transformations on
RexNode trees.
|
ReduceExpressionsRule.CalcReduceExpressionsRule |
Rule that reduces constants inside a Calc .
|
ReduceExpressionsRule.CaseShuttle |
Shuttle that pushes predicates into a CASE.
|
ReduceExpressionsRule.FilterReduceExpressionsRule |
Rule that reduces constants inside a Filter .
|
ReduceExpressionsRule.JoinReduceExpressionsRule |
Rule that reduces constants inside a Join .
|
ReduceExpressionsRule.ProjectReduceExpressionsRule |
Rule that reduces constants inside a Project .
|
ReduceExpressionsRule.ReducibleExprLocator |
Helper class used to locate expressions that either can be reduced to
literals or contain redundant casts.
|
ReduceExpressionsRule.ReducibleExprLocator.Constancy |
Whether an expression is constant, and if so, whether it can be
reduced to a simpler constant.
|
ReduceExpressionsRule.RexReplacer |
Replaces expressions with their reductions.
|
ReflectedPseudoField |
Represents a PseudoField that is implemented via java reflection Field
|
ReflectiveCallNotNullImplementor |
|
ReflectiveConvertletTable |
Implementation of SqlRexConvertletTable which uses reflection to call
any method of the form public RexNode convertXxx(ConvertletContext,
SqlNode) or public RexNode convertXxx(ConvertletContext,
SqlOperator, SqlCall) .
|
ReflectiveFunctionBase |
Implementation of a function that is based on a method.
|
ReflectiveFunctionBase.ParameterListBuilder |
|
ReflectiveRelMetadataProvider |
Implementation of the RelMetadataProvider interface that dispatches
metadata methods to methods on a given object via reflection.
|
ReflectiveRelMetadataProvider.Space |
Workspace for computing which methods can act as handlers for
given metadata methods.
|
ReflectiveRelMetadataProvider.Space2 |
Extended work space.
|
ReflectiveSchema |
Implementation of Schema that exposes the
public fields and methods in a Java object.
|
ReflectiveSchema.Factory |
Factory that creates a schema by instantiating an object and looking at
its public fields.
|
ReflectiveSchema.FieldSelector |
Function that returns an array of a given object's field values.
|
ReflectiveSchema.FieldTable<T> |
Table based on a Java field.
|
ReflectiveSchema.MethodTableMacro |
Table macro based on a Java method.
|
ReflectiveSchema.ReflectiveTable |
Table that is implemented by reading from a Java object.
|
ReflectiveSqlOperatorTable |
ReflectiveSqlOperatorTable implements the SqlOperatorTable interface
by reflecting the public fields of a subclass.
|
ReflectiveSqlOperatorTable.Key |
Key for looking up operators.
|
ReflectiveVisitDispatcher<R extends ReflectiveVisitor,E> |
Interface for looking up methods relating to reflective visitation.
|
ReflectiveVisitor |
|
ReflectUtil |
Static utilities for Java reflection.
|
ReflectUtil.MethodDispatcher<T> |
Can invoke a method on an object of type E with return type T.
|
RelBuilder |
Builder for relational expressions.
|
RelBuilder.AggCall |
Information necessary to create a call to an aggregate function.
|
RelBuilder.AggCallImpl2 |
|
RelBuilder.Field |
|
RelBuilder.Frame |
Builder stack frame.
|
RelBuilder.GroupKey |
Information necessary to create the GROUP BY clause of an Aggregate.
|
RelBuilder.GroupKeyImpl |
|
RelBuilder.Registrar |
|
RelBuilderFactory |
A partially-created RelBuilder.
|
RelCollation |
Description of the physical ordering of a relational expression.
|
RelCollationImpl |
|
RelCollations |
|
RelCollationTraitDef |
Definition of the ordering trait.
|
RelColumnMapping |
Mapping from an input column of a RelNode to
one of its output columns.
|
RelColumnOrigin |
RelColumnOrigin is a data structure describing one of the origins of an
output column produced by a relational expression.
|
RelCompositeTrait<T extends RelMultipleTrait> |
A trait that consists of a list of traits, all of the same type.
|
RelConversionException |
An Exception thrown when attempting conversion to a set of
RelNode s.
|
RelCrossType |
Type of the cartesian product of two or more sets of records.
|
RelDataType |
RelDataType represents the type of a scalar expression or entire row returned
from a relational expression.
|
RelDataTypeComparability |
RelDataTypeComparability is an enumeration of the categories of comparison
operators which types may support.
|
RelDataTypeFactory |
RelDataTypeFactory is a factory for datatype descriptors.
|
RelDataTypeFactory.Builder |
Fluid API to build a list of fields.
|
RelDataTypeFactory.FieldInfo |
Deprecated. |
RelDataTypeFactory.FieldInfoBuilder |
Deprecated. |
RelDataTypeFactoryImpl |
|
RelDataTypeFactoryImpl.Key |
Key to the data type cache.
|
RelDataTypeFamily |
RelDataTypeFamily represents a family of related types.
|
RelDataTypeField |
RelDataTypeField represents the definition of a field in a structured
RelDataType .
|
RelDataTypeField.ToFieldIndex |
Deprecated.
|
RelDataTypeField.ToFieldName |
Deprecated.
|
RelDataTypeFieldImpl |
|
RelDataTypeHolder |
Holding the expandable list of fields for dynamic table.
|
RelDataTypeImpl |
RelDataTypeImpl is an abstract base for implementations of
RelDataType .
|
RelDataTypeImpl.Slot |
|
RelDataTypePrecedenceList |
RelDataTypePrecedenceList defines a type precedence list for a particular
type.
|
RelDataTypeSystem |
Type system.
|
RelDataTypeSystemImpl |
Default implementation of
RelDataTypeSystem ,
providing parameters from the SQL standard.
|
RelDecorrelator |
RelDecorrelator replaces all correlated expressions (corExp) in a relational
expression (RelNode) tree with non-correlated expressions that are produced
from joining the RelNode that produces the corExp with the RelNode that
references it.
|
RelDecorrelator.CorDef |
A correlation and a field.
|
RelDecorrelator.CorelMap |
|
RelDecorrelator.CorelMapBuilder |
|
RelDecorrelator.CorRef |
A unique reference to a correlation field.
|
RelDecorrelator.DecorrelateRexShuttle |
Shuttle that decorrelates.
|
RelDecorrelator.Frame |
Frame describing the relational expression after decorrelation
and where to find the output fields and correlation variables
among its output fields.
|
RelDistribution |
Description of the physical distribution of a relational expression.
|
RelDistribution.Type |
Type of distribution.
|
RelDistributions |
|
RelDistributions.RelDistributionImpl |
|
RelDistributionTraitDef |
Definition of the distribution trait.
|
RelFactories |
Contains factory interface and default implementation for creating various
rel nodes.
|
RelFactories.AggregateFactory |
Can create a LogicalAggregate of the appropriate type
for this rule's calling convention.
|
RelFactories.AggregateFactoryImpl |
|
RelFactories.CorrelateFactory |
Can create a correlate of the appropriate type for a rule's calling
convention.
|
RelFactories.CorrelateFactoryImpl |
|
RelFactories.ExchangeFactory |
Can create a Exchange
of the appropriate type for a rule's calling convention.
|
RelFactories.ExchangeFactoryImpl |
|
RelFactories.FilterFactory |
Can create a LogicalFilter of the appropriate type
for this rule's calling convention.
|
RelFactories.FilterFactoryImpl |
|
RelFactories.JoinFactory |
Can create a join of the appropriate type for a rule's calling convention.
|
RelFactories.JoinFactoryImpl |
|
RelFactories.MatchFactory |
Can create a Match of
the appropriate type for a rule's calling convention.
|
RelFactories.MatchFactoryImpl |
|
RelFactories.ProjectFactory |
Can create a
LogicalProject of the
appropriate type for this rule's calling convention.
|
RelFactories.ProjectFactoryImpl |
|
RelFactories.SemiJoinFactory |
Can create a semi-join of the appropriate type for a rule's calling
convention.
|
RelFactories.SemiJoinFactoryImpl |
|
RelFactories.SetOpFactory |
Can create a SetOp for a particular kind of
set operation (UNION, EXCEPT, INTERSECT) and of the appropriate type
for this rule's calling convention.
|
RelFactories.SetOpFactoryImpl |
|
RelFactories.SortExchangeFactory |
Can create a SortExchange
of the appropriate type for a rule's calling convention.
|
RelFactories.SortExchangeFactoryImpl |
|
RelFactories.SortFactory |
Can create a Sort of the appropriate type
for this rule's calling convention.
|
RelFactories.SortFactoryImpl |
|
RelFactories.TableScanFactory |
Can create a TableScan of the appropriate type for a rule's calling
convention.
|
RelFactories.TableScanFactoryImpl |
|
RelFactories.ValuesFactory |
Can create a Values of the appropriate type for a rule's calling
convention.
|
RelFactories.ValuesFactoryImpl |
|
RelFieldCollation |
Definition of the ordering of one field of a RelNode whose
output is to be sorted.
|
RelFieldCollation.Direction |
Direction that a field is ordered in.
|
RelFieldCollation.NullDirection |
Ordering of nulls.
|
RelFieldTrimmer |
Transformer that walks over a tree of relational expressions, replacing each
RelNode with a 'slimmed down' relational expression that projects
only the columns required by its consumer.
|
RelFieldTrimmer.TrimResult |
Result of an attempt to trim columns from a relational expression.
|
RelHomogeneousShuttle |
Visits all the relations in a homogeneous way: always redirects calls to
accept(RelNode) .
|
RelImplementor |
|
RelInput |
Context from which a relational expression can initialize itself,
reading from a serialized form of the relational expression.
|
RelJson |
Utilities for converting RelNode
into JSON format.
|
RelJsonReader |
Reads a JSON plan and converts it back to a tree of relational expressions.
|
RelJsonWriter |
Callback for a relational expression to dump itself as JSON.
|
RelMdAllPredicates |
Utility to extract Predicates that are present in the (sub)plan
starting at this node.
|
RelMdCollation |
|
RelMdColumnOrigins |
|
RelMdColumnUniqueness |
|
RelMdDistinctRowCount |
|
RelMdDistribution |
|
RelMdExplainVisibility |
|
RelMdExpressionLineage |
|
RelMdExpressionLineage.RexReplacer |
Replaces expressions with their equivalences.
|
RelMdMaxRowCount |
|
RelMdMemory |
|
RelMdMinRowCount |
|
RelMdNodeTypes |
|
RelMdParallelism |
|
RelMdPercentageOriginalRows |
|
RelMdPopulationSize |
|
RelMdPredicates |
Utility to infer Predicates that are applicable above a RelNode.
|
RelMdPredicates.JoinConditionBasedPredicateInference |
Utility to infer predicates from one side of the join that apply on the
other side.
|
RelMdRowCount |
|
RelMdSelectivity |
|
RelMdSize |
Default implementations of the
BuiltInMetadata.Size
metadata provider for the standard logical algebra.
|
RelMdTableReferences |
|
RelMdUniqueKeys |
|
RelMdUtil |
RelMdUtil provides utility methods used by the metadata provider methods.
|
RelMdUtil.CardOfProjExpr |
Visitor that walks over a scalar expression and computes the
cardinality of its result.
|
RelMetadataProvider |
RelMetadataProvider defines an interface for obtaining metadata about
relational expressions.
|
RelMetadataQuery |
RelMetadataQuery provides a strongly-typed facade on top of
RelMetadataProvider for the set of relational expression metadata
queries defined as standard within Calcite.
|
RelMultipleTrait |
Trait for which a given relational expression can have multiple values.
|
RelNode |
A RelNode is a relational expression.
|
RelNode.Context |
Context of a relational expression, for purposes of checking validity.
|
RelNodes |
Utilities concerning relational expressions.
|
RelNodes.RelNodeComparator |
Arbitrary stable comparator for RelNode s.
|
RelOptAbstractTable |
|
RelOptCluster |
An environment for related relational expressions during the
optimization of a query.
|
RelOptConnection |
The planner's view of a connection to a database.
|
RelOptCost |
RelOptCost defines an interface for optimizer cost in terms of number of rows
processed, CPU cost, and I/O cost.
|
RelOptCostFactory |
Cost model for query planning.
|
RelOptCostImpl |
RelOptCostImpl provides a default implementation for the RelOptCost
interface.
|
RelOptCostImpl.Factory |
|
RelOptLattice |
Use of a lattice by the query optimizer.
|
RelOptListener |
RelOptListener defines an interface for listening to events which occur
during the optimization process.
|
RelOptListener.RelChosenEvent |
Event indicating that a relational expression has been chosen.
|
RelOptListener.RelDiscardedEvent |
Event indicating that a relational expression has been discarded.
|
RelOptListener.RelEquivalenceEvent |
Event indicating that a relational expression has been found to
be equivalent to an equivalence class.
|
RelOptListener.RelEvent |
Event class for abstract event dealing with a relational expression.
|
RelOptListener.RuleAttemptedEvent |
Event indicating that a planner rule has been attemptedd.
|
RelOptListener.RuleEvent |
Event indicating that a planner rule has fired.
|
RelOptListener.RuleProductionEvent |
Event indicating that a planner rule has produced a result.
|
RelOptMaterialization |
Records that a particular query is materialized by a particular table.
|
RelOptMaterialization.ProjectFilterTable |
A table scan and optional project mapping and filter condition.
|
RelOptMaterializations |
Utility methods for using
materialized views and lattices for queries.
|
RelOptNode |
Node in a planner.
|
RelOptPlanner |
A RelOptPlanner is a query optimizer: it transforms a relational
expression into a semantically equivalent relational expression, according to
a given set of rules and a cost model.
|
RelOptPlanner.CannotPlanException |
|
RelOptPlanner.Executor |
Deprecated.
|
RelOptPredicateList |
Predicates that are known to hold in the output of a particular relational
expression.
|
RelOptQuery |
|
RelOptRule |
A RelOptRule transforms an expression into another.
|
RelOptRule.ConverterRelOptRuleOperand |
Operand to an instance of the converter rule.
|
RelOptRuleCall |
|
RelOptRuleOperand |
Operand that determines whether a RelOptRule
can be applied to a particular expression.
|
RelOptRuleOperandChildPolicy |
Policy by which operands will be matched by relational expressions with
any number of children.
|
RelOptRuleOperandChildren |
|
RelOptSamplingParameters |
RelOptSamplingParameters represents the parameters necessary to produce a
sample of a relation.
|
RelOptSchema |
|
RelOptSchemaWithSampling |
Extension to RelOptSchema with support for sample data-sets.
|
RelOptTable |
|
RelOptTable.ToRelContext |
Contains the context needed to convert a a table into a relational
expression.
|
RelOptTable.ViewExpander |
Can expand a view into relational expressions.
|
RelOptTableImpl |
|
RelOptTableImpl.MySchemaPlus |
Implementation of SchemaPlus that wraps a regular schema and knows
its name and parent.
|
RelOptUtil |
RelOptUtil defines static utility methods for use in optimizing
RelNode s.
|
RelOptUtil.CorrelationCollector |
Shuttle that finds correlation variables inside a given relational
expression, including those that are inside
sub-queries .
|
RelOptUtil.Exists |
|
RelOptUtil.InputFinder |
Visitor which builds a bitmap of the inputs used by an expression.
|
RelOptUtil.InputReferencedVisitor |
Shuttle that finds the set of inputs that are used.
|
RelOptUtil.Logic |
Policies for handling two- and three-valued boolean logic.
|
RelOptUtil.RexInputConverter |
Walks an expression tree, converting the index of RexInputRefs based on
some adjustment factor.
|
RelOptUtil.Side |
Categorizes whether a bit set contains bits left and right of a
line.
|
RelOptUtil.SubQueryType |
What kind of sub-query.
|
RelOptUtil.TypeDumper |
Converts types to descriptive strings.
|
RelOptUtil.VariableSetVisitor |
Visitor that finds all variables used but not stopped in an expression.
|
RelOptUtil.VariableUsedVisitor |
Visitor that finds all variables used in an expression.
|
RelProtoDataType |
|
RelRecordType |
RelRecordType represents a structured type having named fields.
|
RelRecordType.SerializableRelRecordType |
Skinny object which has the same information content as a
RelRecordType but skips redundant stuff like digest and the
immutable list.
|
RelReferentialConstraint |
Interface for a referential constraint, i.e., Foreign-Key - Unique-Key relationship,
between two tables.
|
RelReferentialConstraintImpl |
RelOptReferentialConstraint base implementation.
|
RelRoot |
|
RelRunner |
Runs a relational expression.
|
RelRunners |
|
RelSet |
A RelSet is an equivalence-set of expressions; that is, a set of
expressions which have identical semantics.
|
RelShuttle |
Visitor that has methods for the common logical relational expressions.
|
RelShuttleImpl |
|
RelStructuredTypeFlattener |
RelStructuredTypeFlattener removes all structured types from a tree of
relational expressions.
|
RelStructuredTypeFlattener.SelfFlatteningRel |
Mix-in interface for relational expressions that know how to
flatten themselves.
|
RelSubset |
Subset of an equivalence class where all relational expressions have the
same physical properties.
|
RelSubset.CheapestPlanReplacer |
Visitor which walks over a tree of RelSet s, replacing each node
with the cheapest implementation of the expression.
|
RelToSqlConverter |
Utility to convert relational expressions to SQL abstract syntax tree.
|
RelToSqlConverter.Frame |
Stack frame.
|
RelTrait |
RelTrait represents the manifestation of a relational expression trait within
a trait definition.
|
RelTraitDef<T extends RelTrait> |
RelTraitDef represents a class of RelTrait s.
|
RelTraitPropagationVisitor |
RelTraitPropagationVisitor traverses a RelNode and its unregistered
children, making sure that each has a full complement of traits.
|
RelTraitSet |
RelTraitSet represents an ordered set of RelTrait s.
|
RelTraitSet.Cache |
Cache of trait sets.
|
RelVisitor |
|
RelWriter |
Callback for an expression to dump itself to.
|
RelWriterImpl |
|
RelXmlWriter |
Callback for a relational expression to dump in XML format.
|
Resources |
Defining wrapper classes around resources that allow the compiler to check
whether the resources exist and have the argument types that your code
expects.
|
Resources.BaseMessage |
The message in the default locale.
|
Resources.BooleanProp |
Boolean property instance.
|
Resources.BuiltinMethod |
|
Resources.Default |
Default value of a property.
|
Resources.DoubleProp |
Double property instance.
|
Resources.Element |
Element in a resource (either a resource or a property).
|
Resources.EmptyPropertyAccessor |
|
Resources.ExInst<T extends java.lang.Exception> |
Sub-class of Resources.Inst that can throw an exception without caused
by.
|
Resources.ExInstWithCause<T extends java.lang.Exception> |
|
Resources.Inst |
Resource instance.
|
Resources.IntProp |
Integer property instance.
|
Resources.MyPropertyResourceBundle |
Resource bundle based on properties.
|
Resources.NoDefaultValueException |
Thrown when a default value is needed but a property does not have
one.
|
Resources.Prop |
Property instance.
|
Resources.PropertiesAccessor |
|
Resources.Property |
Property of a resource.
|
Resources.PropertyAccessor |
Means by which a resource can get values of properties, given their
name.
|
Resources.Resource |
The name of the property in the resource file.
|
Resources.ShadowResourceBundle |
ShadowResourceBundle is an abstract base class for
ResourceBundle classes which are backed by a properties file.
|
Resources.StringProp |
String property instance.
|
Resources.Validation |
Types of validation that can be performed on a resource.
|
ResultSetEnumerable<T> |
Executes a SQL statement and returns the result as an Enumerable .
|
ResultSetEnumerable.PreparedStatementEnricher |
Consumer for decorating a PreparedStatement , that is, setting
its parameters.
|
ResultSetEnumerable.ResultSetEnumerator<T> |
Implementation of Enumerator that reads from a
ResultSet .
|
ReturnTypes |
A collection of return-type inference strategies.
|
RexAction |
A RexAction is called when a RexPattern finds a match.
|
RexAnalyzer |
Analyzes an expression, figures out what are the unbound variables,
assigns a variety of values to each unbound variable, and evaluates
the expression.
|
RexAnalyzer.VariableCollector |
Collects the variables (or other bindable sites) in an expression, and
counts features (such as CAST) that RexInterpreter cannot
handle.
|
RexBiVisitor<R,P> |
Visitor pattern for traversing a tree of RexNode objects
and passing a payload to each.
|
RexBuilder |
Factory for row expressions.
|
RexCall |
An expression formed by a call to an operator with zero or more expressions
as operands.
|
RexCallBinding |
|
RexCallBinding.RexCastCallBinding |
To be compatible with SqlCall , CAST needs to pretend that it
has two arguments, the second of which is the target type.
|
RexChecker |
Visitor which checks the validity of a RexNode expression.
|
RexCopier |
Shuttle which creates a deep copy of a Rex expression.
|
RexCorrelVariable |
Reference to the current row of a correlating relational expression.
|
RexDynamicParam |
Dynamic parameter reference in a row-expression.
|
RexExecutable |
Result of compiling code generated from a RexNode expression.
|
RexExecutor |
Can reduce expressions, writing a literal for each into a list.
|
RexExecutorImpl |
|
RexExecutorImpl.DataContextInputGetter |
|
RexFieldAccess |
Access to a field of a row-expression.
|
RexFieldCollation |
Expression combined with sort flags (DESCENDING, NULLS LAST).
|
RexFieldCollation.Initializer |
Helper, used during initialization, that builds a canonizing map from
sets of SqlKind to immutable sets of SqlKind .
|
RexImplicationChecker |
Checks whether one condition logically implies another.
|
RexImplicationChecker.InputRefUsage<T1,T2> |
|
RexImplicationChecker.InputUsageFinder |
Visitor that builds a usage map of inputs used by an expression.
|
RexImpTable |
Contains implementations of Rex operators as Java code.
|
RexImpTable.BinaryImplementor |
Implementor for binary operators.
|
RexImpTable.CaseImplementor |
Implementor for the SQL CASE operator.
|
RexImpTable.CastImplementor |
Implementor for the SQL CAST operator.
|
RexImpTable.CastOptimizedImplementor |
Implementor for the SQL CAST function that optimizes if, say, the
argument is already of the desired type.
|
RexImpTable.CoalesceImplementor |
Implementor for the SQL COALESCE operator.
|
RexImpTable.CollectImplementor |
Implementor for the COLLECT aggregate function.
|
RexImpTable.CountImplementor |
Implementor for the COUNT aggregate function.
|
RexImpTable.CountWinImplementor |
Implementor for the COUNT windowed aggregate function.
|
RexImpTable.DatetimeArithmeticImplementor |
Implementor for various datetime arithmetic.
|
RexImpTable.DenseRankImplementor |
Implementor for the DENSE_RANK windowed aggregate function.
|
RexImpTable.ExtractImplementor |
Implementor for the EXTRACT(unit FROM datetime) function.
|
RexImpTable.FirstLastValueImplementor |
Implementor for the FIRST_VALUE and LAST_VALUE
windowed aggregate functions.
|
RexImpTable.FirstValueImplementor |
Implementor for the FIRST_VALUE windowed aggregate function.
|
RexImpTable.FloorImplementor |
Implementor for the FLOOR and CEIL functions.
|
RexImpTable.FusionImplementor |
Implementor for the FUSION aggregate function.
|
RexImpTable.GroupingImplementor |
Implementor for the GROUPING aggregate function.
|
RexImpTable.IsXxxImplementor |
Implements "IS XXX" operations such as "IS NULL"
or "IS NOT TRUE".
|
RexImpTable.ItemImplementor |
Implementor for the ITEM SQL operator.
|
RexImpTable.JsonArrayAggImplementor |
Implementor for the JSON_ARRAYAGG aggregate function.
|
RexImpTable.JsonObjectAggImplementor |
Implementor for the JSON_OBJECTAGG aggregate function.
|
RexImpTable.LagImplementor |
Implementor for the LAG windowed aggregate function.
|
RexImpTable.LastValueImplementor |
Implementor for the LAST_VALUE windowed aggregate function.
|
RexImpTable.LeadImplementor |
Implementor for the LEAD windowed aggregate function.
|
RexImpTable.LeadLagImplementor |
Implementor for the LEAD and LAG windowed
aggregate functions.
|
RexImpTable.MethodImplementor |
Implementor for a function that generates calls to a given method.
|
RexImpTable.MethodNameImplementor |
Implementor for SQL functions that generates calls to a given method name.
|
RexImpTable.MinMaxImplementor |
Implementor for the MIN and MAX aggregate functions.
|
RexImpTable.NotImplementor |
Implementor for the NOT operator.
|
RexImpTable.NthValueImplementor |
Implementor for the NTH_VALUE
windowed aggregate function.
|
RexImpTable.NtileImplementor |
Implementor for the NTILE windowed aggregate function.
|
RexImpTable.NullAs |
Strategy what an operator should return if one of its
arguments is null.
|
RexImpTable.RankImplementor |
Implementor for the RANK windowed aggregate function.
|
RexImpTable.ReinterpretImplementor |
Implementor for the REINTERPRET internal SQL operator.
|
RexImpTable.RowNumberImplementor |
Implementor for the ROW_NUMBER windowed aggregate function.
|
RexImpTable.SingleValueImplementor |
Implementor for the SINGLE_VALUE aggregate function.
|
RexImpTable.SumImplementor |
Implementor for the SUM windowed aggregate function.
|
RexImpTable.SystemFunctionImplementor |
Implementor for SQL system functions.
|
RexImpTable.TrimImplementor |
Implementor for the TRIM function.
|
RexImpTable.UnaryImplementor |
Implementor for unary operators.
|
RexImpTable.UserDefinedAggReflectiveImplementor |
Implementor for user-defined aggregate functions.
|
RexImpTable.ValueConstructorImplementor |
Implementor for a value-constructor.
|
RexInputRef |
Variable which references a field of an input relational expression.
|
RexInterpreter |
|
RexInterpreter.Truthy |
An enum that wraps boolean and unknown values and makes them
comparable.
|
RexLiteral |
Constant value in a row-expression.
|
RexLocalRef |
Local variable.
|
RexMultisetUtil |
Utility class for various methods related to multisets.
|
RexMultisetUtil.RexCallMultisetOperatorCounter |
A RexShuttle that traverse all RexNode and counts total number of
RexCalls traversed and number of multiset calls traversed.
|
RexNode |
Row expression.
|
RexOver |
Call to an aggregate function over a window.
|
RexOver.Finder |
|
RexOver.OverFound |
Exception thrown when an OVER is found.
|
RexPattern |
A RexPattern represents an expression with holes in it.
|
RexPatternFieldRef |
Variable which references a field of an input relational expression
|
RexPermutationShuttle |
|
RexPermuteInputsShuttle |
Shuttle which applies a permutation to its input fields.
|
RexProgram |
A collection of expressions which read inputs, compute output expressions,
and optionally use a condition to filter rows.
|
RexProgram.Checker |
Visitor which walks over a program and checks validity.
|
RexProgram.ExpansionShuttle |
|
RexProgramBuilder |
|
RexRangeRef |
Reference to a range of columns.
|
RexShuttle |
Passes over a row-expression, calling a handler method for each node,
appropriate to the type of the node.
|
RexSimplify |
Context required to simplify a row-expression.
|
RexSimplify.CaseBranch |
Object to describe a Case branch
|
RexSimplify.Comparison |
|
RexSimplify.IsPredicate |
Represents an IS Predicate.
|
RexSimplify.Predicate |
Marker interface for predicates (expressions that evaluate to BOOLEAN).
|
RexSimplify.SafeRexVisitor |
Decides whether it is safe to flatten the given case part into AND/ORs
|
RexSlot |
|
RexSlot.SelfPopulatingList |
Thread-safe list that populates itself if you make a reference beyond
the end of the list.
|
RexSqlConvertlet |
|
RexSqlConvertletTable |
|
RexSqlReflectiveConvertletTable |
|
RexSqlStandardConvertletTable |
|
RexSubQuery |
Scalar expression that represents an IN, EXISTS or scalar sub-query.
|
RexTableInputRef |
Variable which references a column of a table occurrence in a relational plan.
|
RexTableInputRef.RelTableRef |
Identifies uniquely a table by its qualified name and its entity number (occurrence)
|
RexToLixTranslator |
|
RexToLixTranslator.AlwaysNull |
Thrown in the unusual (but not erroneous) situation where the expression
we are translating is the null literal but we have already checked that
it is not null.
|
RexToLixTranslator.InputGetter |
Translates a field of an input to an expression.
|
RexToLixTranslator.InputGetterImpl |
|
RexToSqlNodeConverter |
|
RexToSqlNodeConverterImpl |
|
RexTransformer |
Takes a tree of RexNode objects and transforms it into another in one
sense equivalent tree.
|
RexUnknownAs |
Policy for whether a simplified expression may instead return another
value.
|
RexUtil |
Utility methods concerning row-expressions.
|
RexUtil.CnfHelper |
|
RexUtil.CnfHelper.OverflowError |
Exception to catch when we pass the limit.
|
RexUtil.ConstantFinder |
Walks over an expression and determines whether it is constant.
|
RexUtil.CorrelationFinder |
|
RexUtil.DnfHelper |
|
RexUtil.ExpressionNormalizer |
Walks over expressions and builds a bank of common sub-expressions.
|
RexUtil.ExpressionNormalizer.SubExprExistsException |
Thrown if there is a sub-expression.
|
RexUtil.ExprSimplifier |
Deprecated. |
RexUtil.FieldAccessFinder |
Visitor which builds a bitmap of the inputs used by an expression.
|
RexUtil.FixNullabilityShuttle |
Shuttle that fixes up an expression to match changes in nullability of
input fields.
|
RexUtil.ForwardRefFinder |
|
RexUtil.ForwardRefFinder.IllegalForwardRefException |
Thrown to abort a visit when we find an illegal forward reference.
|
RexUtil.RexShiftShuttle |
Shuttle that adds offset to each RexInputRef in an
expression.
|
RexUtil.SubQueryFinder |
|
RexVariable |
A row-expression which references a field.
|
RexVisitor<R> |
Visitor pattern for traversing a tree of RexNode objects.
|
RexVisitorImpl<R> |
Default implementation of RexVisitor , which visits each node but does
nothing while it's there.
|
RexWindow |
Specification of the window of rows over which a RexOver windowed
aggregate is evaluated.
|
RexWindowBound |
Abstracts "XX PRECEDING/FOLLOWING" and "CURRENT ROW" bounds for windowed
aggregates.
|
RexWindowBound.RexWindowBoundBounded |
Implements XX PRECEDING/FOLLOWING bound where XX is not UNBOUNDED.
|
RexWindowBound.RexWindowBoundCurrentRow |
Implements CURRENT ROW bound.
|
RexWindowBound.RexWindowBoundUnbounded |
Implements UNBOUNDED PRECEDING/FOLLOWING bound.
|
Row |
Row.
|
Row.RowBuilder |
Utility class to build row objects.
|
RuleQueue |
Priority queue of relexps whose rules have not been called, and rule-matches
which have not yet been acted upon.
|
RuleQueue.PhaseMatchList |
|
RuleQueue.RuleMatchImportanceComparator |
|
RuleSet |
A set rules associated with a particular
type of invocation of the Planner .
|
RuleSets |
Utilities for creating and composing rule sets.
|
RuleSets.ListRuleSet |
Rule set that consists of a list of rules.
|
SaffronProperties |
Provides an environment for debugging information, et cetera, used by
saffron.
|
SaffronProperties.Helper |
Helper class.
|
SameOperandTypeChecker |
Parameter type-checking strategy where all operand types must be the same.
|
SameOperandTypeExceptLastOperandChecker |
Parameter type-checking strategy where all operand types except last one must be the same.
|
Sample |
Relational expression that returns a sample of the rows from its input.
|
Scalar |
Compiled scalar expression.
|
ScalarFunction |
Function that returns a scalar result.
|
ScalarFunctionImpl |
|
ScannableTable |
Table that can be scanned without creating an intermediate relational
expression.
|
Schema |
A namespace for tables and functions.
|
Schema.TableType |
Table type.
|
SchemaFactory |
|
SchemaNamespace |
Namespace based on a schema.
|
SchemaPlus |
Extension to the Schema interface.
|
Schemas |
Utility functions for schemas.
|
Schemas.DummyDataContext |
Dummy data context that has no variables.
|
Schemas.PathImpl |
|
SchemaVersion |
An interface to represent a version ID that can be used to create a
read-consistent view of a Schema.
|
ScopeChild |
|
Scrolling |
"Iterator" which retrieves results lazily and in batches.
|
Scrolling.AutoClosingIterator |
Observes when existing iterator has ended and clears context (scroll) if any.
|
Scrolling.SequentialIterator |
Iterator which consumes current scrollId until full search result is fetched
or limit is reached.
|
SearchResultListener |
Called each time a search returns a record.
|
SelectNamespace |
Namespace offered by a sub-query.
|
SelectScope |
The name-resolution scope of a SELECT clause.
|
SemiJoin |
Relational expression that joins two relational expressions according to some
condition, but outputs only columns from the left input, and eliminates
duplicates.
|
SemiJoinFilterTransposeRule |
|
SemiJoinJoinTransposeRule |
Planner rule that pushes a SemiJoin
down in a tree past a Join
in order to trigger other rules that will convert SemiJoin s.
|
SemiJoinProjectTransposeRule |
|
SemiJoinRemoveRule |
Planner rule that removes a SemiJoin s
from a join tree.
|
SemiJoinRule |
|
SemiJoinRule.JoinToSemiJoinRule |
SemiJoinRule that matches a Join with an empty Aggregate as its right
child.
|
SemiJoinRule.ProjectToSemiJoinRule |
SemiJoinRule that matches a Project on top of a Join with an Aggregate
as its right child.
|
SemiJoinType |
Enumeration representing different join types used in correlation
relations.
|
SemiMutableSchema |
Schema to which materializations can be added.
|
SemiStrict |
Annotation applied to a user-defined function that indicates that
the function always returns null if one or more of its arguments
are null but also may return null at other times.
|
SequencedAdderAggregateLambdaFactory<TSource,TAccumulate,TResult,TKey> |
|
SerializableCharset |
Serializable wrapper around a Charset .
|
SetOp |
SetOp is an abstract base for relational set operators such
as UNION, MINUS (aka EXCEPT), and INTERSECT.
|
SetopNamespace |
Namespace based upon a set operation (UNION, INTERSECT, EXCEPT).
|
SetopOperandTypeChecker |
Parameter type-checking strategy for a set operator (UNION, INTERSECT,
EXCEPT).
|
Shuttle |
Extension to Visitor that returns a mutated tree.
|
SimpleCalciteSchema |
A concrete implementation of CalciteSchema
that maintains minimal state.
|
SimpleProfiler |
|
SimpleProfiler.Run |
A run of the profiler.
|
SimpleProfiler.Space |
Work space for a particular combination of columns.
|
SingleRel |
Abstract base class for relational expressions with a single input.
|
Sink |
Sink to which to send rows.
|
SocketFactoryImpl |
Extends the SocketFactory object with the main functionality being that the
created sockets inherit a set of options whose values are set in the
SocketFactoryImpl.
|
Sort |
Relational expression that imposes a particular sort order on its input
without otherwise changing its content.
|
SortedMultiMap<K,V> |
Map that allows you to partition values into lists according to a common
key, and then convert those lists into an iterator of sorted arrays.
|
SortExchange |
Relational expression that performs Exchange and Sort
simultaneously.
|
SortJoinTransposeRule |
Planner rule that pushes a Sort past a
Join .
|
SortNode |
Interpreter node that implements a
Sort .
|
SortProjectTransposeRule |
|
SortRemoveConstantKeysRule |
Planner rule that removes keys from a
a Sort if those keys are known to be
constant, or removes the entire Sort if all keys are constant.
|
SortRemoveRule |
Planner rule that removes
a Sort if its input is already sorted.
|
SortUnionTransposeRule |
Planner rule that pushes a Sort past a
Union .
|
Source |
Source of rows.
|
Source |
Source of data.
|
Sources |
|
Sources.FileSource |
|
SourceSorter<TAccumulate,TSource,TSortKey> |
|
SourceStringReader |
Extension to StringReader that allows the original string to be
recovered.
|
Span |
|
SparkHandlerImpl |
|
SparkMethod |
Built-in methods in the Spark adapter.
|
SparkRel |
Relational expression that uses Spark calling convention.
|
SparkRel.Implementor |
|
SparkRel.Result |
Result of generating Java code to implement a Spark relational
expression.
|
SparkRules |
|
SparkRules.EnumerableToSparkConverterRule |
Planner rule that converts from enumerable to Spark convention.
|
SparkRules.SparkCalc |
Implementation of Calc
in Spark convention.
|
SparkRules.SparkCalcRule |
|
SparkRules.SparkToEnumerableConverterRule |
Planner rule that converts from Spark to enumerable convention.
|
SparkRules.SparkValues |
VALUES construct implemented in Spark.
|
SparkRules.SparkValuesRule |
Planner rule that implements VALUES operator in Spark convention.
|
SparkRuntime |
Runtime utilities for Calcite's Spark adapter.
|
SparkRuntime.CalciteFlatMapFunction<T,R> |
Combines linq4j Function
and Spark FlatMapFunction .
|
SparkToEnumerableConverter |
|
SparkToEnumerableConverter.SparkImplementorImpl |
|
SplunkConnection |
Connection to Splunk.
|
SplunkConnectionImpl |
|
SplunkConnectionImpl.CountingSearchResultListener |
|
SplunkConnectionImpl.SplunkResultEnumerator |
Implementation of Enumerator that parses
results from a Splunk REST call.
|
SplunkDriver |
JDBC driver for Splunk.
|
SplunkDriver.MockSplunkConnection |
Connection that looks up responses from a static map.
|
SplunkDriver.WrappingSplunkConnection |
Connection that records requests and responses.
|
SplunkDriverVersion |
Version information for Calcite JDBC Driver for Splunk.
|
SplunkPushDownRule |
Planner rule to push filters and projections to Splunk.
|
SplunkQuery<T> |
Query against Splunk.
|
SplunkSchema |
Splunk schema.
|
SplunkTable |
Table based on Splunk.
|
SplunkTable.SplunkTableQueryable<T> |
|
SplunkTableScan |
Relational expression representing a scan of Splunk.
|
SqlAbstractConformance |
|
SqlAbstractDateTimeLiteral |
A SQL literal representing a DATE, TIME or TIMESTAMP value.
|
SqlAbstractGroupFunction |
Base class for grouping functions GROUP_ID , GROUPING_ID ,
GROUPING .
|
SqlAbstractParserImpl |
Abstract base for parsers generated from CommonParser.jj.
|
SqlAbstractParserImpl.ExprContext |
Type-safe enum for context of acceptable expressions.
|
SqlAbstractParserImpl.Metadata |
Metadata about the parser.
|
SqlAbstractParserImpl.MetadataImpl |
|
SqlAbstractStringLiteral |
Abstract base for character and binary string literals.
|
SqlAbstractTimeFunction |
Base class for time functions such as "LOCALTIME", "LOCALTIME(n)".
|
SqlAccessEnum |
Enumeration representing different access types
|
SqlAccessType |
SqlAccessType is represented by a set of allowed access types
|
SqlAdvisor |
An assistant which offers hints and corrections to a partially-formed SQL
statement.
|
SqlAdvisorGetHintsFunction |
Table function that returns completion hints for a given SQL statement.
|
SqlAdvisorGetHintsFunction2 |
Table function that returns completion hints for a given SQL statement.
|
SqlAdvisorHint |
|
SqlAdvisorHint2 |
|
SqlAdvisorValidator |
SqlAdvisorValidator is used by SqlAdvisor to traverse
the parse tree of a SQL statement, not for validation purpose but for setting
up the scopes and namespaces to facilitate retrieval of SQL statement
completion hints.
|
SqlAggFunction |
Abstract base class for the definition of an aggregate function: an operator
which aggregates sets of values into a result.
|
SqlAlter |
Base class for an ALTER statements parse tree nodes.
|
SqlAnyValueAggFunction |
Definition of the ANY_VALUE aggregate functions,
returning any one of the values which go into it.
|
SqlArgumentAssignmentOperator |
Operator that assigns an argument to a function call to a particular named
parameter.
|
SqlArrayQueryConstructor |
Definition of the SQL:2003 standard ARRAY query constructor,
ARRAY (<query>) .
|
SqlArrayValueConstructor |
Definition of the SQL:2003 standard ARRAY constructor, ARRAY
[<expr>, ...] .
|
SqlAsOperator |
The AS operator associates an expression with an alias.
|
SqlAttributeDefinition |
Parse tree for SqlAttributeDefinition,
which is part of a SqlCreateType .
|
SqlAvgAggFunction |
Avg is an aggregator which returns the average of the values
which go into it.
|
SqlAvgAggFunction.Subtype |
Deprecated. |
SqlBaseContextVariable |
Base class for functions such as "PI", "USER", "CURRENT_ROLE", and
"CURRENT_PATH".
|
SqlBasicCall |
Implementation of SqlCall that keeps its operands in an array.
|
SqlBasicVisitor<R> |
Basic implementation of SqlVisitor which does nothing at each node.
|
SqlBasicVisitor.ArgHandler<R> |
Argument handler.
|
SqlBasicVisitor.ArgHandlerImpl<R> |
|
SqlBetweenOperator |
Defines the BETWEEN operator.
|
SqlBetweenOperator.AndFinder |
Finds an AND operator in an expression.
|
SqlBetweenOperator.Flag |
Defines the "SYMMETRIC" and "ASYMMETRIC" keywords.
|
SqlBinaryOperator |
SqlBinaryOperator is a binary operator.
|
SqlBinaryStringLiteral |
A binary (or hexadecimal) string literal.
|
SqlBuilder |
Extension to StringBuilder for the purposes of creating SQL queries
and expressions.
|
SqlCall |
|
SqlCallBinding |
|
SqlCase |
A SqlCase is a node of a parse tree which represents a case
statement.
|
SqlCaseOperator |
An operator describing a CASE , NULLIF or
COALESCE expression.
|
SqlCastFunction |
SqlCastFunction.
|
SqlCharStringLiteral |
A character string literal.
|
SqlCheckConstraint |
Parse tree for UNIQUE , PRIMARY KEY constraints.
|
SqlCoalesceFunction |
The COALESCE function.
|
SqlCollation |
A SqlCollation is an object representing a Collate
statement.
|
SqlCollation.Coercibility |
A <character value expression> consisting of a column
reference has the coercibility characteristic Implicit, with collating
sequence as defined when the column was created.
|
SqlCollectionTableOperator |
SqlCollectionTableOperator is the "table function derived table" operator.
|
SqlColumnDeclaration |
Parse tree for UNIQUE , PRIMARY KEY constraints.
|
SqlColumnListConstructor |
SqlColumnListConstructor defines the non-standard constructor used to pass a
COLUMN_LIST parameter to a UDX.
|
SqlConformance |
Enumeration of valid SQL compatibility modes.
|
SqlConformanceEnum |
Enumeration of built-in SQL compatibility modes.
|
SqlConvertFunction |
Common base for the CONVERT and TRANSLATE
functions.
|
SqlCountAggFunction |
Definition of the SQL COUNT aggregation function.
|
SqlCovarAggFunction |
Covar is an aggregator which returns the Covariance of the
values which go into it.
|
SqlCovarAggFunction.Subtype |
Deprecated. |
SqlCreate |
Base class for an CREATE statements parse tree nodes.
|
SqlCreateForeignSchema |
Parse tree for CREATE FOREIGN SCHEMA statement.
|
SqlCreateFunction |
Parse tree for CREATE FUNCTION statement.
|
SqlCreateMaterializedView |
Parse tree for CREATE MATERIALIZED VIEW statement.
|
SqlCreateMaterializedView.MaterializedViewTable |
A table that implements a materialized view.
|
SqlCreateSchema |
Parse tree for CREATE SCHEMA statement.
|
SqlCreateTable |
Parse tree for CREATE TABLE statement.
|
SqlCreateTable.AbstractModifiableTable |
|
SqlCreateTable.ColumnDef |
Column definition.
|
SqlCreateTable.MutableArrayTable |
Table backed by a Java list.
|
SqlCreateType |
Parse tree for CREATE TYPE statement.
|
SqlCreateView |
Parse tree for CREATE VIEW statement.
|
SqlCurrentDateFunction |
The CURRENT_DATE function.
|
SqlCursorConstructor |
SqlCursorConstructor defines the non-standard CURSOR(<query>)
constructor.
|
SqlDataTypeSpec |
Represents a SQL data type specification in a parse tree.
|
SqlDateLiteral |
A SQL literal representing a DATE value, such as DATE
'2004-10-22' .
|
SqlDatePartFunction |
SqlDatePartFunction represents the SQL:1999 standard YEAR ,
QUARTER , MONTH and DAY functions.
|
SqlDatetimePlusOperator |
Operator that adds an INTERVAL to a DATETIME.
|
SqlDatetimeSubtractionOperator |
A special operator for the subtraction of two DATETIMEs.
|
SqlDdl |
Base class for CREATE, DROP and other DDL statements.
|
SqlDdlNodes |
Utilities concerning SqlNode for DDL.
|
SqlDdlNodes.FileType |
File type for CREATE FUNCTION.
|
SqlDefaultOperator |
Operator that indicates that an argument to a function call is to take its
default value.
|
SqlDelegatingConformance |
Implementation of SqlConformance that delegates all methods to
another object.
|
SqlDelete |
A SqlDelete is a node of a parse tree which represents a DELETE
statement.
|
SqlDescribeSchema |
A SqlDescribeSchema is a node of a parse tree that represents a
DESCRIBE SCHEMA statement.
|
SqlDescribeTable |
A SqlDescribeTable is a node of a parse tree that represents a
DESCRIBE TABLE statement.
|
SqlDialect |
SqlDialect encapsulates the differences between dialects of SQL.
|
SqlDialect.CalendarPolicy |
Whether this JDBC driver needs you to pass a Calendar object to methods
such as ResultSet.getTimestamp(int, java.util.Calendar) .
|
SqlDialect.Context |
Information for creating a dialect.
|
SqlDialect.ContextImpl |
Implementation of Context.
|
SqlDialect.DatabaseProduct |
Rough list of flavors of database.
|
SqlDialect.FakeUtil |
A few utility functions copied from org.apache.calcite.util.Util.
|
SqlDialectFactory |
Creates a SqlDialect appropriate
for a given database metadata object.
|
SqlDialectFactoryImpl |
The default implementation of a SqlDialectFactory .
|
SqlDotOperator |
The dot operator . , used to access a field of a
record.
|
SqlDrop |
Base class for an DROP statements parse tree nodes.
|
SqlDropFunction |
Parse tree for DROP FUNCTION statement.
|
SqlDropMaterializedView |
Parse tree for DROP MATERIALIZED VIEW statement.
|
SqlDropObject |
Base class for parse trees of DROP TABLE , DROP VIEW ,
DROP MATERIALIZED VIEW and DROP TYPE statements.
|
SqlDropSchema |
Parse tree for DROP TABLE statement.
|
SqlDropTable |
Parse tree for DROP TABLE statement.
|
SqlDropType |
Parse tree for DROP TYPE statement.
|
SqlDropView |
Parse tree for DROP VIEW statement.
|
SqlDynamicParam |
A SqlDynamicParam represents a dynamic parameter marker in an
SQL statement.
|
SqlExecutableStatement |
Mix-in interface for SqlNode that allows DDL commands to be
executed directly.
|
SqlExplain |
A SqlExplain is a node of a parse tree which represents an
EXPLAIN PLAN statement.
|
SqlExplain.Depth |
The level of abstraction with which to display the plan.
|
SqlExplainFormat |
Output format for EXPLAIN PLAN statement.
|
SqlExplainLevel |
SqlExplainLevel defines detail levels for EXPLAIN PLAN.
|
SqlExtendOperator |
EXTEND operator.
|
SqlExtractFunction |
The SQL EXTRACT operator.
|
SqlFilterOperator |
An operator that applies a filter before rows are included in an aggregate
function.
|
SqlFirstLastValueAggFunction |
FIRST_VALUE and LAST_VALUE aggregate functions
return the first or the last value in a list of values that are input to the
function.
|
SqlFloorFunction |
Definition of the "FLOOR" and "CEIL" built-in SQL functions.
|
SqlFormatOptions |
|
SqlFunction |
A SqlFunction is a type of operator which has conventional
function-call syntax.
|
SqlFunctionalOperator |
SqlFunctionalOperator is a base class for special operators which use
functional syntax.
|
SqlFunctionCategory |
Enumeration of the categories of
SQL-invoked routines.
|
SqlFunctionCategory.Property |
Property of a SqlFunctionCategory.
|
SqlFunctions |
Helper methods to implement SQL functions in generated code.
|
SqlFunctions.FlatProductInputType |
|
SqlFunctions.PathContext |
Returned path context of JsonApiCommonSyntax, public for testing.
|
SqlFunctions.PathMode |
Path spec has two different modes: lax mode and strict mode.
|
SqlFunctions.ProductComparableListEnumerator<E extends java.lang.Comparable> |
Enumerates over the cartesian product of the given lists, returning
a comparable list for each row.
|
SqlGroupedWindowFunction |
SQL function that computes keys by which rows can be partitioned and
aggregated.
|
SqlGroupIdFunction |
The GROUP_ID() function.
|
SqlGroupingFunction |
The GROUPING function.
|
SqlGroupingIdFunction |
Deprecated.
|
SqlHistogramAggFunction |
HISTOGRAM is the base operator that supports the Histogram
MIN/MAX aggregate functions.
|
SqlIdentifier |
A SqlIdentifier is an identifier, possibly compound.
|
SqlIdentifierMoniker |
|
SqlImplementor |
State for generating a SQL statement.
|
SqlImplementor.Clause |
Clauses in a SQL query.
|
SqlImplementor.Context |
Context for translating a RexNode expression (within a
RelNode ) into a SqlNode expression (within a SQL parse
tree).
|
SqlImplementor.SimpleContext |
|
SqlInfixOperator |
A generalization of a binary operator to involve several (two or more)
arguments, and keywords between each pair of arguments.
|
SqlInOperator |
Definition of the SQL IN operator, which tests for a value's
membership in a sub-query or a list of values.
|
SqlInsert |
A SqlInsert is a node of a parse tree which represents an INSERT
statement.
|
SqlInsertKeyword |
Defines the keywords that can occur immediately after the "INSERT" keyword.
|
SqlInternalOperator |
Generic operator for nodes with internal syntax.
|
SqlIntervalLiteral |
A SQL literal representing a time interval.
|
SqlIntervalLiteral.IntervalValue |
A Interval value.
|
SqlIntervalQualifier |
Represents an INTERVAL qualifier.
|
SqlItemOperator |
The item operator [ ... ] , used to access a given element of an
array or map.
|
SqlJdbcDataTypeName |
Defines the name of the types which can occur as a type argument
in a JDBC {fn CONVERT(value, type)} function.
|
SqlJdbcFunctionCall |
A SqlJdbcFunctionCall is a node of a parse tree which represents
a JDBC function call.
|
SqlJdbcFunctionCall.JdbcToInternalLookupTable |
Lookup table between JDBC functions and internal representation
|
SqlJdbcFunctionCall.MakeCall |
Converts a call to a JDBC function to a call to a regular function.
|
SqlJdbcFunctionCall.PermutingMakeCall |
|
SqlJdbcFunctionCall.SimpleMakeCall |
Converter that calls a built-in function with the same arguments.
|
SqlJoin |
Parse tree node representing a JOIN clause.
|
SqlJoin.SqlJoinOperator |
SqlJoinOperator describes the syntax of the SQL
JOIN operator.
|
SqlJsonApiCommonSyntaxOperator |
The JSON API common syntax including a path specification, which is for
JSON querying and processing.
|
SqlJsonArrayAggAggFunction |
The JSON_OBJECTAGG aggregate function.
|
SqlJsonArrayFunction |
The JSON_ARRAY function.
|
SqlJsonConstructorNullClause |
Indicating that how do Json constructors handle null
|
SqlJsonEmptyOrError |
Flag to indicate if the json value is missing or an error is thrown where
EmptyOrErrorBehavior is invoked.
|
SqlJsonEncoding |
Supported json encodings that could be passed to a
JsonValueExpression .
|
SqlJsonExistsErrorBehavior |
Categorizing Json exists error behaviors.
|
SqlJsonExistsFunction |
The JSON_EXISTS function.
|
SqlJsonObjectAggAggFunction |
The JSON_OBJECTAGG aggregate function.
|
SqlJsonObjectFunction |
The JSON_OBJECT function.
|
SqlJsonQueryEmptyOrErrorBehavior |
Categorizing Json query empty or error behaviors.
|
SqlJsonQueryFunction |
The JSON_QUERY function.
|
SqlJsonQueryWrapperBehavior |
How json query function handle array result.
|
SqlJsonValueEmptyOrErrorBehavior |
Categorizing Json value empty or error behaviors.
|
SqlJsonValueExpressionOperator |
The JSON value expression operator that indicates that the value expression
should be parsed as JSON.
|
SqlJsonValueFunction |
The JSON_VALUE function.
|
SqlKeyConstraint |
Parse tree for UNIQUE , PRIMARY KEY constraints.
|
SqlKind |
Enumerates the possible types of SqlNode .
|
SqlLateralOperator |
An operator describing a LATERAL specification.
|
SqlLatticeStatisticProvider |
Implementation of LatticeStatisticProvider that gets statistics by
executing "SELECT COUNT(DISTINCT ...) ..." SQL queries.
|
SqlLeadLagAggFunction |
LEAD and LAG aggregate functions
return the value of given expression evaluated at given offset.
|
SqlLikeOperator |
An operator describing the LIKE and SIMILAR
operators.
|
SqlLiteral |
A SqlLiteral is a constant.
|
SqlLiteral.SqlSymbol |
Deprecated. |
SqlLiteralChainOperator |
Internal operator, by which the parser represents a continued string literal.
|
SqlMapQueryConstructor |
Definition of the MAP query constructor,
MAP (<query>) .
|
SqlMapValueConstructor |
Definition of the MAP constructor,
MAP [<key>, <value>, ...] .
|
SqlMatchRecognize |
SqlNode for MATCH_RECOGNIZE clause.
|
SqlMatchRecognize.AfterOption |
Options for AFTER MATCH clause.
|
SqlMatchRecognize.RowsPerMatchOption |
Options for ROWS PER MATCH .
|
SqlMatchRecognize.SqlMatchRecognizeOperator |
An operator describing a MATCH_RECOGNIZE specification.
|
SqlMerge |
A SqlMerge is a node of a parse tree which represents a MERGE
statement.
|
SqlMinMaxAggFunction |
Definition of the MIN and MAX aggregate functions,
returning the returns the smallest/largest of the values which go into it.
|
SqlModality |
Relational or streaming.
|
SqlMoniker |
An interface of an object identifier that represents a SqlIdentifier
|
SqlMonikerImpl |
|
SqlMonikerType |
An enumeration of moniker types.
|
SqlMonotonicBinaryOperator |
Base class for binary operators such as addition, subtraction, and
multiplication which are monotonic for the patterns m op c and
c op m where m is any monotonic expression and c is a constant.
|
SqlMonotonicity |
Enumeration of types of monotonicity.
|
SqlMonotonicUnaryFunction |
Base class for unary operators such as FLOOR/CEIL which are monotonic for
monotonic inputs.
|
SqlMultisetMemberOfOperator |
Multiset MEMBER OF.
|
SqlMultisetQueryConstructor |
Definition of the SQL:2003 standard MULTISET query constructor,
MULTISET (<query>) .
|
SqlMultisetSetOperator |
An operator which performs set operations on multisets, such as "MULTISET
UNION ALL".
|
SqlMultisetValueConstructor |
Definition of the SQL:2003 standard MULTISET constructor, MULTISET
[<expr>, ...] .
|
SqlNameMatcher |
Checks whether two names are the same according to a case-sensitivity policy.
|
SqlNameMatchers |
|
SqlNameMatchers.BaseMatcher |
|
SqlNameMatchers.LiberalNameMatcher |
Matcher that remembers the requests that were made of it.
|
SqlNewOperator |
SqlNewOperator represents an SQL new specification such as
NEW UDT(1, 2) .
|
SqlNode |
A SqlNode is a SQL parse tree.
|
SqlNodeList |
A SqlNodeList is a list of SqlNode s.
|
SqlNodeToRexConverter |
|
SqlNodeToRexConverterImpl |
|
SqlNthValueAggFunction |
NTH_VALUE windowed aggregate function
returns the value of an expression evaluated at the n th row of the
window frame.
|
SqlNtileAggFunction |
NTILE aggregate function
return the value of given expression evaluated at given offset.
|
SqlNullifFunction |
The NULLIF function.
|
SqlNullSemantics |
SqlNullSemantics defines the possible comparison rules for values which might
be null.
|
SqlNumericLiteral |
A numeric SQL literal.
|
SqlOperandCountRange |
A class that describes how many operands an operator can take.
|
SqlOperandCountRanges |
|
SqlOperandCountRanges.RangeImpl |
|
SqlOperandTypeChecker |
Strategy interface to check for allowed operand types of an operator call.
|
SqlOperandTypeChecker.Consistency |
Strategy used to make arguments consistent.
|
SqlOperandTypeInference |
Strategy to infer unknown types of the operands of an operator call.
|
SqlOperator |
A SqlOperator is a type of node in a SQL parse tree (it is NOT a
node in a SQL parse tree).
|
SqlOperatorBinding |
SqlOperatorBinding represents the binding of an
SqlOperator to actual operands, along with any additional information
required to validate those operands if needed.
|
SqlOperatorTable |
SqlOperatorTable defines a directory interface for enumerating and looking up
SQL operators and functions.
|
SqlOrderBy |
Parse tree node that represents an ORDER BY on a query other than a
SELECT (e.g.
|
SqlOrderBy.Operator |
Definition of ORDER BY operator.
|
SqlOverlapsOperator |
SqlOverlapsOperator represents the SQL:1999 standard OVERLAPS
function.
|
SqlOverlayFunction |
The OVERLAY function.
|
SqlOverOperator |
An operator describing a window function specification.
|
SqlParseException |
SqlParseException defines a checked exception corresponding to
SqlParser .
|
SqlParser |
A SqlParser parses a SQL statement.
|
SqlParser.Config |
Interface to define the configuration for a SQL parser.
|
SqlParser.ConfigBuilder |
|
SqlParser.ConfigImpl |
|
SqlParserImplFactory |
|
SqlParserPos |
SqlParserPos represents the position of a parsed token within SQL statement
text.
|
SqlParserUtil |
Utility methods relating to parsing SQL.
|
SqlParserUtil.Format |
Pre-initialized DateFormat objects, to be used within the current
thread, because DateFormat is not thread-safe.
|
SqlParserUtil.OldTokenSequenceImpl |
|
SqlParserUtil.ParsedCollation |
The components of a collation definition, per the SQL standard.
|
SqlParserUtil.StringAndPos |
Contains a string, the offset of a token within the string, and a parser
position containing the beginning and end line number.
|
SqlParserUtil.TokenSequenceImpl |
|
SqlParserUtil.ToTreeListItem |
|
SqlPositionFunction |
The POSITION function.
|
SqlPostfixOperator |
A postfix unary operator.
|
SqlPrefixOperator |
A unary operator.
|
SqlPrettyWriter |
Pretty printer for SQL statements.
|
SqlPrettyWriter.Bean |
Helper class which exposes the get/set methods of an object as
properties.
|
SqlProcedureCallOperator |
SqlProcedureCallOperator represents the CALL statement.
|
SqlQualified |
Fully-qualified identifier.
|
SqlQuantifyOperator |
Definition of the SQL ALL and SOME operators.
|
SqlRandFunction |
The RAND function.
|
SqlRandIntegerFunction |
The RAND_INTEGER function.
|
SqlRankFunction |
Operator which aggregates sets of values into a result.
|
SqlRegrCountAggFunction |
Definition of the SQL REGR_COUNT aggregation function.
|
SqlReturnTypeInference |
Strategy interface to infer the type of an operator call from the type of the
operands.
|
SqlReturnTypeInferenceChain |
Strategy to infer the type of an operator call from the type of the operands
by using a series of SqlReturnTypeInference rules in a given order.
|
SqlRexContext |
|
SqlRexConvertlet |
|
SqlRexConvertletTable |
|
SqlRollupOperator |
Operator that appears in a GROUP BY clause: CUBE ,
ROLLUP , GROUPING SETS .
|
SqlRowOperator |
SqlRowOperator represents the special ROW constructor.
|
SqlSampleSpec |
Specification of a SQL sample.
|
SqlSampleSpec.SqlSubstitutionSampleSpec |
Sample specification that orders substitution.
|
SqlSampleSpec.SqlTableSampleSpec |
Sample specification.
|
SqlScopedShuttle |
Refinement to SqlShuttle which maintains a stack of scopes.
|
SqlSelect |
A SqlSelect is a node of a parse tree which represents a select
statement.
|
SqlSelectKeyword |
Defines the keywords which can occur immediately after the "SELECT" keyword.
|
SqlSelectOperator |
An operator describing a query.
|
SqlSequenceValueOperator |
Operator that returns the current or next value of a sequence.
|
SqlSetOperator |
SqlSetOperator represents a relational set theory operator (UNION, INTERSECT,
MINUS).
|
SqlSetOption |
SQL parse tree node to represent SET and RESET statements,
optionally preceded by ALTER SYSTEM or ALTER SESSION .
|
SqlShell |
Command that executes its arguments as a SQL query
against Calcite's OS adapter.
|
SqlShell.Format |
Output format.
|
SqlShuttle |
Basic implementation of SqlVisitor which returns each leaf node
unchanged.
|
SqlSimpleParser |
A simple parser that takes an incomplete and turn it into a syntactically
correct statement.
|
SqlSimpleParser.IdToken |
|
SqlSimpleParser.Query |
|
SqlSimpleParser.Token |
|
SqlSimpleParser.Tokenizer |
|
SqlSimpleParser.TokenType |
|
SqlSingleOperandTypeChecker |
SqlSingleOperandTypeChecker is an extension of SqlOperandTypeChecker
for implementations which are capable of checking the type of a single
operand in isolation.
|
SqlSingleValueAggFunction |
SINGLE_VALUE aggregate function returns the input value if there
is only one value in the input; Otherwise it triggers a run-time error.
|
SqlSpecialOperator |
Generic operator for nodes with special syntax.
|
SqlSpecialOperator.TokenSequence |
List of tokens: the input to a parser.
|
SqlSplittableAggFunction |
Aggregate function that can be split into partial aggregates.
|
SqlSplittableAggFunction.AbstractSumSplitter |
Common splitting strategy for SUM and SUM0 functions.
|
SqlSplittableAggFunction.CountSplitter |
Splitting strategy for COUNT .
|
SqlSplittableAggFunction.Registry<E> |
Collection in which one can register an element.
|
SqlSplittableAggFunction.SelfSplitter |
Aggregate function that splits into two applications of itself.
|
SqlSplittableAggFunction.Sum0Splitter |
Splitting strategy for SUM0 function.
|
SqlSplittableAggFunction.SumSplitter |
Splitting strategy for SUM function.
|
SqlStateCodes |
Deprecated.
|
SqlStatisticProvider |
Estimates row counts for tables and columns.
|
SqlStdOperatorTable |
Implementation of SqlOperatorTable containing
the standard operators and functions.
|
SqlString |
String that represents a kocher SQL statement, expression, or fragment.
|
SqlStringContextVariable |
Base class for string functions such as "USER", "CURRENT_ROLE", and
"CURRENT_PATH".
|
SqlSubstringFunction |
Definition of the "SUBSTRING" builtin SQL function.
|
SqlSumAggFunction |
Sum is an aggregator which returns the sum of the values which
go into it.
|
SqlSumEmptyIsZeroAggFunction |
Sum0 is an aggregator which returns the sum of the values which
go into it like Sum .
|
SqlSyntax |
Enumeration of possible syntactic types of operators .
|
SqlThrowOperator |
An internal operator that throws an exception.
|
SqlTimeLiteral |
A SQL literal representing a TIME value, for example TIME
'14:33:44.567' .
|
SqlTimeoutException |
Indicates that an operation timed out.
|
SqlTimestampAddFunction |
The TIMESTAMPADD function, which adds an interval to a
datetime (TIMESTAMP, TIME or DATE).
|
SqlTimestampDiffFunction |
The TIMESTAMPDIFF function, which calculates the difference
between two timestamps.
|
SqlTimestampLiteral |
A SQL literal representing a TIMESTAMP value, for example TIMESTAMP
'1969-07-21 03:15 GMT' .
|
SqlToRelConverter |
Converts a SQL parse tree (consisting of
SqlNode objects) into a relational algebra
expression (consisting of RelNode objects).
|
SqlToRelConverter.AggregateFinder |
Visitor that collects all aggregate functions in a SqlNode tree.
|
SqlToRelConverter.Config |
Interface to define the configuration for a SqlToRelConverter.
|
SqlToRelConverter.ConfigBuilder |
|
SqlToRelConverter.ConfigImpl |
|
SqlToRelConverter.CorrelationUse |
Use of a row as a correlating variable by a given relational
expression.
|
SqlToRelConverter.DeferredLookup |
Deferred lookup.
|
SqlToRelConverter.LookupContext |
Context to find a relational expression to a field offset.
|
SqlToRelConverter.SubQuery |
A sub-query, whether it needs to be translated using 2- or 3-valued
logic.
|
SqlTranslate3Function |
Definition of the "TRANSLATE" built-in SQL function that takes 3 arguments.
|
SqlTrimFunction |
Definition of the "TRIM" builtin SQL function.
|
SqlTrimFunction.Flag |
Defines the enumerated values "LEADING", "TRAILING", "BOTH".
|
SqlTypeAssignmentRules |
Rules that determine whether a type is assignable from another type.
|
SqlTypeAssignmentRules.Builder |
Keeps state while maps are building build.
|
SqlTypeExplicitPrecedenceList |
|
SqlTypeFactoryImpl |
SqlTypeFactoryImpl provides a default implementation of
RelDataTypeFactory which supports SQL types.
|
SqlTypeFactoryImpl.UnknownSqlType |
The unknown type.
|
SqlTypeFamily |
SqlTypeFamily provides SQL type categorization.
|
SqlTypeName |
Enumeration of the type names which can be used to construct a SQL type.
|
SqlTypeName.Limit |
Limit.
|
SqlTypeName.PrecScale |
Flags indicating precision/scale combinations.
|
SqlTypeTransform |
Strategy to transform one type to another.
|
SqlTypeTransformCascade |
|
SqlTypeTransforms |
|
SqlTypeUtil |
Contains utility methods used during SQL validation or type derivation.
|
SqlUnnestOperator |
The UNNEST operator.
|
SqlUnresolvedFunction |
Placeholder for an unresolved function.
|
SqlUpdate |
A SqlUpdate is a node of a parse tree which represents an UPDATE
statement.
|
SqlUserDefinedAggFunction |
User-defined aggregate function.
|
SqlUserDefinedFunction |
User-defined scalar function.
|
SqlUserDefinedTableFunction |
User-defined table function.
|
SqlUserDefinedTableMacro |
User-defined table macro.
|
SqlUserDefinedTableMacro.NonLiteralException |
Thrown when a non-literal occurs in an argument to a user-defined
table macro.
|
SqlUtil |
Contains utility functions related to SQL parsing, all static.
|
SqlUtil.DatabaseMetaDataInvocationHandler |
Handles particular DatabaseMetaData methods; invocations of other
methods will fall through to the base class,
BarfingInvocationHandler , which will throw
an error.
|
SqlUtil.Genealogist |
Walks over a SqlNode tree and returns the
ancestry stack when it finds a given node.
|
SqlValidator |
Validates the parse tree of a SQL statement, and provides semantic
information about the parse tree.
|
SqlValidatorCatalogReader |
|
SqlValidatorException |
Exception thrown while validating a SQL statement.
|
SqlValidatorImpl |
|
SqlValidatorImpl.DeleteNamespace |
Namespace for a DELETE statement.
|
SqlValidatorImpl.DmlNamespace |
Common base class for DML statement namespaces.
|
SqlValidatorImpl.Expander |
Converts an expression into canonical form by fully-qualifying any
identifiers.
|
SqlValidatorImpl.ExtendedExpander |
Shuttle which walks over an expression in the GROUP BY/HAVING clause, replacing
usages of aliases or ordinals with the underlying expression.
|
SqlValidatorImpl.FunctionParamInfo |
Utility object used to maintain information about the parameters in a
function call.
|
SqlValidatorImpl.IdInfo |
Information about an identifier in a particular scope.
|
SqlValidatorImpl.InsertNamespace |
Namespace for an INSERT statement.
|
SqlValidatorImpl.MergeNamespace |
Namespace for a MERGE statement.
|
SqlValidatorImpl.NavigationExpander |
Shuttle that expands navigation expressions in a MATCH_RECOGNIZE clause.
|
SqlValidatorImpl.NavigationModifier |
Modify the nodes in navigation function
such as FIRST, LAST, PREV AND NEXT.
|
SqlValidatorImpl.NavigationReplacer |
Shuttle that replaces A as A.price > PREV(B.price) with
PREV(A.price, 0) > LAST(B.price, 0) .
|
SqlValidatorImpl.Status |
Validation status.
|
SqlValidatorImpl.UpdateNamespace |
Namespace for an UPDATE statement.
|
SqlValidatorNamespace |
A namespace describes the relation returned by a section of a SQL query.
|
SqlValidatorScope |
Name-resolution scope.
|
SqlValidatorScope.EmptyPath |
A path that has no steps.
|
SqlValidatorScope.Path |
A sequence of steps by which an identifier was resolved.
|
SqlValidatorScope.Resolve |
A match found when looking up a name.
|
SqlValidatorScope.Resolved |
|
SqlValidatorScope.ResolvedImpl |
|
SqlValidatorScope.Step |
A step in resolving an identifier.
|
SqlValidatorTable |
|
SqlValidatorUtil |
Utility methods related to validation.
|
SqlValidatorUtil.DeepCopier |
Deprecated. |
SqlValidatorUtil.GroupAnalyzer |
Builds a list of GROUP BY expressions.
|
SqlValidatorUtil.Suggester |
Suggests candidates for unique names, given the number of attempts so far
and the number of expressions in the project list.
|
SqlValidatorWithHints |
Extends SqlValidator to allow discovery of useful data such as fully
qualified names of sql objects, alternative valid sql objects that can be
used in the SQL statement (dubbed as hints)
|
SqlValuesOperator |
The VALUES operator.
|
SqlVisitor<R> |
|
SqlWindow |
SQL window specification.
|
SqlWindow.Bound |
An enumeration of types of bounds in a window: CURRENT ROW ,
UNBOUNDED PRECEDING , and UNBOUNDED FOLLOWING .
|
SqlWindow.SqlWindowOperator |
An operator describing a window specification.
|
SqlWith |
The WITH clause of a query.
|
SqlWith.SqlWithOperator |
SqlWithOperator is used to represent a WITH clause of a query.
|
SqlWithinGroupOperator |
An operator that applies a sort operation before rows are included in an aggregate function.
|
SqlWithItem |
An item in a WITH clause of a query.
|
SqlWithItem.SqlWithItemOperator |
SqlWithItemOperator is used to represent an item in a WITH clause of a
query.
|
SqlWriter |
A SqlWriter is the target to construct a SQL statement from a
parse tree.
|
SqlWriter.Frame |
A Frame is a piece of generated text which shares a common indentation
level.
|
SqlWriter.FrameType |
Frame type.
|
SqlWriter.FrameTypeEnum |
Enumerates the types of frame.
|
SqlWriter.SubQueryStyle |
Style of formatting sub-queries.
|
Stacks |
Deprecated. |
StackWriter |
A helper class for generating formatted text.
|
StandardConvertletTable |
|
StandardConvertletTable.AvgVarianceConvertlet |
Convertlet that handles AVG and VARIANCE
windowed aggregate functions.
|
StandardConvertletTable.GreatestConvertlet |
Convertlet that converts GREATEST and LEAST .
|
StandardConvertletTable.RegrCovarianceConvertlet |
Convertlet that handles COVAR_POP , COVAR_SAMP ,
REGR_SXX , REGR_SYY windowed aggregate functions.
|
StandardConvertletTable.TimestampAddConvertlet |
Convertlet that handles the TIMESTAMPADD function.
|
StandardConvertletTable.TimestampDiffConvertlet |
Convertlet that handles the TIMESTAMPDIFF function.
|
StandardConvertletTable.TrimConvertlet |
Convertlet that converts LTRIM and RTRIM to
TRIM .
|
StarTable |
Virtual table that is composed of two or more tables joined together.
|
StarTable.StarTableScan |
Relational expression that scans a StarTable .
|
Statement |
Statement.
|
StatementTest |
Compares Statement vs PreparedStatement .
|
StatementTest.Department |
Department record.
|
StatementTest.Employee |
Employee record.
|
StatementTest.HrConnection |
Connection to be used during tests.
|
StatementTest.HrPreparedStatement |
Tests performance of reused execution of prepared statement.
|
StatementTest.HrSchema |
Pojo schema containing "emps" and "depts" tables.
|
Static |
Definitions of objects to be statically imported.
|
Statistic |
Statistics about a Table .
|
Statistics |
|
StdinTableFunction |
Table function that reads stdin and returns one row per line.
|
Step |
Edge in the join graph.
|
Step.Factory |
|
StreamableTable |
Table that can be converted to a stream.
|
StreamRules |
Rules and relational operators for streaming relational expressions.
|
StreamRules.DeltaAggregateTransposeRule |
|
StreamRules.DeltaFilterTransposeRule |
|
StreamRules.DeltaJoinTransposeRule |
Planner rule that pushes a Delta through a Join .
|
StreamRules.DeltaProjectTransposeRule |
|
StreamRules.DeltaSortTransposeRule |
Planner rule that pushes a Delta through an Sort .
|
StreamRules.DeltaTableScanRule |
|
StreamRules.DeltaTableScanToEmptyRule |
|
StreamRules.DeltaUnionTransposeRule |
Planner rule that pushes a Delta through an Union .
|
Strict |
Annotation applied to a user-defined function that indicates that
the function returns null if and only if one or more of its arguments
are null.
|
StrictAggImplementor |
The base implementation of strict aggregate function.
|
StrictWinAggImplementor |
The base implementation of strict window aggregate function.
|
StringConcatFunction |
Example query for checking query projections
|
StringUtils |
Utility methods for encoding and decoding strings for Splunk REST calls.
|
Strong |
Utilities for strong predicates.
|
Strong.Policy |
How whether an operator's operands are null affects whether a call to
that operator evaluates to null.
|
StructKind |
Describes a policy for resolving fields in record types.
|
SubQueryConverter |
SubQueryConverter provides the interface for classes that convert sub-queries
into equivalent expressions.
|
SubQueryRemoveRule |
Transform that converts IN, EXISTS and scalar sub-queries into joins.
|
SubQueryRemoveRule.ReplaceSubQueryShuttle |
Shuttle that replaces occurrences of a given
RexSubQuery with a replacement
expression.
|
SubQueryRemoveRule.SubQueryFilterRemoveRule |
Rule that converts a sub-queries from filter expressions into
Correlate instances.
|
SubQueryRemoveRule.SubQueryJoinRemoveRule |
Rule that converts sub-queries from join expressions into
Correlate instances.
|
SubQueryRemoveRule.SubQueryProjectRemoveRule |
Rule that converts sub-queries from project expressions into
Correlate instances.
|
SubstitutionVisitor |
Substitutes part of a tree of relational expressions with another tree.
|
SubstitutionVisitor.AbstractUnifyRule |
|
SubstitutionVisitor.AggregateOnProjectToAggregateUnifyRule |
|
SubstitutionVisitor.AggregateToAggregateUnifyRule |
|
SubstitutionVisitor.AnyOperand |
|
SubstitutionVisitor.FilterOnProjectRule |
|
SubstitutionVisitor.FilterToFilterUnifyRule |
|
SubstitutionVisitor.FilterToProjectUnifyRule |
|
SubstitutionVisitor.InternalOperand |
|
SubstitutionVisitor.MatchFailed |
Exception thrown to exit a matcher.
|
SubstitutionVisitor.Operand |
|
SubstitutionVisitor.ProjectToFilterUnifyRule |
|
SubstitutionVisitor.ProjectToProjectUnifyRule |
|
SubstitutionVisitor.QueryOperand |
Operand that assigns a particular relational expression to a variable.
|
SubstitutionVisitor.Replacement |
Represents a replacement action: before → after.
|
SubstitutionVisitor.ScanToProjectUnifyRule |
|
SubstitutionVisitor.SlotCounter |
|
SubstitutionVisitor.TargetOperand |
|
SubstitutionVisitor.TrivialRule |
|
SubstitutionVisitor.UnifyResult |
Result of an application of a SubstitutionVisitor.UnifyRule indicating that the
rule successfully matched query against target and
generated a result that is equivalent to query and
contains target .
|
SubstitutionVisitor.UnifyRule |
Rule that attempts to match a query relational expression
against a target relational expression.
|
SubstringOperatorConversion |
Converts Calcite SUBSTRING call to Druid Expression when possible
|
SwitchCase |
|
SwitchStatement |
Represents a control expression that handles multiple selections by passing
control to SwitchCase .
|
SybaseSqlDialect |
A SqlDialect implementation for the Sybase database.
|
Table |
Table.
|
TableAccessMap |
TableAccessMap represents the tables accessed by a query plan,
with READ/WRITE information.
|
TableAccessMap.Mode |
Access mode.
|
TableConstructorNamespace |
Namespace for a table constructor VALUES (expr, expr, ...) .
|
TableFactory<T extends Table> |
Factory for Table objects.
|
TableFunction |
Function that returns a table during execution time.
|
TableFunctionImpl |
|
TableFunctionReturnTypeInference |
TableFunctionReturnTypeInference implements rules for deriving table function
output row types by expanding references to cursor parameters.
|
TableFunctionScan |
Relational expression that calls a table-valued function.
|
TableMacro |
Function that returns a Table .
|
TableMacroImpl |
|
TableModify |
Relational expression that modifies a table.
|
TableModify.Operation |
Enumeration of supported modification operations.
|
TableNamespace |
Namespace based on a table from the catalog.
|
TableScan |
Relational operator that returns the contents of a table.
|
TableScanNode |
Interpreter node that implements a
TableScan .
|
TableScanRule |
|
TableScope |
The name-resolution scope of a LATERAL TABLE clause.
|
Template |
String template.
|
TeradataSqlDialect |
A SqlDialect implementation for the Teradata database.
|
TernaryExpression |
Represents an expression that has a ternary operator.
|
ThrowStatement |
Represents a throw statement.
|
TileKey |
Definition of a particular combination of dimensions and measures of a
lattice that is the basis of a materialization.
|
TileSuggester |
Algorithm that suggests a set of initial tiles (materialized aggregate views)
for a given lattice.
|
TileSuggester.AttributeImpl |
|
TileSuggester.SchemaImpl |
Implementation of Schema based on a Lattice .
|
TileSuggester.StatisticsProviderImpl |
Implementation of StatisticsProvider
that asks the lattice.
|
TileSuggester.TableImpl |
Implementation of Table based on a Lattice .
|
TimeExtractionFunction |
Implementation of Druid time format extraction function.
|
TimestampString |
Timestamp literal.
|
TimestampWithTimeZoneString |
Timestamp with time-zone literal.
|
TimeString |
Time literal.
|
TimeWithTimeZoneString |
Time with time-zone literal.
|
TopologicalOrderIterator<V,E extends DefaultEdge> |
Iterates over the edges of a graph in topological order.
|
TpcdsSchema |
Schema that provides TPC-DS tables, populated according to a
particular scale factor.
|
TpcdsSchemaFactory |
|
TpchSchema |
Schema that provides TPC-H tables, populated according to a
particular scale factor.
|
TpchSchemaFactory |
|
TraitMatchingRule |
TraitMatchingRule adapts a converter rule, restricting it to fire only when
its input already matches the expected output trait.
|
TransformedEnumerator<F,E> |
Enumerator that applies a transform to each value from a backing
enumerator.
|
TranslatableTable |
|
TrustAllSslSocketFactory |
Socket factory that trusts all SSL connections.
|
TrustAllSslSocketFactory.DummyTrustManager |
Implementation of X509TrustManager that trusts all
certificates.
|
TryStatement |
Represents a try ... catch ... finally block.
|
TryThreadLocal<T> |
Thread-local variable that returns a handle that can be closed.
|
TryThreadLocal.Memo |
Remembers to set the value back.
|
TypeBinaryExpression |
Represents an operation between an expression and a type.
|
Typed |
|
Types |
Utilities for converting between Expression , Type and
Class .
|
Types.ArrayType |
Array type.
|
Types.MapType |
Map type.
|
Types.ParameterizedTypeImpl |
Implementation of ParameterizedType .
|
Types.RecordField |
Field that belongs to a record.
|
Types.RecordType |
Base class for record-like types that do not mapped to (currently
loaded) Java Class objects.
|
UnaryExpression |
Represents an expression that has a unary operator.
|
UnaryPrefixOperatorConversion |
Unary prefix Operator conversion class used to convert expression like Unary NOT and Minus
|
UnarySuffixOperatorConversion |
Unary suffix operator conversion, used to convert function like: expression Unary_Operator
|
UnboundMetadata<M extends Metadata> |
|
Uncollect |
Relational expression that unnests its input's columns into a relation.
|
Union |
Relational expression that returns the union of the rows of its inputs,
optionally eliminating duplicates.
|
UnionEliminatorRule |
UnionEliminatorRule checks to see if its possible to optimize a
Union call by eliminating the Union operator altogether in the case the call
consists of only one input.
|
UnionMergeRule |
UnionMergeRule implements the rule for combining two
non-distinct SetOp s
into a single SetOp .
|
UnionNode |
Interpreter node that implements a
Union .
|
UnionPullUpConstantsRule |
Planner rule that pulls up constants through a Union operator.
|
UnionToDistinctRule |
Planner rule that translates a distinct
Union
( all = false )
into an Aggregate
on top of a non-distinct Union
( all = true ).
|
Unit |
Synthetic record with zero fields.
|
UnmodifiableArrayList<E> |
A view onto an array that cannot be modified by the client.
|
UnnestNamespace |
Namespace for UNNEST.
|
Unsafe |
|
Util |
Miscellaneous utility functions.
|
Util.FilteringIterator<T> |
Iterator that applies a predicate to each element.
|
Util.FoundOne |
Exception used to interrupt a tree walk of any kind.
|
Util.OverFinder |
Visitor which looks for an OVER clause inside a tree of
SqlNode objects.
|
Util.RandomAccessTransformingList<F,T> |
|
Util.TransformingList<F,T> |
List that returns the same number of elements as a backing list,
applying a transformation function to each one.
|
Utilities |
Utility methods called by generated code.
|
ValidationException |
An Exception thrown when attempting to validate a SQL parse tree.
|
Values |
Relational expression whose value is a sequence of zero or more literal row
values.
|
ValuesNode |
Interpreter node that implements a
Values .
|
ValuesReduceRule |
Planner rule that folds projections and filters into an underlying
LogicalValues .
|
ValuesReduceRule.MyRexShuttle |
Shuttle that converts inputs to literals.
|
VerticaSqlDialect |
A SqlDialect implementation for the Vertica database.
|
ViewExpanders |
|
ViewTable |
Table whose contents are defined using an SQL statement.
|
ViewTableMacro |
Table function that implements a view.
|
VirtualColumn |
Druid Json Expression based Virtual Column.
|
VirtualColumn.Builder |
Virtual Column Builder
|
Visitor<R> |
Node visitor.
|
VisitorDataContext |
DataContext for evaluating an RexExpression
|
VisitorImpl<R> |
Default implementation of Visitor , which traverses a tree but does
nothing.
|
VmstatTableFunction |
Table function that executes the OS "vmstat" command
to share memory statistics.
|
VolcanoCost |
VolcanoCost represents the cost of a plan node.
|
VolcanoCost.Factory |
|
VolcanoPlanner |
VolcanoPlanner optimizes queries by transforming expressions selectively
according to a dynamic programming algorithm.
|
VolcanoPlanner.DeferringRuleCall |
A rule call which defers its actions.
|
VolcanoPlanner.DirectProvenance |
A RelNode that came directly from another RelNode via a copy.
|
VolcanoPlanner.Provenance |
Where a RelNode came from.
|
VolcanoPlanner.RuleProvenance |
A RelNode that came via the firing of a rule.
|
VolcanoPlanner.UnknownProvenance |
We do not know where this RelNode came from.
|
VolcanoPlannerPhase |
VolcanoPlannerPhase represents the phases of operation that the
VolcanoPlanner passes through during optimization of a tree of
RelNode objects.
|
VolcanoPlannerPhaseRuleMappingInitializer |
VolcanoPlannerPhaseRuleMappingInitializer describes an inteface for
initializing the mapping of VolcanoPlannerPhase s to sets of rule
descriptions.
|
VolcanoRelMetadataProvider |
VolcanoRelMetadataProvider implements the RelMetadataProvider
interface by combining metadata from the rels making up an equivalence class.
|
VolcanoRuleCall |
VolcanoRuleCall implements the RelOptRuleCall interface
for VolcanoPlanner.
|
VolcanoRuleMatch |
A match of a rule to a particular set of target relational expressions,
frozen in time.
|
WhileStatement |
Represents a "while" statement.
|
WinAggAddContext |
|
WinAggAddContextImpl |
|
WinAggContext |
Marker interface to allow
AggImplementor
to tell if it is used in regular or windowed context.
|
WinAggFrameContext |
Provides information on the current window.
|
WinAggFrameResultContext |
Provides information on the current window when computing the result of
the aggregation.
|
WinAggImplementor |
Implements a windowed aggregate function by generating expressions to
initialize, add to, and get a result from, an accumulator.
|
WinAggImplementor.SeekType |
Allows to access rows in window partition relative to first/last and
current row.
|
WinAggResetContext |
|
WinAggResetContextImpl |
|
WinAggResultContext |
|
WinAggResultContextImpl |
|
Window |
A relational expression representing a set of window aggregates.
|
Window.Group |
Group of windowed aggregate calls that have the same window specification.
|
Window.RexWinAggCall |
A call to a windowed aggregate function.
|
WindowNode |
Interpreter node that implements a
Window .
|
WithItemNamespace |
|
WithNamespace |
Namespace for WITH clause.
|
WithScope |
Scope providing the objects that are available after evaluating an item
in a WITH clause.
|
Wrapper |
Mix-in interface that allows you to find sub-objects.
|
XmlOutput |
Streaming XML output.
|
XmlOutput.StringEscaper |
Utility for replacing special characters
with escape sequences in strings.
|
XmlOutput.XMLAttrVector |
List of attribute names and values.
|