All Classes and Interfaces
Class
Description
Converts a relational expression to any given output convention.
Rule that converts an
AbstractConverter into a chain of
converters from the source relation to the target traits.Rule configuration.
Abstract implementation of the
Enumerable interface that
implements the extension methods.Abstract implementation of the
Enumerable
interface that implements the extension methods.Rule configuration.
Abstract base class for implementations of
ModifiableTable.Abstract base class for implementations of
ModifiableView.Abstract implementation of
Node.Abstract implementation of the
Queryable interface that implements
the extension methods.Abstract base class for implementing
Table.Base class for every relational expression (
RelNode).Abstract base for implementations of the
RelOptPlanner interface.Abstract implementation of
Schema.Schema factory that creates an
AbstractSchema.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.Abstract implementation of
SqlTester
that talks to a mock catalog.Abstract base class for SQL implementations of
RelDataType.Abstract base class for implementing
Table.Abstract implementation of
Queryable for
QueryableTable.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.Base class for all the type coercion rules.
A
SqlDialect implementation for the Access database.Used at run time by the ST_Accum function.
Geometry editor operation that adds a point to a geometry.
Operation that adds a z value to a geometry.
Information for a call to
AggImplementor.implementAdd(AggContext, AggAddContext).Implementation of
AggAddContext.Information on the aggregate calculation context.
Implements an aggregate function by generating expressions to
initialize, add to, and get a result from, an accumulator.
Represents internal state when implementing aggregate functions.
Relational operator that eliminates
duplicates and computes totals.
Implementation of the
SqlOperatorBinding interface for an
aggregate call applied to a set of operands in the
context of a LogicalAggregate.Describes the kind of roll-up.
Used for PERCENTILE_DISC return type inference.
Call to an aggregate function within an
Aggregate.Rule that converts CASE-style filtered aggregates into true filtered
aggregates.
Rule configuration.
Planner rule that expands distinct aggregates
(such as
COUNT(DISTINCT x)) from a
Aggregate.Rule configuration.
Planner rule that rewrites an
Aggregate that contains
WITHIN DISTINCT aggregate functions.Rule configuration.
Rule configuration.
Rule configuration.
Function that combines several values into a scalar result.
Implementation of
AggregateFunction via user-defined class.Rule configuration.
Rule configuration.
Rule configuration.
Generates lambda functions used in
EnumerableAggregate.Rule configuration.
Interpreter node that implements an
Aggregate.Implementation of
SUM over BigDecimal values as a user-defined
aggregate.Implementation of
SUM over DOUBLE values as a user-defined
aggregate.Implementation of
SUM over INTEGER values as a user-defined
aggregate.Implementation of
SUM over BIGINT values as a user-defined
aggregate.Implementation of
MAX function to calculate the maximum of
BigDecimal values as a user-defined aggregate.Implementation of
MAX function to calculate the maximum of
boolean values as a user-defined aggregate.Implementation of
MAX function to calculate the maximum of
double and real values as a user-defined aggregate.Implementation of
MAX function to calculate the maximum of
float values as a user-defined aggregate.Implementation of
MAX function to calculate the maximum of
integer values as a user-defined aggregate.Implementation of
MAX function to calculate the maximum of
long values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
BigDecimal values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
boolean values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
double and real values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
float values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
integer values as a user-defined aggregate.Implementation of
MIN function to calculate the minimum of
long values as a user-defined aggregate.Common implementation of comparison aggregate methods over numeric
values as a user-defined aggregate.
Rule configuration.
Rule configuration.
Planner rule that removes constant keys from an
Aggregate.Rule configuration.
Variant of
AggregateStarTableRule that accepts a Project
between the Aggregate and its StarTable.StarTableScan
input.Rule configuration.
Planner rule that reduces aggregate functions in
Aggregates to simpler forms.Rule configuration.
Planner rule that removes
a
Aggregate
if it computes no aggregate functions
(that is, it is implementing SELECT DISTINCT),
or all the aggregate functions are splittable,
and the underlying relational expression is already distinct.Rule configuration.
Planner rule that matches an
Aggregate on
top of a StarTable.StarTableScan.Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
An extension to the
SqlValidatorScope interface which indicates that
the scope is aggregating.Scope for resolving identifiers within a SELECT statement that has a
GROUP BY clause.
Information about an aggregating scope that can only be determined
after validation has occurred.
Information for a call to
AggImplementor.implementReset(AggContext, AggResetContext).Implementation of
AggResetContext.Information for a call to
AggImplementor.implementResult(AggContext, AggResultContext)Implementation of
AggResultContext.Namespace for an
AS t(c1, c2, ...) clause.The date/time format compiled component for AM/PM (first or second half of day).
The date/time format component for AM/PM (first or second half of day).
Defines the keywords that can occur immediately after the "ROLLBACK" or "COMMIT" keywords.
A
SqlDialect implementation for an unknown ANSI compatible database.Annotation that indicates that a field is an array type.
Extension to
Bindable that returns rows that are arrays of objects.Compares arrays.
Parameter type-checking strategy where types must be Array and Array element type.
Parameter type checking strategy, where the operand size is 3, and the first type is array,
the second type is integer, and the third type is the component type of the first array (
strictly matched without leastRestrictive conversion).
Length field of a RecordType.
SQL array type.
Relational expression that uses the Arrow calling convention.
Callback for the implementation process that converts a tree of
ArrowRel nodes into a SQL query.Planner rules relating to the Arrow adapter.
Rule to convert a
Filter to an
ArrowFilter.Rule configuration.
Planner rule that projects from an
ArrowTableScan just the columns
needed to satisfy a projection.Factory that creates an
ArrowSchema.Arrow Table.
Base class for various ASOF JOIN representations.
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").Abstract syntax tree.
Abstract base class for statements that assign to a named relation.
Abstract base class for an assignment with one source relation.
Parse tree for a bag type.
Parse tree node for a call to a function or operator.
Parse tree node for DESCRIBE statement.
Sort direction.
Parse tree node for DISTINCT statement.
Parse tree node for DUMP statement.
Parse tree for field schema.
Parse tree node for FILTER statement.
Parse tree node for FOREACH statement (nested).
Parse tree node for FOREACH statement (non-nested).
Parse tree node for GROUP statement.
Parse tree node for Identifier.
Parse tree node for LIMIT statement.
Parse tree node for Literal.
Parse tree node for LOAD statement.
Parse tree for a map type.
Abstract base class for parse tree node.
Parse tree node for NumericLiteral.
Parse tree node type.
Parse tree node for ORDER statement.
Parse tree node for a program.
Parse tree for scalar type such as
int.Parse tree for schema.
Parse tree node for "*", a special kind of identifier.
Abstract base class for parse tree node representing a statement.
Parse tree for a tuple type.
Parse tree for type.
Parse tree node for VALUES statement.
Directed graph where edges have attributes and allows multiple edges between
any two vertices provided that their attributes are different.
Factory for edges that have attributes.
A nondeterministic finite-state automaton (NFA).
Builds a state-transition graph for deterministic finite automaton.
Converts an expression for a group window function (e.g.
Simple implementation of
AuxiliaryConverter.A class derived from
BarfingInvocationHandler handles a method
call by looking for a method in itself with identical parameters.Base table for the Orders table.
Skeleton implementation of
Queryable.Implementation of
AggregateLambdaFactory that applies a sequence of
accumulator adders to input source.Performs accumulation against a pre-collected list of input sources,
used with
LazyAggregateLambdaFactory.BasicSqlType represents a standard atomic SQL type (excluding interval
types).
The date/time format compiled component for BC/AD (era, ie.
The date/time format component for BC/AD (era, ie.
Helps to run benchmarks by running the same task repeatedly and averaging
the running times.
Collects statistics for a test that is run multiple times.
Function that takes one parameter and returns a
BigDecimal value.A
SqlDialect implementation for Google BigQuery's "Standard SQL"
dialect.Represents an expression that has a binary operator.
Binary operator conversion utility class; used to convert expressions like
exp1 Operator exp2.Binary search for the implementation of
RANGE BETWEEN XXX PRECEDING/FOLLOWING clause.
Statement that can be bound to a
DataContext and then executed.Calling convention that returns results as an
Enumerable of object arrays.Relational expression that can implement itself in Bindable
convention.
Utilities pertaining to
BindableRel and BindableConvention.Implementation of
Aggregate
in bindable calling convention.Rule that converts an
Aggregate to bindable convention.Implementation of
Filter
in bindable convention.Rule that converts a
Filter to bindable convention.Implementation of
Intersect in
bindable calling convention.Implementation of
Join in
bindable calling convention.Rule to convert a
LogicalJoin
to a Bindables.BindableJoin.Implementation of
Match
in bindable convention.Rule to convert a
LogicalMatch
to a Bindables.BindableMatch.Implementation of
Minus in
bindable calling convention.Implementation of
Project in
bindable calling convention.Rule to convert a
LogicalProject
to a Bindables.BindableProject.Rule to convert an
SetOp to a Bindables.BindableUnion
or Bindables.BindableIntersect or Bindables.BindableMinus.Implementation of
Sort
bindable calling convention.Rule to convert an
Sort to a
Bindables.BindableSort.Scan of a table that implements
ScannableTable and therefore can
be converted into an Enumerable.Rule that converts a
TableScan
to bindable convention.Rule configuration.
Implementation of
Union in
bindable calling convention.Implementation of
Values
in bindable calling convention.Rule that converts a
Values to bindable convention.Implementation of
Window
in bindable convention.Rule to convert a
LogicalWindow
to a Bindables.BindableWindow.Abstract base class for relational expressions with a two inputs.
Utility functions for
BitSet.String of bits.
Builder for
BlockStatement.Helper methods concerning
BlockStatements.Represents a block that contains a sequence of expressions where variables
can be defined.
A Schema representing a bookstore.
Author.
Book.
Coordinate.
Page.
Place.
Iterates over the vertices in a directed graph in breadth-first order.
A parser for buffer styles as defined by PostGIS.
Holder for a list of constants describing which bugs which have not been
fixed.
Contains the interfaces for several common forms of metadata.
Metadata about the predicates that hold in the rows emitted from a
relational expression.
Handler API.
Metadata about which columns are sorted.
Handler API.
Metadata about the origins of columns.
Handler API.
Metadata about whether a set of columns uniquely identifies a row.
Handler API.
Metadata about the cost of evaluating a relational expression, including
all of its inputs.
Handler API.
Metadata about the number of distinct rows returned by a set of columns
in a relational expression.
Handler API.
Metadata about how a relational expression is distributed.
Handler API.
Metadata about whether a relational expression should appear in a plan.
Handler API.
Metadata about the origins of expressions.
Handler API.
Metadata to get the lower bound cost of a RelNode.
Handler API.
Metadata about the maximum number of rows returned by a relational
expression.
Handler API.
Metadata about whether a column is a measure and, if so, what is the
expression to evaluate that measure in the current context.
Context for a use of a measure at a call site.
Handler API.
Metadata about the memory use of an operator.
Handler API.
Metadata about the minimum number of rows returned by a relational
expression.
Handler API.
Metadata about the node types in a relational expression.
Handler API.
Metadata about the cost of evaluating a relational expression, not
including its inputs.
Handler API.
Metadata about the degree of parallelism of a relational expression, and
how its operators are assigned to processes with independent resource
pools.
Handler API.
Metadata about the proportion of original rows that remain in a relational
expression.
Handler API.
Metadata about the number of distinct values in the original source of a
column or set of columns.
Handler API.
Metadata about the predicates that hold in the rows emitted from a
relational expression.
Handler API.
Metadata about the number of rows returned by a relational expression.
Handler API.
Metadata about the selectivity of a predicate.
Handler API.
Metadata about the size of rows and columns.
Handler API.
Metadata to obtain references to tables used by a given expression.
Handler API.
Metadata about which combinations of columns are unique identifiers.
Handler API.
Built-in methods.
Functions used by generated code.
Deprecated.
Implementation of
SqlStatisticProvider that reads and writes a
cache.Calc is an abstract base class for implementations of
LogicalCalc.Fluid DSL for testing Calcite connections and queries.
Fluent interface for building a metadata query to be tested.
Fluent interface for building a query to be tested.
Result of calling
CalciteAssert.that().Connection configuration.
Connection post-processor.
Information necessary to create a JDBC connection.
We want a consumer that can throw SqlException.
Specification for common test schemas.
Implementation of
Prepare.CatalogReader
and also SqlOperatorTable based on tables and
functions defined schemas.Extension to Calcite's implementation of
JDBC connection allows schemas to be defined
dynamically.Interface for reading connection properties within Calcite code.
Implementation of
CalciteConnectionConfig.Properties that may be specified on the JDBC connect string.
Provider of calcite connections for end-to-end tests.
Exception which contains information about the textual context of the causing
exception.
Base class for all exceptions originating from Farrago.
Extension of
AvaticaFactory
for Calcite.Annotation to be used to convert interfaces/abstract classes into
Immutable POJO using Immutables package.
Implementation of
AvaticaFactory
for Calcite and JDBC 4.1 (corresponds to JDK 1.7).Small extension to
Logger with some performance improvements.Factory for creating instances of
MetaImpl.MetaColumn.Default implementation of CalciteMetaColumnFactoryImpl.
Helper for implementing the
getXxx methods such as
AvaticaDatabaseMetaData.getTables(java.lang.String, java.lang.String, java.lang.String, java.lang.String[]).Metadata describing a Calcite table.
Factory for creating instances of
MetaImpl.MetaTable.Default implementation of CalciteMetaTableFactory.
Tagging interface to allow a
SqlParseException
to be identified without adding a
dependency on it from client-side code.API for a service that prepares statements for execution.
The result of analyzing a view.
The result of preparing a query.
Context for preparing a statement.
The result of parsing and validating a SQL query and converting it to
relational algebra.
Namespace that allows us to define non-abstract methods inside an
interface.
The result of parsing and validating a SQL query.
Callback to register Spark as the main engine.
Allows Spark to declare the rules it needs.
Shit just got real.
Holds state for the process of preparing a SQL statement.
Compiler-checked resources for the Calcite project.
Implementation of
ResultSet
for the Calcite engine.Deprecated.
Schema.
Entry in a schema, such as a table or sub-schema.
Membership of a function in a schema.
Implementation of
CalciteSchema.FunctionEntry
where all properties are held in fields.Membership of a lattice in a schema.
Implementation of
CalciteSchema.LatticeEntry
where all properties are held in fields.Membership of a table in a schema.
Implementation of
CalciteSchema.TableEntry
where all properties are held in fields.Membership of a type in a schema.
Implementation of
CalciteSchema.TypeEntry
where all properties are held in fields.Server.
Statement within a Calcite server.
A
SqlDialect implementation that produces SQL that can be parsed
by Apache Calcite.Validator.
Implementation of
Statement
for the Calcite engine.A Calcite specific system property that is used to configure various aspects of the framework.
CalciteTimingTracer provides a mechanism for tracing the timing of a call
sequence at nanosecond resolution.
Contains all of the
tracers used within
org.apache.calcite class libraries.Tagging interface to allow a
SqlValidatorException
to be identified without
adding a dependency on it from client-side code.Rule configuration.
Type of relational expression.
Planner rule that removes a trivial
LogicalCalc.Rule configuration.
Rule configuration.
Implements a call via given translator.
Creates a
DynamicExpression that represents a dynamic operation bound
by the provided CallSiteBinder.CancelFlag is used to post and check cancellation requests.
Casing styles that can be applied to a string.
Enumerator over the cartesian product of enumerators.
Implementation of a
Filter
relational expression in Cassandra.Implementation of limits in Cassandra.
Builtin methods in the Cassandra adapter.
Implementation of
Project
relational expression in Cassandra.Relational expression that uses Cassandra calling convention.
Callback for the implementation process that converts a tree of
CassandraRel nodes into a CQL query.Rules and relational operators for
CassandraRel.CONVENTION
calling convention.Rule to convert a
LogicalFilter to a
CassandraFilter.Rule configuration.
Deprecated.
Rule to convert a
EnumerableLimit to a
CassandraLimit.Rule configuration.
Deprecated.
Rule to convert a
LogicalProject
to a CassandraProject.Rule to convert a
Sort to a
CassandraSort.Rule configuration.
Deprecated.
Schema mapped onto a Cassandra column family.
Factory that creates a
CassandraSchema.Implementation of
Sort
relational expression in Cassandra.Table based on a Cassandra column family.
Implementation of
Queryable based on
a CassandraTable.Relational expression representing a scan of a Cassandra collection.
Relational expression representing a scan of a table in a Cassandra data source.
Rule to convert a relational expression from
CassandraRel.CONVENTION to EnumerableConvention.Converts a list whose members are automatically down-cast to a given type.
Object whose fields are relations.
All field are private, therefore the resulting record has no fields.
Table that has a field that cannot be recognized as a SQL type.
Record that has a field of every interesting type.
Table that has integer and string fields.
Custom java class that holds just a single field.
Represents a catch statement in a try block.
DruidSqlOperatorConverter implementation that handles Ceil operations
conversions.
Implementation of the
RelMetadataProvider
interface via the
Glossary.CHAIN_OF_RESPONSIBILITY_PATTERN.ChainedSqlOperatorTable implements the
SqlOperatorTable interface by
chaining together any number of underlying operator table instances.Styles of character literal.
Relational operator that converts a stream to a relation.
Wrapping Calcite engine with Avatica tansport for testing JDBC capabilities
between Avatica JDBC transport and Calcite.
Factory for Chinook Calcite database wrapped in meta for Avatica.
Factory for Chinook Calcite database wrapped in meta for Avatica.
Example UDF for WHERE clause to check pushing to JDBC.
A component of a datetime.
Implementation of list similar to
LinkedList, but stores elements
in chunks of 32 elements.Declaration of a class.
Entry point for optimizers that factor out deterministic expressions to
final static fields.
A
SqlDialect implementation for the ClickHouse database.Schema that contains in-memory copies of tables from a JDBC schema.
Schema factory that creates a
CloneSchema.Helper that holds onto
AutoCloseable resources and releases them
when its #close method is called.Example Table Function for lateral join checks.
CoerceInputsRule pre-casts inputs to a particular type.
Rule configuration.
A relational expression that collapses multiple rows into one.
Namespace for COLLECT and TABLE constructs.
Interpreter node that implements a
Collect.Used at run time by the ST_Collect function.
Describes how a column gets populated.
Mappings from
innodb-java-reader column types
to corresponding SQL types.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.Rule configuration.
Type checking strategy which verifies that types have the required attributes
to be used as arguments to comparison operators.
Compatibility layer.
Compatibility layer.
Creates an implementation of
Compatible suitable for the current environment.Creates the implementation of Compatible suitable for the
current environment.
Contains a parsed date/time format.
A single component of a parsed date/time format.
A single date/time format compiled component such as "YYYY" or "MI".
Context while converting a tree of
RelNode to a program
that can be run by an Interpreter.Stores information about available complex metrics in the Druid Adapter.
A
HintPredicate to combine multiple hint predicates into one.How hint predicates are composed.
Read-only list that is the concatenation of sub-lists.
Unmodifiable view onto multiple backing maps.
This class allows multiple existing
SqlOperandTypeChecker rules to be
combined into one rule.How operands are composed.
Allows multiple
SqlSingleOperandTypeChecker rules to be
combined into one rule.A collection of functions used in compression and decompression.
Represents an expression that has a conditional operator.
Represents an expression that has a conditional operator.
Utilities for
ConnectionFactory and
CalciteAssert.ConnectionPostProcessor.Wrapping connection factory for Quidem.
Creates JDBC connections for tests.
Wrapping with Fairy environmental decoration.
Information necessary to create a JDBC connection.
List that consists of a head element and an immutable non-empty list.
Represents an expression that has a constant value.
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.
Declaration of a constructor.
Context for executing a scalar expression in an interpreter.
Provides library users a way to store data within the planner session and
access it within rules.
Utilities for
Context.A SqlValidator with schema and type factory of the given
CalcitePrepare.Context.Exception intended to be used for control flow, as opposed to the usual
use of exceptions which is to signal an error condition.
Calling convention trait.
Default implementation.
Definition of the convention trait.
Utility functions for converting from one type to another.
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.Abstract implementation of
Converter.Abstract base class for a rule which converts from one calling convention to
another without changing semantics.
Rule configuration.
Transforms the coordinates of a geometry.
Rules that perform logical transformations on relational expressions.
A relational operator that performs nested-loop joins.
Describes the necessary parameters for an implementation in order to
identify and set dynamic variables.
Shuttle that finds references to a given
CorrelationId within a tree
of RelNodes.A table function that returns all countries in the world.
Table function that executes the OS "cpu_info".
Table function that executes the OS "cpu_info".
CqlToSqlTypeConversionRules defines mappings from CQL types to
corresponding SQL types.
Enumerator that reads from a CSV file.
Table based on a CSV file that can implement simple filtering.
Planner rule that projects from a
CsvTableScan scan just the columns
needed to satisfy a projection.Planner rule that projects from a
CsvTableScan scan just the columns
needed to satisfy a projection.Rule configuration.
Rule configuration.
Planner rules relating to the CSV adapter.
Table based on a CSV file.
Schema mapped onto a directory of CSV files.
Factory that creates a
CsvSchema.Table based on a CSV file.
Factory that creates a
CsvTranslatableTable.Base class for table that reads CSV files.
Base class for table that reads CSV files.
Various degrees of table "intelligence".
Various degrees of table "intelligence".
Factory that creates a
CsvTranslatableTable.Factory that creates a
CsvTranslatableTable.Relational expression representing a scan of a CSV file.
Relational expression representing a scan of a CSV file.
Table based on a CSV file.
Table based on a CSV file.
Returns the rowtype of a cursor of the operand at a particular 0-based
ordinal position.
Extension to
Table that specifies a custom way to resolve column
names.Custom implementations of
RelDataTypeSystem for testing.Detects cycles in directed graphs.
Thrown when an object, such as a view, is found to have a cylic
definition.
Exception that indicates that a cycle has been detected while
computing metadata.
Runtime context allowing access to the tables in a database.
Variable that may be asked for in a call to
DataContext.get(java.lang.String).Utilities for
DataContext.Calendar types that can be used in PostgreSQL datetime formats.
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.Rule that converts EXTRACT, FLOOR and CEIL in a
Filter into a date
range.Rule configuration.
Date literal.
Utility methods to manipulate String representation of DateTime values.
The date/time format compiled component for a text representation of a day of
the week.
The date/time format component for a text representation of a day of the week.
A
SqlDialect implementation for the IBM DB2 database.Executes DDL commands.
Abstract implementation of
DdlExecutor.Expression that declares and optionally initializes a variable.
Rewrites relations to ensure the same correlation is referenced by the same
correlation variable.
Default implementation of DimensionSpec.
Default implementation of
DirectedGraph.Default implementation of Edge.
Implementation of the
Enumerable interface
that implements the extension methods by calling into the Extensions
class.Represents the default value of a type or an empty expression.
DefaultRelMetadataProvider supplies a default implementation of the
RelMetadataProvider interface.Simple enumerator that just delegates all calls to the passed enumerator.
A class derived from
DelegatingInvocationHandler handles a
method call by looking for a method in itself with identical parameters.Implementation of
LatticeStatisticProvider that delegates
to an underlying provider.Interface for
RelNode where the metadata is derived from another node.An implementation of
SqlValidatorNamespace that delegates all methods
to an underlying object.Implementation of
Schema that delegates to
an underlying schema.A scope which delegates all requests to its parent scope.
Implementation of
SqlValidatorCatalogReader that passes
all calls to a parent catalog reader.Implements
SqlValidatorTable by
delegating to a parent table.Implementation of
RelDataTypeSystem
that sends all methods to an underlying object.Relational operator that converts a relation to a stream.
Demo.
Department model.
Department with inception date model.
Employee dependents model.
Iterates over the vertices in a directed graph in depth-first order.
A
SqlDialect implementation for the Apache Derby database.The mode of trait derivation.
A key used in caching with descriptive to string.
Specifies that function is deterministic (i.e.
A deterministic finite automaton (DFA).
Factors out deterministic expressions to final static fields.
A collection of resources used by tests.
Callback to filter strings before returning them.
DiffTestCase is an abstract base for JUnit tests which produce multi-line
output to be verified by diffing against a pre-existing reference file.
Interface for Druid DimensionSpec.
Directed graph.
Factory for edges.
Direct operator conversion for expression like Function(exp_1,...exp_n)
Function that takes one parameter and returns a native
double value.Calcite JDBC driver.
Connection to Druid.
Utilities for generating intervals from RexNode.
Expression utility class to transform Calcite expressions to Druid expressions when possible.
Object that knows how to write itself to a
JsonGenerator.Relational expression representing a scan of a Druid data set.
Post-aggregator abstract writer.
Druid query specification.
Rules and relational operators for
DruidQuery.Rule configuration.
Rule to push an
Aggregate
into a DruidQuery.Rule configuration.
Rule to push a
Filter into a
DruidQuery.Rule configuration.
Rule to Push a Having
Filter into a DruidQuery.Rule configuration.
Rule to push a
Project into a
DruidQuery as a Post aggregator.Rule configuration.
Rule to push a
Project into a
DruidQuery.Rule configuration.
Rule to push a
Sort
into a DruidQuery.Rule configuration.
Schema mapped onto a Druid instance.
Schema factory that creates Druid schemas.
Druid cast converter operator; used to translates Calcite casts to Druid
expression casts.
Defines how to convert a
RexNode with a given Calcite SQL operator to
a Druid expression.Table mapped onto a Druid table.
Implementation of
TableFactory for Druid.Druid type.
Table function that executes the OS "du" ("disk usage") command
to compute file sizes.
Represents a dynamic operation.
Specific type of RelRecordType that corresponds to a dynamic table,
where columns are created as they are requested.
Implementation of
RelDataType for a dynamic table.Represents Pig Tuples with unknown fields.
Implementation of
Aggregate relational expression
for ElasticSearch.Implementation of a
Filter
relational expression in Elasticsearch.Implementation of
Project
relational expression in Elasticsearch.Relational expression that uses Elasticsearch calling convention.
Callback for the implementation process that converts a tree of
ElasticsearchRel nodes into an Elasticsearch query.Each table in the schema is an ELASTICSEARCH index.
Factory that creates an
ElasticsearchSchema.Internal object used to parse elastic search result.
Concrete result record which matched the query.
Similar to
SearchHits in ES.Implementation of
Sort
relational expression in Elasticsearch.Table based on an Elasticsearch index.
Implementation of
Queryable based on
a ElasticsearchTable.Relational expression representing a scan of an Elasticsearch type.
Relational expression representing a scan of a table in an Elasticsearch data source.
Rule to convert a relational expression from
ElasticsearchRel.CONVENTION to EnumerableConvention.Represents an initializer for a single element of an
Enumerable collection.Employee model.
Exposes the enumerator, which supports a simple iteration over a collection.
Implementation of
Aggregate in
enumerable calling convention.Base class for EnumerableAggregate and EnumerableSortedAggregate.
Implementation of
LogicalAsofJoin in
enumerable calling convention.Implementation of batch nested loop join in
enumerable calling convention.Rule to convert a
LogicalJoin to an EnumerableBatchNestedLoopJoin.Rule configuration.
Relational expression that converts an enumerable input to interpretable
calling convention.
Rule that converts any enumerable relational expression to bindable.
Implementation of
Calc in
enumerable calling convention.Implementation of
Collect in
enumerable calling convention.Family of calling conventions that return results as an
Enumerable.Implementation of
Correlate in
enumerable calling convention.Implementation of nested loops over enumerable inputs.
Default implementations of methods in the
Enumerable interface.Implementation of
Filter in
enumerable calling convention.Variant of
FilterToCalcRule for
enumerable calling convention.Rule configuration.
Implementation of
Join in
enumerable calling convention.Relational expression that converts an enumerable input to interpretable
calling convention.
Relational expression that executes its children using an interpreter.
Implementation of
Intersect in
enumerable calling convention.Relational expression that applies a limit and/or offset to its input.
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.Rule configuration.
Implementation of
Sort in
enumerable calling convention.Rule configuration.
Implementation of
Match in
enumerable calling convention.Rule to convert a
LogicalMatch to an EnumerableMatch.Implementation of
Join in
enumerable calling convention using
a merge algorithm.Implementation of
Union in
enumerable calling convention.Rule configuration.
Implementation of
Minus in
enumerable calling convention.Implementation of
Join in
enumerable calling convention
that allows conditions that are not just = (equals).Implementation of
Project in
enumerable calling convention.Variant of
ProjectToCalcRule for
enumerable calling convention.Rule configuration.
A relational expression of one of the
EnumerableConvention calling
conventions.Preferred physical type.
Result of implementing an enumerable relational expression by generating
Java code.
Contains factory interface and default implementation for creating various
rel nodes.
Subclass of
RelImplementor for relational
operators of EnumerableConvention calling convention.Implementation of
RepeatUnion in
enumerable calling convention.Rule to convert a
LogicalRepeatUnion into an EnumerableRepeatUnion.Rules and relational operators for the
enumerable calling convention.Utilities for processing
Enumerable
collections.Given a match (a list of rows, and their states) produces a list
of rows to be output.
Implementation of
Sort in
enumerable calling convention.Sort based physical implementation of
Aggregate in
enumerable calling convention.Implementation of
TableFunctionScan in
enumerable calling convention.Rule to convert a
LogicalTableFunctionScan to an EnumerableTableFunctionScan.Implementation of
TableModify in
enumerable calling convention.Planner rule that converts a
LogicalTableModify to an EnumerableTableModify.Implementation of
TableScan in
enumerable calling convention.Planner rule that converts a
LogicalTableScan to an EnumerableTableScan.Implementation of
TableSpool in
enumerable calling convention
that writes into a ModifiableTable (which must exist in the current
schema).Rule to convert a
LogicalTableSpool into an EnumerableTableSpool.Relational expression that converts input of
EnumerableConvention
into Spark convention.Implementation of
Uncollect in
enumerable calling convention.Implementation of
Union in
enumerable calling convention.Implementation of
Values in
enumerable calling convention.Planner rule that converts a
LogicalValues to an EnumerableValues.Implementation of
Window in
enumerable calling convention.Supports a simple iteration over a collection.
Implementation of
Cursor on top of an
Enumerator that
returns a record for each row.Utilities for generating programs in the Enumerable (functional)
style.
Fairy simulates environment around Calcite.
Describes who is emulated to being logged in.
Compares values for equality.
Deprecated.
Deprecated.
Set of elements organized into equivalence classes.
Event.
A
SqlDialect implementation for the Exasol database.Relational expression that imposes a particular distribution on its input
without otherwise changing its content.
Planner rule that removes keys from
a
Exchange if those keys are known to be constant.Rule configuration.
Annotation that indicates that a class, interface, field or method
is experimental, not part of the public API, and subject to change
or removal.
Parameter type-checking strategy for Explicit Type.
ExplicitOperandTypeInferences implements
SqlOperandTypeInference by
explicitly supplying a type for each parameter.ExplicitOperatorBinding implements SqlOperatorBinding
via an underlying array of known operand types.A
SqlReturnTypeInference which always returns the same SQL type.Analogous to LINQ's System.Linq.Expression.
Utility methods for expressions, including a lot of factory methods.
Fluent list.
Analogous to LINQ's System.Linq.Expressions.ExpressionType.
Represents a visitor or rewriter for expression trees.
Extension methods in
Enumerable.Extension methods for
OrderedEnumerable.Extension methods for
OrderedQueryable.Table whose row type can be extended to include extra fields.
Contains what, in LINQ.NET, would be extension methods.
Implementation of extraction function DimensionSpec.
Interface for Druid extraction functions.
Time extract operator conversion for expressions like
EXTRACT(timeUnit FROM arg).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).
Operand type-checking strategy which checks operands for inclusion in type
families.
SQL language feature.
Declaration of a field.
Scrapes HTML tables from URLs using Jsoup.
Indicates that the FileReader failed.
Planner rules relating to the File adapter.
Factory that creates a
FileSchema.Table function that executes the OS "find" command to find files under a
particular path.
Relational expression that iterates over its input
and returns elements for which
condition evaluates to
true.Table that can be scanned, optionally applying supplied filter expressions,
without creating an intermediate relational expression.
Rule configuration.
Filtered iterator class: an iterator that includes only elements that are
instanceof a specified class.
Rule configuration.
Rule configuration.
Planner rule that matches a
Filter expression with correlated
variables, and rewrites the condition in a simpler form that is more
convenient for the decorrelation logic.Rule configuration.
Planner rule that pushes filters above and
within a join node into the join node and/or its children nodes.
Rule configuration.
Rule that tries to push filter expressions into a join
condition and into the inputs of the join.
Rule configuration.
Rule that pushes parts of the join condition to its inputs.
Rule configuration.
Predicate that returns whether a filter is valid in the ON clause of a
join for this particular kind of join.
Planner rule that combines two
LogicalFilters.Rule configuration.
Rule configuration.
Interpreter node that implements a
Filter.Rule configuration.
Planner rule that replaces
IS NOT DISTINCT FROM
in a Filter with logically equivalent operations.Rule configuration.
Rule configuration.
Rule configuration.
Planner rule that pushes
a
LogicalFilter
past a LogicalTableFunctionScan.Rule configuration.
Planner rule that converts
a
Filter
on a TableScan
of a FilterableTable
or a ProjectableFilterableTable
to a Bindables.BindableTableScan.Rule configuration.
Planner rule that converts a
LogicalFilter to a
LogicalCalc.Rule configuration.
Rule configuration.
A
SqlDialect implementation for the Firebird database.A SqlDialect implementation for the Firebolt database.
Fluent test fixtures for typical Calcite tests (parser, validator,
sql-to-rel and rel-rules) that can easily be used in dependent projects.
Space-efficient, comparable, immutable lists.
Base class for flat lists.
List that is also comparable.
List that stores its one elements in the one members of the class.
List that stores its two elements in the two members of the class.
List that stores its three elements in the three members of the class.
List that stores its four elements in the four members of the class.
List that stores its five elements in the five members of the class.
List that stores its six elements in the six members of the class.
Flips the coordinates of a geometry.
Function that takes one parameter and returns a native
float value.DruidSqlOperatorConverter implementation that handles Floor operations
conversions.
Foodmart schema.
Sales fact model.
Represents a "for-each" loop, "for (T v : iterable) { f(v); }".
A format element in a format string.
Implementation of
FormatElement containing the standard format
elements.Describes the format strings used by a formatting function such as
FORMAT_TIMESTAMP or CAST(string AS DATE FORMAT formatString).Utilities for
FormatModel.A single component of a date/time format pattern such as YYYY or MI.
Represents an infinite loop.
Interface that describes how to configure planning sessions generated
using the Frameworks tools.
Tools for invoking Calcite functionality without initializing a container /
server first.
Piece of code to be run in a context where a planner and statement are
available.
A builder to help you build a
FrameworkConfig using defaults
where values aren't required.Piece of code to be run in a context where a planner is available.
Deprecated.
Base interface for all functions.
Named expression that accepts parameters and returns a result.
Function with no parameters.
Function with one parameter.
Function with two parameters.
Information about a function call that is passed to the constructor of a
function instance.
Runtime support for
FunctionContext.Represents a strongly typed lambda expression as a data structure in the form
of an expression tree.
Function that can be invoked with a variable number of arguments.
Parameter to a
Function.Utilities relating to functions.
Function type.
Implementation of
Aggregate relational expression
in Geode.Implementation of
Filter relational expression in Geode.Implementation of
Project
relational expression in Geode.Relational expression that uses Geode calling convention.
Shared context used by the
GeodeRel relations.Rules and relational operators for
GeodeRel.CONVENTION
calling convention.Rule to convert a
LogicalFilter to a
GeodeFilter.Rule configuration.
Rule configuration.
Schema mapped onto a Geode Region.
Factory that creates a
GeodeSchema.Geode Simple Enumerator.
Geode Simple Scannable Table abstraction.
Geode Simple Schema.
Geode Simple Table Schema Factory.
Implementation of
Sort
relational expression in Geode.Table based on a Geode Region.
Implementation of
Queryable based on a GeodeTable.Relational expression representing a scan of a Geode collection.
Relational expression representing a scan of a table in a Geode data source.
Rule to convert a relational expression from
GeodeRel.CONVENTION to EnumerableConvention.Utilities for the Geode adapter.
Table function that executes the OS "git log" command
to discover git commits.
A collection of terms.
Specifies what kind of jump a
GotoStatement represents.Represents an unconditional jump.
Factory methods and helpers for
Granularity.A strategy by which Druid rolls up rows into sub-totals based on their
timestamp values.
Type of supported periods for granularity.
Miscellaneous graph utilities.
Immutable grap.
Represents the name-resolution context for expressions in an GROUP BY clause.
Represents a collection of objects that have a common key.
A
SqlDialect implementation for the H2 database.Walks over a Piglet AST and calls the corresponding methods in a
PigRelBuilder.HepMatchOrder specifies the order of graph traversal when looking for rule
matches.
HepPlanner is a heuristic implementation of the
RelOptPlanner
interface.HepProgram specifies the order in which rules should be attempted by
HepPlanner.HepProgramBuilder creates instances of
HepProgram.HepRelVertex wraps a real
RelNode as a vertex in a DAG representing
the entire query expression.HepRuleCall implements
RelOptRuleCall for a HepPlanner.A Schema representing a hierarchy of employees.
Hierarchy representing manager - subordinate.
2-dimensional Hilbert space-filling curve.
A
HintOptionChecker validates the options of a RelHint.A
HintPredicate indicates whether a RelNode
can apply the specified hint.A collection of hint predicates.
Annotation applied to a user-defined function that gives extra metadata
about that function.
Represents a hint strategy entry of
HintStrategyTable.Builder for
HintStrategy.A collection of
HintStrategys.Builder for
HintStrategyTable.Implementation of
Litmus that returns
a status code, it logs warnings for fail check and does not throw.A
SqlDialect implementation for the Apache Hive database.Utility that extracts constants from a SQL query.
Configuration.
Result of hoisting.
Variable.
Implementation of
MutableRel whose only purpose is to have a
child.A mutable slot that can contain one object.
Collection of hooks that can be set by observers and are executed at various
parts of the query preparation process.
Removes a Hook after use.
A schema that contains two tables by reflection.
HR schema with more data than in
HrSchema.A
SqlDialect implementation for the Hsqldb database.Utilities for connecting to REST services such as Splunk via HTTP.
Namespace whose contents are defined by the type of an
identifier.Similar to
Pair but identity is based
on identity of values.An immutable list of bits.
Builder.
An immutable list of
Integer values backed by an array of
ints.An immutable list that may contain null values.
A builder for creating immutable nullable list instances.
An immutable map that may contain null values.
An immutable set that may contain null values.
A builder for creating immutable nullable set instances.
Immutable list of pairs.
Function that can be translated to java code.
Function that can be translated to java code.
An operand type checker that supports implicit type cast, see
TypeCoercion.builtinFunctionCoercion(SqlCallBinding, List, List)
for details.Index condition.
Represents indexing a property or array.
Strategies for inferring operand types.
Mock table that returns a stream of orders from a fixed array.
Table representing an infinitely larger ORDERS stream.
A
SqlDialect implementation for the Infobright database.A
SqlDialect implementation for the Informix database.A
SqlDialect implementation for the Ingres database.Provides context for
InitializerExpressionFactory methods.InitializerExpressionFactory supplies default values for INSERT, UPDATE, and NEW.
Implementation of a
Filter
relational expression for an InnoDB data source.Builtin methods in InnoDB data source.
Implementation of
Project
relational expression for an InnoDB data source.Relational expression that uses InnoDB calling convention.
Callback for the implementation process that converts a tree of
InnodbRel nodes into an InnoDB direct call query.Rules and relational operators for
InnodbRel.CONVENTION
calling convention.Rule to convert a
LogicalFilter to a
InnodbFilter.Rule configuration.
Rule to convert a
LogicalProject
to a InnodbProject.Rule to convert a
Sort to a
InnodbSort.Rule configuration.
Rule to convert a
Sort to a
InnodbSort based on InnoDB table clustering index.Rule configuration.
Schema for an InnoDB data source.
Factory that creates a
InnodbSchema.Implementation of
Sort
relational expression for an InnoDB data source.Table based on an InnoDB data file.
Implementation of
Queryable based on
a InnodbTable.Relational expression representing a scan of an InnoDB data source.
Relational expression representing a scan of a table
in InnoDB data source.
Rule to convert a relational expression from
InnodbRel.CONVENTION to EnumerableConvention.Function that takes one parameter and returns a native
int value.A set of non-negative integers defined by a sequence of points, intervals,
and exclusions.
A
SqlDialect implementation for the Interbase database.Table function that executes the OS "interface_addresses".
Table function that executes the OS "interface_details".
Calling convention that returns results as an
Enumerable of object arrays.Relational expression that converts any relational expression input to
InterpretableConvention, by wrapping
it in an interpreter.Relational expression that can implement itself using an interpreter.
Interpreter.
Utilities relating to
Interpreter
and InterpretableConvention.Relational expression that returns the intersection of the rows of its
inputs.
Rule configuration.
Parameter type-checking strategy whether the operand must be an interval.
IntervalSqlType represents a standard SQL datetime interval type.
Test cases for intervals.
Fluent interface for binding an expression to create a fixture that can
be used to validate, check AST, or check type.
Fluent interface to validate an expression.
Deprecated.
An immutable pair of integers.
Exception that indicates that a relational expression would be invalid
with given parameters.
Represents an expression that applies a delegate or lambda expression to a
list of argument expressions.
Arguments to an invocation of the Janino compiler.
Implementation of the
RelMetadataProvider interface that generates
a class that dispatches to the underlying providers.Deprecated.
Collation that uses a specific
Collator for comparison.The interface
JavaCompiler represents an interface to invoke a
regular Java compiler.A
JavaCompilerArgs holds the arguments for a
JavaCompiler.Table function that executes the OS "java_info".
Record type based on a Java class.
Abstract base class for implementations of
RelImplementor
that generate java code.How a row is represented as a Java value.
JavaToSqlTypeConversionRules defines mappings from common Java types to
corresponding SQL types.
Type factory that can register Java classes as record types.
Implementation of
JavaTypeFactory.Implementation of
JavaTypeFactory.Synthetic record type.
Schema based upon a JDBC catalog (database).
Calling convention for relational operations that occur in a JDBC
database.
State for generating a SQL statement.
Implementation of
QueryProvider that talks to JDBC databases.Relational expression that uses JDBC calling convention.
Rules and relational operators for
JdbcConvention
calling convention.Aggregate operator implemented in JDBC convention.
Rule to convert a
Aggregate
to a JdbcRules.JdbcAggregate.Deprecated.
Implementation of
Filter in
jdbc calling convention.Rule to convert a
Filter to
an JdbcRules.JdbcFilter.Intersect operator implemented in JDBC convention.
Rule to convert a
Intersect
to a JdbcRules.JdbcIntersect.Join operator implemented in JDBC convention.
Rule that converts a join to JDBC.
Minus operator implemented in JDBC convention.
Rule to convert a
Minus to a
JdbcRules.JdbcMinus.Implementation of
Project in
jdbc calling convention.Rule to convert a
Project to
an JdbcRules.JdbcProject.Sort operator implemented in JDBC convention.
Rule to convert a
Sort to an
JdbcRules.JdbcSort.Rule that converts a table-modification to JDBC.
Table-modification operator implemented in JDBC convention.
Union operator implemented in JDBC convention.
Rule to convert an
Union to a
JdbcRules.JdbcUnion.Values operator implemented in JDBC convention.
Rule that converts a values operator to JDBC.
Implementation of
Schema that is backed by a JDBC data source.Schema factory that creates a
JdbcSchema.Do not use.
Queryable that gets its data from a table within a JDBC connection.
Relational expression representing a scan of a table in a JDBC data source.
Relational expression representing a scan of a table in a JDBC data source.
Rule to convert a relational expression from
JdbcConvention to
EnumerableConvention.Relational expression representing a scan of a table in a JDBC data source
that returns its results as a Spark RDD.
Rule to convert a relational expression from
JdbcConvention to
Spark convention.Maps Java types to their corresponding getters in JDBC.
A
SqlDialect implementation for the JethroData database.Information about the capabilities of a Jethro database.
Stores information about capabilities of Jethro databases.
Relational expression that combines two relational expressions according to
some condition.
Rule to add a semi-join into a join.
Rule configuration.
Planner rule that changes a join based on the associativity rule.
Rule configuration.
Planner rule that permutes the inputs to a
Join.Rule configuration.
Enumerates the types of condition in a join expression.
Rule configuration.
Rule configuration.
An analyzed join condition.
Interpreter node that implements a
Join.Planner rule that matches a
Join one of whose inputs is a
LogicalProject, and
pulls the project up.Rule configuration.
Planner rule that pushes down expressions in "equal" join condition.
Rule configuration.
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.
Rule configuration.
Rule configuration.
Enumeration of join types.
The name-resolution context for expression inside a JOIN clause.
Rule that converts a
Join
into a LogicalCorrelate, which can
then be implemented using nested loops.Rule configuration.
Planner rule to flatten a tree of
LogicalJoins
into a single MultiJoin with N inputs.Rule configuration.
Enumeration of join types.
Enumerates the types of join.
Rule configuration.
Table function that executes the OS "jps" ("Java Virtual Machine Process
Status Tool") command to list all java processes of a user.
JSON object representing a column.
JSON schema element that represents a custom schema.
Custom table schema element.
Enumerator that reads from a Object List.
Function schema element.
A collection of functions used in JSON processing.
Used in the JsonModify function.
Returned path context of JsonApiCommonSyntax, public for testing.
The Java output of
SqlJsonValueExpressionOperator.Path spec has two different modes: lax mode and strict mode.
State for
JSON_EXISTS, JSON_VALUE, JSON_QUERY.JSON object representing a schema that maps to a JDBC database.
Element that describes a star schema and provides a framework for defining,
recognizing, and recommending materialized views at various levels of
aggregation.
JSON object representing a schema whose tables are explicitly specified.
Element that describes how a table is a materialization of a query.
An aggregate function applied to a column (or columns) of a lattice.
Root schema element.
Table based on a JSON file.
Schema schema element.
Built-in schema types.
Information about whether a table allows streaming.
Table based on a JSON file.
Table schema element.
Materialized view within a
JsonLattice.Type schema element.
JSON object representing a type attribute.
View schema element.
Enumerator to read data from
Consumer,
and converted into SQL rows with KafkaRowConverter.Interface to handle formatting between Kafka message and Calcite row.
Default implementation of
KafkaRowConverter, both key and value are byte[].A table that maps to an Apache Kafka topic.
Implementation of
TableFactory for Apache Kafka.Available options for
KafkaStreamTable.Represents a label, which can be put in any
Expression context.Used to represent the target of a
GotoStatement.Describes a lambda expression.
Namespace for
lambda expression.Structure that allows materialized views based upon a star schema to be
recognized and recommended.
Column in a lattice.
Lattice builder.
Column in a lattice.
Column in a lattice that is based upon a SQL expression.
A measure within a
Lattice.The information necessary to convert a column to SQL.
Materialized aggregate within a lattice.
Tile builder.
Non-root node in a
Lattice.Source relation of a lattice.
Root node in a
Lattice.Utilities for
Lattice, LatticeStatisticProvider.Estimates row counts for a lattice and its attributes.
Creates a
LatticeStatisticProvider for a given
Lattice.Algorithm that suggests a set of lattices.
Table registered in the graph.
Generate aggregate lambdas that preserve the input source before calling each
aggregate adder, this implementation is generally used when we need to sort the input
before performing aggregation.
Accumulate on the cached input sources.
Cache the input sources.
Named, built-in lexical policy.
An annotation that is read by
SqlLibraryOperatorTableFactory to
add functions and operators to a library.Utilities for converting SQL
LIKE and SIMILAR operators
to regular expressions.Lingual emp model.
Lingual schema.
Utility and factory methods for Linq4j.
Represents a constructor call that has a collection initializer.
Abstract base for a scope which is defined by a list of child namespaces and
which inherits from a parent scope.
Implementation of the
SqlOperatorTable interface by using a list of
operators.TransientTable backed by a Java list.A literal string in a date/time format.
Parameter type-checking strategy type must be a literal (whether null is
allowed is determined by the constructor).
Callback to be called when a test for validity succeeds or fails.
Location model.
LogicalAggregate is a relational operator which eliminates
duplicates and computes totals.Sub-class of
AsofJoin encoding ASOF joins.A relational expression which computes project expressions and also filters.
Sub-class of
Chi
not targeted at any particular engine or calling convention.A relational operator that performs nested-loop joins.
Sub-class of
Delta
not targeted at any particular engine or calling convention.Sub-class of
Exchange not
targeted at any particular engine or calling convention.Sub-class of
Filter
not targeted at any particular engine or calling convention.Sub-class of
Intersect
not targeted at any particular engine or calling convention.Sub-class of
Join
not targeted at any particular engine or calling convention.Sub-class of
Match
not targeted at any particular engine or calling convention.Sub-class of
Minus
not targeted at any particular engine or calling convention.Sub-class of
Project not
targeted at any particular engine or calling convention.Sub-class of
RepeatUnion
not targeted at any particular engine or calling convention.Sub-class of
Snapshot
not targeted at any particular engine or calling convention.Sub-class of
Sort not
targeted at any particular engine or calling convention.Sub-class of
SortExchange not
targeted at any particular engine or calling convention.Sub-class of
TableFunctionScan
not targeted at any particular engine or calling convention.Sub-class of
TableModify
not targeted at any particular engine or calling convention.A
LogicalTableScan reads all the rows from a
RelOptTable.Sub-class of
TableSpool not targeted at any particular engine or
calling convention.Sub-class of
Union
not targeted at any particular engine or calling convention.Sub-class of
Values
not targeted at any particular engine or calling convention.Sub-class of
Window
not targeted at any particular engine or calling convention.Visitor pattern for traversing a tree of
RexNode objects.Function that takes one parameter and returns a native
long value.Implementation of SchemaVersion that uses a long value as representation.
Represents a collection of keys each mapped to one or more values.
Utility class used to store a
Join tree
and the factors that make up the tree.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.
Binary tree node that has no children.
Binary tree node that has two children.
Utility class that keeps track of the join factors that
make up a
MultiJoin.Planner rule that implements the heuristic planner for determining optimal
join orderings.
Rule configuration.
Implements the logic for determining the optimal
semi-joins to be used in processing joins in a query.
A
SqlDialect implementation for the LucidDB database.Annotation that indicates that a field is a map type.
Simple implementation of
Map.Entry.A Mapping is a relationship between a source domain to target
domain of integers.
Utility functions related to mappings.
Abstract implementation of
Mapping.Core interface of all mappings.
Abstract implementation of mapping where both source and target
domains are finite.
Mapping where every source has a target.
The identity mapping, of a given size, or infinite.
Thrown when a mapping is expected to return one element but returns none.
Source mapping that returns the same result as a parent
Mappings.SourceMapping except for specific overriding elements.Target mapping that returns the same result as a parent
Mappings.TargetMapping except for specific overriding elements.A mapping where a source has at most one target, and every target has at
most one source.
Mapping suitable for sourcing columns.
Mapping suitable for mapping columns to a target.
Thrown when a mapping is expected to return one element but returns
several.
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 restricted MappingType.BIJECTION (every
element in the source and target domain must be paired with precisely one
element in the other domain).Implementation of
SqlStatisticProvider that looks up values in a
table.SQL map type.
Relational expression that represent a MATCH_RECOGNIZE node.
Aggregate calls in match recognize.
Workspace that partialMatches patterns against an automaton.
Builds a Matcher.
Matchers for testing SQL queries.
Matcher that tests whether the numeric value is within a given difference
another value.
Implementor of Functions used in MATCH_RECOGNIZE Context.
Interpreter node that implements a
Match.Namespace for a
MATCH_RECOGNIZE clause.Scope for expressions in a
MATCH_RECOGNIZE clause.Returns the first type that matches a set of given
SqlTypeNames.Planner rule that converts a
LogicalMatch to the result
of calling LogicalMatch.copy(org.apache.calcite.plan.RelTraitSet, java.util.List<org.apache.calcite.rel.RelNode>).Rule configuration.
Class with static Helpers for MATCH_RECOGNIZE.
Unique identifier for a materialization.
Manages the collection of materialized tables known to the system,
and the process by which they become valid and invalid.
Default implementation of
MaterializationService.TableFactory.Creates tables that represent a materialized view.
Materialized view rewriting for aggregate.
Rule configuration.
Rule configuration.
Materialized view rewriting for join.
Rule that matches Aggregate.
Rule configuration.
Rule that matches Filter.
Rule configuration.
Rule that matches Join.
Rule configuration.
Rule that matches Project on Aggregate.
Rule configuration.
Rule that matches Project on Filter.
Rule configuration.
Rule that matches Project on Join.
Rule configuration.
Rule configuration.
Edge for graph.
Class representing an equivalence class, i.e., a set of equivalent columns
Complete, view partial, or query partial.
Expression lineage details.
View partitioning result.
Collection of rules pertaining to materialized views.
Deprecated.
Table that is a materialized view.
Table function that returns the table that materializes a view.
User-defined table function that generates a Maze and prints it in text
form.
Collection of planner rules that deal with measures.
Rule that matches an
Aggregate with at least one call to
SqlInternalOperators.AGG_M2V and expands these calls by
asking the measure for its expression.Configuration for
MeasureRules.AggregateMeasure2Rule.Rule that matches an
Aggregate with at least one call to
SqlInternalOperators.AGG_M2V and converts those calls
to SqlInternalOperators.M2X.Configuration for
MeasureRules.AggregateMeasureRule.Configuration for
MeasureRules.FilterSortMeasureRule.Configuration for
MeasureRules.ProjectMeasureRule.Configuration for
MeasureRules.ProjectSortMeasureRule.Scope for resolving identifiers within a SELECT item that is annotated
"AS MEASURE".
Measure SQL type.
A named expression in a schema.
Represents assignment operation for a field or property of an object.
Provides the base class from which the classes that represent bindings that
are used to initialize members of a newly created object derive.
Declaration of a member of a class.
Represents accessing a field or property.
Represents calling a constructor and initializing one or more members of the
new object.
Represents initializing the elements of a collection member of a newly
created object.
Represents initializing members of a member of a newly created object.
Enumerable that has a (limited) memory for n past and m future steps.
Enumerator that keeps some recent and some "future" values.
Contains the State and changes internally.
Contents of a "memory segment", used for implementing the
MATCH_RECOGNIZE operator.Table function that executes the OS "memory_info".
Metadata about a relational expression.
Definition of metadata.
Source of metadata about relational expressions.
Deprecated.
Use
RelMetadataQuery.Marker interface for a handler of metadata.
Provides
MetadataHandler call sites for
RelMetadataQuery.Exception that indicates there there should be a handler for
this class but there is not.
Represents a call to either a static or an instance method.
Declaration of a method.
Relational expression that returns the rows of its first input minus any
matching rows from its other inputs.
Rule configuration.
Mock implementation of
SqlValidatorCatalogReader which returns tables
"EMP", "DEPT", "BONUS", "SALGRADE" (same as Oracle's SCOTT schema).Column resolver.
Mock implementation of
AbstractQueryableTable with dynamic record
type.Alternative to MockViewTable that exercises code paths in ModifiableViewTable
and ModifiableViewTableInitializerExpressionFactory.
A mock of ModifiableViewTable that can unwrap a mock RelOptTable.
A TableMacro that creates mock ModifiableViewTable.
Mock implementation of
Prepare.AbstractPreparingTable which holds ViewTable
and delegates MockCatalogReader.MockTable.toRel(org.apache.calcite.plan.RelOptTable.ToRelContext) call to the view.Mock schema.
Mock implementation of
Prepare.PreparingTable.Mock implementation of
Prepare.PreparingTable for views.Mock implementation of
MockCatalogReader.MockTable that supports must-filter fields.Registers dynamic tables.
Adds some extra tables to the mock catalog.
Simple catalog reader for testing.
Executes the few DDL commands.
MockRelOptPlanner is a mock implementation of the
RelOptPlanner
interface.Mock operator table for testing purposes.
Another bad table function: declares itself as a table function but does
not return CURSOR.
"COMPOSITE" user-defined scalar function.
"DEDUP" user-defined table function.
"DYNTYPE" user-defined table function.
Invalid user-defined table function with multiple input tables with
row semantics.
"MAP" user-defined function.
"MYAGGFUNC" user-defined aggregate function.
"MYAGG" user-defined aggregate function.
"MYFUN" user-defined scalar function.
Not valid as a table function, even though it returns CURSOR, because
it does not implement
SqlTableFunction."RAMP" user-defined table function.
"ROW_FUNC" user-defined table function whose return type is
row type with nullable and non-nullable fields.
"Score" user-defined table function.
Similarity performs an analysis on two data sets, which are both tables
of two columns, treated as the x and y axes of a graph.
"SPLIT" user-defined function.
"STRUCTURED_FUNC" user-defined function whose return type is structured type.
"TopN" user-defined table function.
Reads a model and creates schema objects accordingly.
Extra operands automatically injected into a
JsonCustomSchema.operand, as extra context for the adapter.A table that can be modified.
A modifiable view onto
ModifiableTable.Extension to
ViewTable that is modifiable.Implementation of
Aggregate relational expression
in MongoDB.Implementation of a
Filter
relational expression in MongoDB.Builtin methods in the MongoDB adapter.
Implementation of
Project
relational expression in MongoDB.Relational expression that uses Mongo calling convention.
Callback for the implementation process that converts a tree of
MongoRel nodes into a MongoDB query.Rules and relational operators for
MONGO
calling convention.Schema mapped onto a directory of MONGO files.
Factory that creates a
MongoSchema.Implementation of
Sort
relational expression in MongoDB.Table based on a MongoDB collection.
Implementation of
Queryable based on
a MongoTable.Relational expression representing a scan of a MongoDB collection.
Relational expression representing a scan of a table in a Mongo data source.
Rule to convert a relational expression from
MongoRel.CONVENTION to EnumerableConvention.Supplier that awaits a value and allows the value to be set, once,
to a not-null value.
The date/time format compiled component for a text representation of a month.
The date/time format component for a text representation of a month.
Table function that executes the OS "mounts".
A
SqlDialect implementation for the Microsoft SQL Server
database.MulticastRelOptListener implements the
RelOptListener interface by
forwarding events on to a collection of other listeners.A MultiJoin represents a join of N inputs, whereas regular Joins
represent strictly binary joins.
Planner rule that finds an approximately optimal ordering for join operators
using a heuristic algorithm.
Rule configuration.
MultiJoinProjectTransposeRule implements the rule for pulling
LogicalProjects that are on top of a
MultiJoin and beneath a
LogicalJoin so the
LogicalProject appears above the
LogicalJoin.Rule configuration.
Parameter type-checking strategy where types must be ([nullable] Multiset,
[nullable] Multiset), and the two types must have the same element type.
MultisetSqlType represents a standard SQL2003 multiset type.
Mock catalog reader that tags a few columns in the tables as must-filter.
Mutable equivalent of
Aggregate.Mutable equivalent of
Calc.Mutable equivalent of
Collect.Mutable equivalent of
Correlate.Mutable equivalent of
Exchange.Mutable equivalent of
Filter.Mutable equivalent of
Intersect.Mutable equivalent of
Join.Mutable equivalent of
Match.Mutable equivalent of
Minus.Mutable equivalent of
Project.Mutable equivalent of
RelNode.Utilities for dealing with
MutableRels.Visitor over
MutableRel.Mutable equivalent of
Sample.Mutable equivalent of
TableScan.Mutable equivalent of
SetOp.Mutable equivalent of
Sort.Mutable equivalent of
TableFunctionScan.Mutable equivalent of
TableModify.Mutable equivalent of
Uncollect.Mutable equivalent of
Union.Mutable equivalent of
Values.Mutable equivalent of
Window.A
SqlDialect implementation for the MySQL database.Map whose keys are names and can be accessed with and without case
sensitivity.
Multimap whose keys are names and can be accessed with and without case
sensitivity.
Set of names that can be accessed with and without case sensitivity.
Converts Calcite n-ary operators to Druid expressions, for example
arg1 Op arg2 Op arg3.A
SqlDialect implementation for the Neoview database.Allows to build nested code blocks with tracking of current context.
Allows to build nested code blocks with tracking of current context.
A
SqlDialect implementation for the Netezza database.Represents creating a new array and possibly initializing the elements of the
new array.
Represents a constructor call.
A string, optionally with
character set and
SqlCollation.Relational expression that can be executed using an interpreter.
Parse tree node.
Helper methods for
Node and implementations for core relational
expressions.Extension to
Interpreter.CompilerImpl
that knows how to handle the core logical
RelNodes.A hint predicate that specifies which kind of relational
expression the hint can be applied to.
Specifies that function is NOT deterministic (i.e.
Rule to convert a relational expression from
Convention.NONE
to BindableConvention.This class provides non-nullable accessors for common getters.
Simplified version of
CallImplementor
that does not know about null semantics.Parameter type-checking strategy where all operand types must not be NULL.
Function that takes one parameter and returns a
BigDecimal value that
may be null.Function that takes one parameter and returns a
Double value that
may be null.Function that takes one parameter and returns a
Float value that
may be null.Function that takes one parameter and returns an
Integer value that
may be null.Function that takes one parameter and returns a
Long value that
may be null.A table model that contains nullable columns.
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.
An implementation of
InitializerExpressionFactory that always supplies NULL.The methods in this class allow to cast nullable reference to a non-nullable one.
Describes when a function/operator will return null.
Placeholder for null values.
A date/time format compiled component that will parse a sequence of digits into
a value (such as "DD").
A date/time format component that will parse a sequence of digits into a value
(such as "DD").
Utility functions for working with numbers.
ObjectSqlType represents an SQL structured user-defined type.
Strategies for handling operands.
Operand type-checking strategy user-defined functions (including user-defined
aggregate functions, table functions, and table macros).
Strategies to check for allowed operand types of an operator call.
Strategies for checking operand types.
Shuttle that optimizes expressions.
Four states that describe whether a particular behavior or
property is allowed and/or not allowed.
Operator type.
A
SqlDialect implementation for the Oracle database.Deprecated.
Use
SqlLibraryOperatorTableFactory.getOperatorTable(SqlLibrary...)
instead, passing SqlLibrary.ORACLE as argument.Pair of an element and an ordinal.
Represents the name-resolution context for expressions in an ORDER BY clause.
Represents the result of applying a sorting operation to an
Enumerable.Represents the result of applying a sorting operation to a
Queryable.Table representing the history of the ORDERS stream.
Mock table that returns a stream of orders from a fixed array.
Table representing the ORDERS stream.
Returns the type of the operand at a particular 0-based ordinal position.
Enumerator that reads from OS's System.
Used to put OS query related func.
Get system enumeration information.
Table function that executes the OS "os_version".
The name-resolution scope of a OVER clause.
This is a dummy annotation that forces javac to produce output for
otherwise empty package-info.java.
Pair of objects.
Represents an operation that accepts two input arguments and an ordinal,
and returns no result.
A list of pairs, stored as a quotient list.
Builds a PairList.
Deprecated.
Action to be taken each step of an indexed iteration over a PairList.
A
SqlDialect implementation for the Paraccel database.Annotation that supplies metadata about a function parameter.
Represents a named parameter expression.
A scope which contains nothing besides a few parameters.
Partially-ordered set.
Ordering relation.
Path from a root schema to a particular object (schema, table, function).
Regular expression, to be compiled into an
Automaton.Base class for implementations of
Pattern.Operator that constructs composite
Pattern instances.Pattern with one or more arguments.
Builds a pattern expression.
Pattern that matches a pattern repeated between
minRepeat
and maxRepeat times.Pattern that matches a symbol.
Flags that can be added to a date/time format component.
Represents a mapping which reorders elements in an array.
A
SqlDialect implementation for the Apache Phoenix database.Physical node in a planner that is capable of doing
physical trait propagation and derivation.
Physical type of a row.
Implementation of
PhysType.Supported Pig aggregate functions and their Calcite counterparts.
Implementation of
Aggregate in
Pig calling convention.Extension from PigServer to convert Pig scripts into logical relational
algebra plans and SQL statements.
Supported Pig data types and their Calcite counterparts.
Implementation of
Filter in
Pig calling convention.Implementation of
Join in
Pig calling convention.Implementation of
Project in
Pig calling convention.Relational expression that uses the Pig calling convention.
Callback for the implementation process that converts a tree of
PigRel nodes into complete Pig Latin script.Extension to
RelBuilder for Pig logical operators.Extension to
RelBuilder for Pig relational operators.Option for performing group efficiently if data set is already sorted.
Context constructed during Pig-to-
RelNode translation process.Implementations of factories in
RelFactories
for the Pig adapter.Implementation of
RelFactories.AggregateFactory that
returns a PigAggregate.Implementation of
RelFactories.FilterFactory that
returns a PigFilter.Implementation of
RelFactories.JoinFactory that
returns a PigJoin.Implementation of
RelFactories.TableScanFactory that
returns a PigTableScan.An extension of
RelToSqlConverter to convert a relation algebra tree,
translated from a Pig script, into a SQL statement.Various
RelOptRules using the Pig convention.Schema that contains one more or more Pig tables.
Factory that creates a
PigSchema.Represents a Pig relation that is created by Pig Latin
LOAD statement.A non-queriable table that contains only row type to represent a Pig Table.
Factory that creates a
PigTable.Implementation of
TableScan in
Pig calling convention.Relational expression representing a scan of a table in a Pig data source.
Rule to convert a relational expression from
PigRel.CONVENTION to EnumerableConvention.Planner rule that converts Pig aggregate UDF calls to built-in SQL
aggregates.
Rule configuration.
Implementation methods.
Pig user-defined function.
Namespace for a
PIVOT clause.Scope for expressions in a
PIVOT clause.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.
Implementation of
Planner.Provides an implementation of toChar that matches PostgreSQL behaviour.
A
SqlDialect implementation for the PostgreSQL database.Parser that takes a collection of tokens (atoms and operators)
and groups them together according to the operators' precedence
and associativity.
Fluent helper to build a parser containing a list of tokens.
A token that is a call to an operator with arguments.
An operator token.
Callback defining the behavior of a special function.
An token corresponding to a special operator.
A token: either an atom, a call to an operator with arguments,
or an unmatched operator.
Token type.
Function with one parameter returning a native
boolean value.Function with two parameters returning a native
boolean value.Deprecated.
Now Calcite is Java 8 and higher, we recommend that you
implement
Predicate directly.Factory for the table of albums preferred by the current user.
Factory for the table of genres preferred by the current user.
Abstract base for classes that implement
the process of preparing and executing SQL expressions.
Abstract implementation of
Prepare.PreparingTable with an implementation
for Prepare.AbstractPreparingTable.columnHasDefaultValue(org.apache.calcite.rel.type.RelDataType, int, org.apache.calcite.sql2rel.InitializerContext).Interface by which validator and planner can read table metadata.
Describes that a given SQL query is materialized by a given table.
PreparedExplanation is a PreparedResult for an EXPLAIN PLAN statement.
Abstract implementation of
Prepare.PreparedResult.Definition of a table, for the purposes of the validator and planner.
A
SqlDialect implementation for the Presto database.Enumeration of Java's primitive types.
Whether a type is primitive (e.g.
A place to send a value.
A place from which to read a value.
Namespace whose contents are defined by the result of a call to a
user-defined procedure.
Utilities regarding operating system processes.
Table representing the PRODUCTS relation.
Mocks a simple relation to use for stream joining test.
Table representing the PRODUCTS_TEMPORAL temporal table.
Analyzes data sets.
Column.
Value distribution, including cardinality and optionally values, of a
column or set of columns.
Functional dependency.
The result of profiling, contains various statistics about the
data in a table.
Whole data set.
Statistic produced by the profiler.
Unique key.
Implementation of
Profiler that only investigates "interesting"
combinations of columns.Builds a
ProfilerImpl.Program that transforms a relational expression into another relational
expression.
Utilities for creating
Programs.Relational expression that computes a set of
'select expressions' from its input relational expression.
Deprecated.
Table that can be scanned, optionally applying supplied filter expressions,
and projecting a given list of columns,
without creating an intermediate relational expression.
Rule configuration.
Rule configuration.
Rule configuration.
Visitor for RelNodes which applies specified
RexShuttle visitor
for every node in the tree.Visitor for RexNodes which replaces
RexCorrelVariable with specified.Rule configuration.
Transforms the projection of a geometry.
Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
Interpreter node that implements a
Project.Planner rule that converts SUM to SUM0 when it is the aggregate for an OVER clause inside
the project list.
Rule configuration.
Planner rule that,
given a
Project node that
merely returns its input, converts the node into its child.Rule configuration.
Rule configuration.
Planner rule that converts a
Project
on a TableScan
of a ProjectableFilterableTable
to a Bindables.BindableTableScan.Rule configuration.
Rule to convert a
LogicalProject to a
LogicalCalc.Rule configuration.
Planner rule that slices a
Project
into sections which contain windowed
aggregate functions and sections which do not.Instance of the rule that applies to a
Calc that contains
windowed aggregates and converts it into a mixture of
LogicalWindow and Calc.Rule configuration.
Rule configuration.
Instance of the rule that can be applied to a
Project and that produces, in turn,
a mixture of LogicalProject
and LogicalWindow.Rule configuration.
Planner rule that pushes
a
LogicalProject
past a LogicalWindow.Rule configuration.
A MetadataHandlerProvider built on a RelMetadataProvider.
Collection of rules which remove sections of a query plan known never to
produce any rows.
Configuration for rule that prunes a correlate if its left input is empty.
Configuration for rule that prunes a correlate if its right input is empty.
Configuration for a rule that prunes an Intersect if any of its inputs
is empty.
Configuration for rule that prunes a join it its left input is
empty.
Configuration for rule that prunes a join it its right input is
empty.
Configuration for a rule that prunes empty inputs from a Minus.
Abstract prune empty rule that implements SubstitutionRule interface.
Rule configuration.
Rule that converts a relation into empty.
Rule configuration.
Configuration for a rule that prunes a Sort if it has limit 0.
Configuration for a rule that prunes empty inputs from a Minus.
Configuration for rule that transforms an empty relational expression into
an empty values.
Contains the parts of the
Field class needed
for code generation, but might be implemented differently.Table function that executes the OS "ps" command
to list processes.
Class for parsing, line by line, the output of the ps command for a
predefined list of parameters.
A text processor similar to Awk.
Fluent interface for constructing a Program.
Context for executing a Puffin program within a given file.
A line in a file.
A Puffin program.
PushProjector is a utility class used to perform operations used in push
projection rules.
A functor that replies true or false for a given expression.
Provides functionality to evaluate queries against a specific data source
wherein the type of the data is known.
Default implementations for methods in the
Queryable interface.Non-leaf replayable queryable.
Replayable.
Replayable queryable.
Factory for building
Queryable objects.Implementation of
QueryableFactory that records each event
and returns an object that can replay the event when you call its
QueryableDefaults.ReplayableQueryable.replay(QueryableFactory)
method.Defines methods to create and execute queries that are described by a
Queryable object.Partial implementation of
QueryProvider.Binds an expression to this query provider.
Implementation of
SqlStatisticProvider that generates and executes
SQL queries.Type of Druid query.
Query type of a push down condition in InnoDB data source.
Test that runs every Quidem file as a test.
Quidem connection factory for Calcite's built-in test schemas.
Function object for
RAND and RAND_INTEGER, with and without
seed.Utilities for Guava
RangeSet.Consumer of
Range values.Deconstructor for
Range values.Exposes the enumerator, which supports a simple iteration over a collection,
without the extension methods.
Core methods that define a
Queryable.Implementation of
Cursor on top of an
Enumerator that
returns a record for each row.Set the redis config.
Define the data processing type of redis.
The class with RedisDataProcess.
All available data type for Redis.
Manages connections to the Redis nodes.
Factory that creates a
RedisSchema.Table mapped onto a redis table.
Implementation of
TableFactory for Redis.get the redis table's field info.
A
SqlDialect implementation for the Redshift database.Rule that reduces decimal operations (such as casts
or arithmetic) into operations involving more primitive types (such as longs
and doubles).
Rule configuration.
A shuttle which converts decimal expressions to expressions based on
longs.
Rewrites a decimal expression for a specific set of SqlOperator's.
Collection of planner rules that apply various simplifying transformations on
RexNode trees.
Rule that reduces constants inside a
Calc.Rule configuration.
Shuttle that pushes predicates into a CASE.
Rule configuration.
Rule that reduces constants inside a
Filter.Rule configuration.
Rule that reduces constants inside a
Join.Rule configuration.
Rule that reduces constants inside a
Project.Rule configuration.
Helper class used to locate expressions that either can be reduced to
literals or contain redundant casts.
Replaces expressions with their reductions.
Rule that reduces constants inside a
Window.Rule configuration.
Represents a PseudoField that is implemented via a Java reflection
Field.Implementation of
NotNullImplementor
that calls a given Method.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).Implementation of a function that is based on a method.
Helps build lists of
FunctionParameter.Implementation of the
RelMetadataProvider interface that dispatches
metadata methods to methods on a given object via reflection.Implementation of
Schema that exposes the
public fields and methods in a Java object.Factory that creates a schema by instantiating an object and looking at
its public fields.
A ReflectiveSchema that does not return row count statistics.
ReflectiveSqlOperatorTable implements the
SqlOperatorTable interface
by reflecting the public fields of a subclass.Interface for looking up methods relating to reflective visitation.
Object which can be a target for a reflective visitation (see
ReflectUtil.invokeVisitor(ReflectiveVisitor, Object, Class, String).Static utilities for Java reflection.
Can invoke a method on an object of type E with return type T.
Builder for relational expressions.
Information necessary to create a call to an aggregate function.
Configuration of RelBuilder.
Information necessary to create the GROUP BY clause of an Aggregate.
Call to a windowed aggregate function.
A partially-created RelBuilder.
Description of the physical ordering of a relational expression.
Simple implementation of
RelCollation.Utilities concerning
RelCollation
and RelFieldCollation.Definition of the ordering trait.
Mapping from an input column of a
RelNode to
one of its output columns.RelColumnOrigin is a data structure describing one of the origins of an
output column produced by a relational expression.
An Exception thrown when attempting conversion to a set of
RelNodes.Type of the cartesian product of two or more sets of records.
RelDataType represents the type of a scalar expression or entire row returned
from a relational expression.
RelDataTypeComparability is an enumeration of the categories of comparison
operators which types may support.
RelDataTypeFactory is a factory for datatype descriptors.
Fluid API to build a list of fields.
Deprecated.
Deprecated.
Abstract base for implementations of
RelDataTypeFactory.RelDataTypeFamily represents a family of related types.
RelDataTypeField represents the definition of a field in a structured
RelDataType.Deprecated.
Use
RelDataTypeField::getIndexDeprecated.
Use
RelDataTypeField::getNameDefault implementation of
RelDataTypeField.RelDataTypeImpl is an abstract base for implementations of
RelDataType.RelDataTypePrecedenceList defines a type precedence list for a particular
type.
Type system.
Default implementation of
RelDataTypeSystem,
providing parameters from the SQL standard.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.
Planner rule that adjusts projects when counts are added.
Rule configuration.
Base configuration for rules that are non-static in a RelDecorrelator.
Builds a
RelDecorrelator.CorelMap.Planner rule that removes correlations for scalar aggregates.
Rule configuration.
Planner rule that removes correlations for scalar projects.
Rule configuration.
Rule to remove an Aggregate with SINGLE_VALUE.
Rule configuration.
The digest is the exact representation of the corresponding
RelNode,
at anytime, anywhere.Description of the physical distribution of a relational expression.
Type of distribution.
Utilities concerning
RelDistribution.Definition of the distribution trait.
Utility to dump a rel node plan in dot format.
Options for displaying the rel node plan in dot format.
Registry of
Enum classes that can be serialized to JSON.Contains factory interface and default implementation for creating various
rel nodes.
Can create a
LogicalAggregate of the appropriate type
for this rule's calling convention.Creates ASOF join of the appropriate type for a rule's calling convention.
Can create a correlate of the appropriate type for a rule's calling
convention.
Can create a
Exchange
of the appropriate type for a rule's calling convention.Can create a
Filter of the appropriate type
for this rule's calling convention.Can create a join of the appropriate type for a rule's calling convention.
Can create a
Match of
the appropriate type for a rule's calling convention.Can create a
LogicalProject of the
appropriate type for this rule's calling convention.Can create a
RepeatUnion of
the appropriate type for a rule's calling convention.Can create a
Sample of
the appropriate type for a rule's calling convention.Deprecated.
Use
RelFactories.JoinFactory instead.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.Can create a
Snapshot of
the appropriate type for a rule's calling convention.Implementation of
RelFactories.SnapshotFactory that
returns a vanilla LogicalSnapshot.Can create a
SortExchange
of the appropriate type for a rule's calling convention.Can create a
Sort of the appropriate type
for this rule's calling convention.Can create a
Spool of
the appropriate type for a rule's calling convention.Immutable record that contains an instance of each factory.
Can create a
TableFunctionScan
of the appropriate type for a rule's calling convention.Can create a
TableScan of the appropriate type for a rule's calling
convention.Can create a
Values of the appropriate type for a rule's calling
convention.Definition of the ordering of one field of a
RelNode whose
output is to be sorted.Direction that a field is ordered in.
Ordering of nulls.
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.Result of an attempt to trim columns from a relational expression.
Hint attached to a relation expression.
Builder for
RelHint.Customize the propagation of the
RelHints
from the root relational expression of a rule call RelOptRuleCall to
the new equivalent expression.Visits all the relations in a homogeneous way: always redirects calls to
accept(RelNode).This is a marker interface for a callback used to convert a tree of
relational expressions into a plan.Context from which a relational expression can initialize itself,
reading from a serialized form of the relational expression.
Utilities for converting
RelNode
into JSON format.Translates a JSON object that represents an input reference into a RexNode.
Reads a JSON plan and converts it back to a tree of relational expressions.
Callback for a relational expression to dump itself as JSON.
Utility to extract Predicates that are present in the (sub)plan
starting at this node.
RelMdCollation supplies a default implementation of
RelMetadataQuery.collations(org.apache.calcite.rel.RelNode)
for the standard logical algebra.RelMdColumnOrigins supplies a default implementation of
RelMetadataQuery.getColumnOrigins(org.apache.calcite.rel.RelNode, int) for the standard logical algebra.RelMdColumnUniqueness supplies a default implementation of
RelMetadataQuery.areColumnsUnique(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet) for the standard logical algebra.RelMdDistinctRowCount supplies a default implementation of
RelMetadataQuery.getDistinctRowCount(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet, org.apache.calcite.rex.RexNode) for the standard logical
algebra.RelMdCollation supplies a default implementation of
RelMetadataQuery.distribution(org.apache.calcite.rel.RelNode)
for the standard logical algebra.RelMdExplainVisibility supplies a default implementation of
RelMetadataQuery.isVisibleInExplain(org.apache.calcite.rel.RelNode, org.apache.calcite.sql.SqlExplainLevel) for the standard logical algebra.Default implementation of
RelMetadataQuery.getExpressionLineage(org.apache.calcite.rel.RelNode, org.apache.calcite.rex.RexNode) for the standard logical
algebra.Default implementations of the
BuiltInMetadata.LowerBoundCost
metadata provider for the standard algebra.RelMdMaxRowCount supplies a default implementation of
RelMetadataQuery.getMaxRowCount(org.apache.calcite.rel.RelNode) for the standard logical algebra.Default implementations of the
BuiltInMetadata.Measure
metadata provider for the standard logical algebra.Helpers for
BuiltInMetadata.Measure.Context.Implementation of Context that delegates to another Context.
Default implementations of the
BuiltInMetadata.Memory
metadata provider for the standard logical algebra.RelMdMinRowCount supplies a default implementation of
RelMetadataQuery.getMinRowCount(org.apache.calcite.rel.RelNode) for the standard logical algebra.RelMdNodeTypeCount supplies a default implementation of
RelMetadataQuery.getNodeTypes(org.apache.calcite.rel.RelNode) for the standard logical algebra.Default implementations of the
BuiltInMetadata.Parallelism
metadata provider for the standard logical algebra.RelMdPercentageOriginalRows supplies a default implementation of
RelMetadataQuery.getPercentageOriginalRows(org.apache.calcite.rel.RelNode) for the standard logical
algebra.RelMdPopulationSize supplies a default implementation of
RelMetadataQuery.getPopulationSize(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet) for the standard logical algebra.Utility to infer Predicates that are applicable above a RelNode.
RelMdRowCount supplies a default implementation of
RelMetadataQuery.getRowCount(org.apache.calcite.rel.RelNode) for the standard logical algebra.RelMdSelectivity supplies a default implementation of
RelMetadataQuery.getSelectivity(org.apache.calcite.rel.RelNode, org.apache.calcite.rex.RexNode) for the standard logical algebra.Default implementations of the
BuiltInMetadata.Size
metadata provider for the standard logical algebra.Default implementation of
RelMetadataQuery.getTableReferences(org.apache.calcite.rel.RelNode) for the
standard logical algebra.RelMdUniqueKeys supplies a default implementation of
RelMetadataQuery.getUniqueKeys(org.apache.calcite.rel.RelNode) for the standard logical algebra.RelMdUtil provides utility methods used by the metadata provider methods.
Parameters for a Metadata test.
A configuration that describes how metadata should be configured.
Generates the
MetadataHandler code.Contains Name and code that been generated for
MetadataHandler.RelMetadataProvider defines an interface for obtaining metadata about
relational expressions.
RelMetadataQuery provides a strongly-typed facade on top of
RelMetadataProvider for the set of relational expression metadata
queries defined as standard within Calcite.Base class for the RelMetadataQuery that uses the metadata handler class
generated by the Janino.
Trait for which a given relational expression can have multiple values.
A
RelNode is a relational expression.Context of a relational expression, for purposes of checking validity.
Utilities concerning relational expressions.
Partial implementation of
RelOptTable.An environment for related relational expressions during the
optimization of a query.
The planner's view of a connection to a database.
RelOptCost defines an interface for optimizer cost in terms of number of rows
processed, CPU cost, and I/O cost.
Cost model for query planning.
RelOptCostImpl provides a default implementation for the
RelOptCost
interface.A fixture for testing planner rules.
Use of a lattice by the query optimizer.
RelOptListener defines an interface for listening to events which occur
during the optimization process.
Event indicating that a relational expression has been chosen.
Event indicating that a relational expression has been discarded.
Event indicating that a relational expression has been found to
be equivalent to an equivalence class.
Event class for abstract event dealing with a relational expression.
Event indicating that a planner rule has been attempted.
Event indicating that a planner rule has fired.
Event indicating that a planner rule has produced a result.
Records that a particular query is materialized by a particular table.
Utility methods for using
materialized views and lattices for queries.
Node in a planner.
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.Thrown by
RelOptPlanner.findBestExp().Deprecated.
Use
RexExecutorPredicates that are known to hold in the output of a particular relational
expression.
A
RelOptQuery represents a set of
relational expressions which derive from the same
select statement.A
RelOptRule transforms an expression into another.Operand to an instance of the converter rule.
A
RelOptRuleCall is an invocation of a RelOptRule with a
set of relational expressions as arguments.Operand that determines whether a
RelOptRule
can be applied to a particular expression.Policy by which operands will be matched by relational expressions with
any number of children.
Deprecated.
A utility class for organizing built-in rules and rule related
methods.
RelOptSamplingParameters represents the parameters necessary to produce a
sample of a relation.
A
RelOptSchema is a set of RelOptTable objects.Extension to
RelOptSchema with support for sample data-sets.Represents a relational dataset in a
RelOptSchema.Contains the context needed to convert a a table into a relational
expression.
Can expand a view into relational expressions.
Implementation of
RelOptTable.RelOptUtil defines static utility methods for use in optimizing
RelNodes.Visitor which builds a bitmap of the inputs used by an expression.
Shuttle that finds the set of inputs that are used.
Policies for handling two- and three-valued boolean logic.
Walks an expression tree, converting the index of RexInputRefs based on
some adjustment factor.
What kind of sub-query.
Converts types to descriptive strings.
Visitor that finds all variables used in an expression.
Can be converted into a
RelDataType given a
RelDataTypeFactory.RelRecordType represents a structured type having named fields.
Interface for a referential constraint, i.e., Foreign-Key - Unique-Key relationship,
between two tables.
RelOptReferentialConstraint base implementation.
Root of a tree of
RelNode.Rule that is parameterized via a configuration.
Rule configuration.
Indicates that an operand is complete.
Callback interface that helps you avoid creating sub-classes of
RelRule that differ only in implementations of
RelOptRule.onMatch(RelOptRuleCall) method.Callback to create an operand.
Add details about an operand, such as its inputs.
Function that creates an operand.
Runs a relational expression.
Implementations of
RelRunner.Visitor that has methods for the common logical relational expressions.
Basic implementation of
RelShuttle that calls
RelNode.accept(RelShuttle) on each child, and
RelNode.copy(org.apache.calcite.plan.RelTraitSet, java.util.List) if
any children change.RelStructuredTypeFlattener removes all structured types from a tree of
relational expressions.
Mix-in interface for relational expressions that know how to
flatten themselves.
Subset of an equivalence class where all relational expressions have the
same physical properties.
Utility to convert relational expressions to SQL abstract syntax tree.
Utilities used by multiple dialect for RelToSql conversion.
RelTrait represents the manifestation of a relational expression trait within
a trait definition.
RelTraitDef represents a class of
RelTraits.Deprecated.
As of 1.19, if you need to perform certain assertions regarding a RelNode tree and
the contained traits you are encouraged to implement your own RelVisitor or
RelShuttle directly.RelTraitSet represents an ordered set of
RelTraits.Visitor that checks that every
RelNode in a tree is valid.A
RelVisitor is a Visitor role in the
visitor pattern and
visits RelNode objects as the role of Element.Callback for an expression to dump itself to.
Implementation of
RelWriter.Callback for a relational expression to dump in XML format.
Removes the holes of a geometry.
Geometry editor operation that removes a point to a geometry.
Removes repeated points from a geometry.
Relational expression that computes a repeat union (recursive union in SQL
terminology).
Utilities for
SqlTester.ResultChecker.Executes a SQL statement and returns the result as an
Enumerable.Consumer for decorating a
PreparedStatement, that is, setting
its parameters.A collection of return-type inference strategies.
Deprecated.
Analyzes an expression, figures out what are the unbound variables,
assigns a variety of values to each unbound variable, and evaluates
the expression.
Visitor pattern for traversing a tree of
RexNode objects
and passing a payload to each.Default implementation of
RexBiVisitor, which visits each node but
does nothing while it's there.Factory for row expressions.
An expression formed by a call to an operator with zero or more expressions
as operands.
RexCallBinding implements SqlOperatorBinding by
referring to an underlying collection of RexNode operands.Visitor which checks the validity of a
RexNode expression.Reference to the current row of a correlating relational expression.
Defines if type information should be printed for
RexLiteral.Dynamic parameter reference in a row-expression.
Result of compiling code generated from a
RexNode expression.Can reduce expressions, writing a literal for each into a list.
Evaluates a
RexNode expression.Access to a field of a row-expression.
Expression combined with sort flags (DESCENDING, NULLS LAST).
Checks whether one condition logically implies another.
Fixtures for verifying
RexImplicationChecker.Contains all the nourishment a test case could possibly need.
Contains implementations of Rex operators as Java code.
Implementor for the
LAG windowed aggregate function.Implementor for the
LEAD windowed aggregate function.Strategy what an operator should return if one of its
arguments is null.
Null-safe implementor of
RexCalls.Implementor for user-defined aggregate functions.
Variable which references a field of an input relational expression.
Evaluates
RexNode expressions.Represents a lambda expression.
Variable that references a field of a lambda expression.
Constant value in a row-expression.
Local variable.
Utility class for various methods related to multisets.
Row expression.
Context required to normalize a row-expression.
Call to an aggregate function over a window.
Deprecated.
Variable that references a field of an input relational expression.
Visitor which replaces
RexLocalRef objects after the expressions in a
RexProgram have been reordered.Shuttle which applies a permutation to its input fields.
A collection of expressions which read inputs, compute output expressions,
and optionally use a condition to filter rows.
Workspace for constructing a
RexProgram.Reference to a range of columns.
Passes over a row-expression, calling a handler method for each node,
appropriate to the type of the node.
Context required to simplify a row-expression.
Thread-safe list that populates itself if you make a reference beyond
the end of the list.
Collection of
RexSqlConvertlets.Implementation of
RexSqlConvertletTable.Standard implementation of
RexSqlConvertletTable.Scalar expression that represents an IN, EXISTS or scalar sub-query.
Variable which references a column of a table occurrence in a relational plan.
Identifies uniquely a table by its qualified name and its entity number
(occurrence).
Translates
REX expressions to
linq4j expressions.Translates a field of an input to an expression.
Implementation of
RexToLixTranslator.InputGetter that calls
PhysType.fieldReference(org.apache.calcite.linq4j.tree.Expression, int).Result of translating a
RexNode.Standard implementation of
RexToSqlNodeConverter.Takes a tree of
RexNode objects and transforms it into another in one
sense equivalent tree.Default implementation of a
RexBiVisitor whose payload and return
type are the same.Policy for whether a simplified expression may instead return another
value.
Utility methods concerning row-expressions.
Deprecated.
Visitor which builds a bitmap of the inputs used by an expression.
Shuttle that fixes up an expression to match changes in nullability of
input fields.
Visitor that tells whether a node matching a particular description exists
in a tree.
Visitor that collects all the top level SubQueries
RexSubQuery
in a projection list of a given Project.Visitor that throws
Util.FoundOne if
applied to an expression that contains a RexSubQuery.A row-expression which references a field.
Visitor pattern for traversing a tree of
RexNode objects.Default implementation of
RexVisitor, which visits each node but does
nothing while it's there.Specification of the window of rows over which a
RexOver windowed
aggregate is evaluated.Abstracts "XX PRECEDING/FOLLOWING" and "CURRENT ROW" bounds for windowed
aggregates.
Helpers for
RexWindowBound.Representation of different kinds of exclude clause in window functions.
The date/time format compiled component for the roman numeral representation of a
month.
The date/time format component for the roman numeral representation of a month.
Row.
Utility class to build row objects.
Listener for logging useful debugging information on certain rule events.
This is a tool to visualize the rule match process of a RelOptPlanner.
A data structure that manages rule matches for RuleDriver.
A set rules associated with a particular
type of invocation of the
Planner.Utilities for creating and composing rule sets.
Deprecated.
As of release 1.19,
replaced by
CalciteSystemPropertyHelper class.
Parameter type-checking strategy where the type of operand I must
be comparable with the type of operand I-1, for all legal values of I.
Parameter type-checking strategy where all operand types except last one must be the same.
Relational expression that returns a sample of the rows from its input.
Rule configuration.
Set of values (or ranges) that are the target of a search.
Compiled scalar expression.
Produces a
Scalar when a query is executed.Function that returns a scalar result.
Implementation of
ScalarFunction.Table that can be scanned without creating an intermediate relational
expression.
A namespace for tables and functions.
Table type.
Factory for
Schema objects.Extension to the
Schema interface.Utility functions for schemas.
An interface to represent a version ID that can be used to create a
read-consistent view of a Schema.
Called each time a search returns a record.
Namespace offered by a sub-query.
The name-resolution scope of a SELECT clause.
Extension to
SqlValidatorTable with extra, optional metadata.Planner rule that pushes
SemiJoins down in a tree past
a Filter.Rule configuration.
Rule configuration.
Rule configuration.
Planner rule that removes a
semi-join from a join
tree.Rule configuration.
Planner rule that creates a
SemiJoin from a
Join on top of a
LogicalAggregate or
on a RelNode which is
unique for join's right keys.Rule configuration.
SemiJoinRule that matches a Project on top of a Join with a RelNode
which is unique for Join's right keys.
Rule configuration.
SemiJoinRule that matches a Join with an empty Aggregate as its right
input.
Rule configuration.
SemiJoinRule that matches a Project on top of a Join with an Aggregate
as its right child.
Rule configuration.
Schema to which materializations can be added.
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.
Serializable wrapper around a
Charset.Executes DDL commands.
SetOp is an abstract base for relational set operators such
as UNION, MINUS (aka EXCEPT), and INTERSECT.Namespace based upon a set operation (UNION, INTERSECT, EXCEPT).
Parameter type-checking strategy for a set operator (UNION, INTERSECT,
EXCEPT).
Extension to
Visitor that returns a mutated tree.Simple
NamespaceContext implementation.Basic implementation of
Profiler.Specific type of RelDataType that corresponds to a single column table,
where column can have alias.
Abstract base class for relational expressions with a single input.
Collection of rules which simplify joins which have one of their input as constant relations
Values that produce a single row.Abstract class for all the SingleValuesOptimizationRules.
Rule configuration.
Sink to which to send rows.
Holder for various classes and functions used in tests as user-defined
functions and so forth.
UDF class that provides user-defined functions for each data type.
User-defined table-macro function with named and optional parameters.
Example of a UDF class that needs to be instantiated but cannot be.
Example of a UDF that has overloaded UDFs (same name, different args).
Example of a UDF with non-default constructor.
A table function that returns its input value.
Class with int and String fields.
The real MazeTable may be found in example/function.
UDF class that has multiple methods, some overloaded.
Example of a UDF with named parameters, some of them optional.
As
Smalls.MyPlusFunction but declared to be deterministic.Example of a UDF with a static
eval method.User-defined function that declares exceptions.
User-defined function with two arguments.
Example of a UDF with named parameters.
Example of a UDF with a non-static
eval method,
and named parameters.As
Smalls.MyPlusFunction but constructor has a
FunctionContext parameter.Example of a user-defined aggregate function (UDAF), whose methods are
static.
Example of a user-defined aggregate function that implements a generic
interface.
Example of a user-defined aggregate function (UDAF).
A table function that returns a
QueryableTable.Example of a user-defined aggregate function (UDAF), whose methods are
static.
Example of a user-defined aggregate function (UDAF), whose methods are
static.
Example of a non-strict UDF.
Example of a user-defined aggregate function (UDAF) with two parameters.
Another example of a user-defined aggregate function (UDAF) with two
parameters.
Example of a semi-strict UDF.
Example of a picky, semi-strict UDF.
Table with columns (A, B).
A table function that returns a
QueryableTable.Implementation of
TableMacro interface with
Smalls.SimpleTableMacro.apply(java.util.List<?>) method that returns Queryable table.User-defined table-macro function whose eval method is static.
User-defined function.
User-defined table-macro function.
User-defined table-macro function with named and optional parameters.
A table function that returns a
QueryableTable via a
static method.Table with a lot of columns.
Schema containing a
prod table with a lot of columns.Relational expression that returns the contents of a relation expression as
it was at a given time in the past.
A
SqlDialect implementation for the Snowflake database.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.
Relational expression that imposes a particular sort order on its input
without otherwise changing its content.
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.
Rule configuration.
Rule configuration.
This rule try to merge the double
Sort,one is Limit semantics,
another sort is Limit or TOPN semantics.Rule configuration.
Interpreter node that implements a
Sort.Rule configuration.
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.Rule configuration.
Rule that removes redundant
ORDER BY or LIMIT when its input
RelNode's maximum row count is less than or equal to specified row count.Rule configuration.
Planner rule that removes
a
Sort if its input is already sorted.Rule configuration.
Rule configuration.
Source of rows.
Source of data.
Utilities for
Source.Helper that combines the sorting process and accumulating process against the
aggregate execution, used with
LazyAggregateLambdaFactory.Extension to
StringReader that allows the original string to be
recovered.Utilities for space-filling curves.
Base class for Range implementations.
Range that is covered.
Range.
Lexicographic ordering for
SpaceFillingCurve2D.IndexRange.Utilities for
SpaceFillingCurve2D.IndexRange.Data representing a range.
Range that is not contained.
A 2-dimensional point.
Builder for
SqlParserPos.Implementation of
CalcitePrepare.SparkHandler.Built-in methods in the Spark adapter.
Relational expression that uses Spark calling convention.
Extension to
JavaRelImplementor that can handle Spark relational
expressions.Result of generating Java code to implement a Spark relational
expression.
Rules for the
Spark calling convention.Implementation of
Calc
in Spark convention.VALUES construct implemented in Spark.
Planner rule that implements VALUES operator in Spark convention.
Runtime utilities for Calcite's Spark adapter.
Combines linq4j
Function
and Spark FlatMapFunction.A
SqlDialect implementation for the APACHE SPARK database.Relational expression that converts input of
Spark convention
into EnumerableConvention.Collection of planner rules that convert
calls to spatial functions into more efficient expressions.
Rule that converts ST_DWithin in a Filter condition into a predicate on
a Hilbert curve.
Rule configuration.
Helper methods to implement spatial type (ST) functions in generated code.
Used at run time by the
SpatialTypeFunctions.ST_MakeGrid(org.locationtech.jts.geom.Geometry, java.math.BigDecimal, java.math.BigDecimal) and SpatialTypeFunctions.ST_MakeGridPoints(org.locationtech.jts.geom.Geometry, java.math.BigDecimal, java.math.BigDecimal) functions.Utilities for spatial types.
Geometry types, with the names and codes assigned by OGC.
Splits
geom by blade.Connection to Splunk.
Implementation of
SplunkConnection based on Splunk's REST API.Implementation of
SearchResultListener
interface that just counts the results.Implementation of
Enumerator that parses
results from a Splunk REST call.JDBC driver for Splunk.
Planner rule to push filters and projections to Splunk.
Rule configuration.
Query against Splunk.
Splunk schema.
Relational expression representing a scan of Splunk.
Relational expression that iterates over its input and, in addition to
returning its results, will forward them into other consumers.
Enumeration representing spool read / write type.
Abstract base class for implementing
SqlConformance.A SQL literal representing a DATE, TIME or TIMESTAMP value.
Base class for grouping functions
GROUP_ID, GROUPING_ID,
GROUPING.Base class for time functions such as "LOCALTIME", "LOCALTIME(n)".
Access type.
SqlAccessType is represented by a set of allowed access types.
An assistant which offers hints and corrections to a partially-formed SQL
statement.
Text and position info of a validator or parser exception.
Table function that returns completion hints for a given SQL statement.
Table function that returns completion hints for a given SQL statement.
This class is used to return values for
(String, int, String[]).This class is used to return values for
(String, int, String[]).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.Abstract base class for the definition of an aggregate function: an operator
which aggregates sets of values into a result.
Represents a type name for an alien system.
Base class for an ALTER statements parse tree nodes.
Definition of the
ANY_VALUE aggregate functions,
returning any one of the values which go into it.Definition of the SQL:2003 standard ARRAY query constructor,
ARRAY (<query>).Definition of the SQL:2003 standard ARRAY constructor,
ARRAY
[<expr>, ...].Parse tree node representing a
ASOF JOIN clause.Describes the syntax of the SQL ASOF JOIN operator.
The
AS operator associates an expression with an alias.Parse tree for SqlAttributeDefinition,
which is part of a
SqlCreateType.Avg is an aggregator which returns the average of the values
which go into it.Deprecated.
Parse tree for
CREATE TABLE statement, with extensions for particular
SQL dialects supported by Babel.Base class for functions such as "USER", "CURRENT_ROLE", and "CURRENT_PATH".
Concrete implementation of
SqlAggFunction.Implementation of
SqlCall that keeps its operands in an array.Concrete implementation of
SqlFunction.A sql type name specification of basic sql type.
Basic implementation of
SqlVisitor which does nothing at each node.Argument handler.
Default implementation of
SqlBasicVisitor.ArgHandler which merely calls
SqlNode.accept(org.apache.calcite.sql.util.SqlVisitor<R>) on each operand.Parse tree node representing a
BEGIN clause.Transaction mode.
Defines the BETWEEN operator.
Defines the "SYMMETRIC" and "ASYMMETRIC" keywords.
SqlBinaryOperator is a binary operator.A binary (or hexadecimal) string literal.
Definition of the
BIT_AND and BIT_OR aggregate functions,
returning the bitwise AND/OR of all non-null input values, or null if none.Extension to
StringBuilder for the purposes of creating SQL queries
and expressions.A
SqlCall is a call to an operator.SqlCallBinding implements SqlOperatorBinding by
analyzing to the operands of a SqlCall with a SqlValidator.A
SqlCase is a node of a parse tree which represents a case
statement.An operator describing a
CASE, NULLIF or
COALESCE expression.SqlCastFunction.
A character string literal.
Parse tree for
UNIQUE, PRIMARY KEY constraints.The
COALESCE function.A
SqlCollation is an object representing a Collate
statement.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 is the "table function derived table" operator.
A sql type name specification of collection type.
Parse tree for
UNIQUE, PRIMARY KEY constraints.SqlColumnListConstructor defines the non-standard constructor used to pass a
COLUMN_LIST parameter to a UDX.
Parse tree node representing a
COMMIT clause.Enumeration of valid SQL compatibility modes.
Enumeration of built-in SQL compatibility modes.
The
CONVERT function, which converts a string from one character
set to another.Definition of the SQL
COUNT aggregation function.Covar is an aggregator which returns the Covariance of the
values which go into it.Deprecated.
Base class for an CREATE statements parse tree nodes.
Parse tree for
CREATE FOREIGN SCHEMA statement.Parse tree for
CREATE FUNCTION statement.Parse tree for
CREATE MATERIALIZED VIEW statement.Parse tree for
CREATE SCHEMA statement.Parse tree for
CREATE TABLE statement.Parse tree for
CREATE TABLE LIKE statement.The LikeOption specify which additional properties of the original table to copy.
Parse tree for
CREATE TYPE statement.Parse tree for
CREATE VIEW statement.The
CURRENT_DATE function.SqlCursorConstructor defines the non-standard CURSOR(<query>)
constructor.
Represents a SQL data type specification in a parse tree.
A SQL literal representing a DATE value, such as
DATE
'2004-10-22'.SqlDatePartFunction represents the SQL:1999 standard
YEAR,
QUARTER, MONTH and DAY functions.Operator that adds an INTERVAL to a DATETIME.
A special operator for the subtraction of two DATETIMEs.
Base class for CREATE, DROP and other DDL statements.
Utilities concerning
SqlNode for DDL.File type for CREATE FUNCTION.
Implementation of
SqlConformance that delegates all methods to
another object.A
SqlDelete is a node of a parse tree which represents a DELETE
statement.A
SqlDescribeSchema is a node of a parse tree that represents a
DESCRIBE SCHEMA statement.A
SqlDescribeTable is a node of a parse tree that represents a
DESCRIBE TABLE statement.DESCRIPTOR appears as an argument in a function.
SqlDialect encapsulates the differences between dialects of SQL.Whether this JDBC driver needs you to pass a Calendar object to methods
such as
ResultSet.getTimestamp(int, java.util.Calendar).Information for creating a dialect.
Rough list of flavors of database.
Deprecated.
Creates a
SqlDialect appropriate
for a given database metadata object.The default implementation of a
SqlDialectFactory.Utilities related to
SqlDialect.Parse tree node representing a
DISCARD clause.The dot operator
., used to access a field of a
record.Base class for an DROP statements parse tree nodes.
Parse tree for
DROP FUNCTION statement.Parse tree for
DROP MATERIALIZED VIEW statement.Base class for parse trees of
DROP TABLE, DROP VIEW,
DROP MATERIALIZED VIEW and DROP TYPE statements.Parse tree for
DROP SCHEMA statement.Parse tree for
DROP TABLE statement.Parse tree for
DROP TYPE statement.Parse tree for
DROP VIEW statement.A
SqlDynamicParam represents a dynamic parameter marker in an
SQL statement.A
SqlExplain is a node of a parse tree which represents an
EXPLAIN PLAN statement.The level of abstraction with which to display the plan.
Output format for
EXPLAIN PLAN statement.SqlExplainLevel defines detail levels for EXPLAIN PLAN.
The SQL
EXTRACT operator.An operator that applies a filter before rows are included in an aggregate
function.
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.Definition of the "FLOOR" and "CEIL" built-in SQL functions.
Data structure to hold options for
SqlPrettyWriter.setFormatOptions(SqlFormatOptions).A
SqlFunction is a type of operator which has conventional
function-call syntax.SqlFunctionalOperator is a base class for special operators which use
functional syntax.
Enumeration of the categories of
SQL-invoked routines.
Helper methods to implement SQL functions in generated code.
State for
FORMAT_DATE, FORMAT_TIMESTAMP,
FORMAT_DATETIME, FORMAT_TIME, TO_CHAR functions.State for
FORMAT_DATE, FORMAT_TIMESTAMP,
FORMAT_DATETIME, FORMAT_TIME, TO_CHAR functions.State for
PARSE_DATE, PARSE_TIMESTAMP,
PARSE_DATETIME, PARSE_TIME functions.Type of argument passed into
SqlFunctions.flatProduct(int[], boolean, org.apache.calcite.runtime.SqlFunctions.FlatProductInputType[]).Specifies scope to search for
#containsSubstr.State for
LIKE, ILIKE.State for
PARSE_URL.State for posix regex function.
State for
REGEXP_CONTAINS, REGEXP_EXTRACT, REGEXP_EXTRACT_ALL,
REGEXP_INSTR, REGEXP_REPLACE, RLIKE.State for
SIMILAR function with escape.State for
SIMILAR function.SQL function that computes keys by which rows can be partitioned and
aggregated.
A
SqlHint is a node of a parse tree which represents
a sql hint expression.Enumeration that represents hint option format.
HISTOGRAM is the base operator that supports the Histogram
MIN/MAX aggregate functions.SqlHopTableFunction implements an operator for hopping.
A
SqlIdentifier is an identifier, possibly compound.An implementation of
SqlMoniker that encapsulates the normalized name
information of a SqlIdentifier.State for generating a SQL statement.
Clauses in a SQL query.
Simple implementation of
SqlImplementor.Context that cannot handle sub-queries
or correlations.A generalization of a binary operator to involve several (two or more)
arguments, and keywords between each pair of arguments.
Definition of the SQL
IN operator, which tests for a value's
membership in a sub-query or a list of values.A
SqlInsert is a node of a parse tree which represents an INSERT
statement.Defines the keywords that can occur immediately after the "INSERT" keyword.
Generic operator for nodes with internal syntax.
Contains internal operators.
A SQL literal representing a time interval.
A Interval value.
Interval expression.
Represents an INTERVAL qualifier.
The item operator
[ ... ], used to access a given element of an
array, map or struct.Defines the name of the types which can occur as a type argument
in a JDBC
{fn CONVERT(value, type)} function.A
SqlJdbcFunctionCall is a node of a parse tree which represents
a JDBC function call.Converter that calls a built-in function with the same arguments.
Parse tree node representing a
JOIN clause.Describes the syntax of the SQL
JOIN operator.The
JSON_OBJECTAGG aggregate function.The
JSON_ARRAY function.Indicating how JSON constructors handle null.
The
JSON_DEPTH function.Flag to indicate if the json value is missing or an error is thrown where
EmptyOrErrorBehavior is invoked.
Supported json encodings that could be passed to a
JsonValueExpression.Categorizing Json exists error behaviors.
The
JSON_EXISTS function.The
JSON_KEYS function.The
JSON_LENGTH function.Definition of the
JSON_INSERT, JSON_REPLACE
and JSON_SET JSON Modify functions.The
JSON_OBJECTAGG aggregate function.The
JSON_OBJECT function.The
JSON_TYPE function.Categorizing Json query empty or error behaviors.
The
JSON_QUERY function.How json query function handle array result.
The
JSON_REMOVE function.The
JSON_STORAGE_SIZE function.The
JSON_TYPE function.Categorizing Json value empty or error behaviors.
The JSON value expression operator that indicates that the value expression
should be parsed as JSON.
The
JSON_VALUE function.Flag to indicate the explicit return type of JSON_VALUE.
Parse tree for
UNIQUE, PRIMARY KEY constraints.Enumerates the possible types of
SqlNode.A
SqlLambda is a node of a parse tree which
represents a lambda expression.Scope for a
LAMBDA EXPRESSION.An operator describing a LATERAL specification.
LEAD and LAG aggregate functions
return the value of given expression evaluated at given offset.A library is a collection of SQL functions and operators.
Defines functions and operators that are not part of standard SQL but
belong to one or more other dialects of SQL.
Factory that creates operator tables that consist of functions and operators
for particular named libraries.
An operator describing the
LIKE and SIMILAR
operators.A
SqlLiteral is a constant.Deprecated.
The
LITERAL_AGG aggregate function.Internal operator, by which the parser represents a continued string literal.
Definition of the MAP query constructor,
MAP (<query>).Parse SQL MAP type, i.e.
Definition of the MAP constructor,
MAP [<key>, <value>, ...].Base class for all functions used in MATCH_RECOGNIZE.
SqlNode for MATCH_RECOGNIZE clause.
Options for
AFTER MATCH clause.Options for
ROWS PER MATCH.An operator describing a MATCH_RECOGNIZE specification.
The
MEASURE wraps an expression in the SELECT clause and tags
it as a measure.A
SqlMerge is a node of a parse tree which represents a MERGE
statement.Definition of the
MIN and MAX aggregate functions,
returning the returns the smallest/largest of the values which go into it.Relational or streaming.
An interface of an object identifier that represents a SqlIdentifier.
A generic implementation of
SqlMoniker.An enumeration of moniker types.
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.Enumeration of types of monotonicity.
Base class for unary operators such as FLOOR/CEIL which are monotonic for
monotonic inputs.
Multiset MEMBER OF.
Definition of the SQL:2003 standard MULTISET query constructor,
MULTISET (<query>).An operator which performs set operations on multisets, such as "MULTISET
UNION ALL".
Definition of the SQL:2003 standard MULTISET constructor,
MULTISET
[<expr>, ...].Checks whether two names are the same according to a case-sensitivity policy.
Helpers for
SqlNameMatcher.SqlNewOperator represents an SQL
new specification such as
NEW UDT(1, 2).A
SqlNode is a SQL parse tree.A
SqlNodeList is a list of SqlNodes.Standard implementation of
SqlNodeToRexConverter.This class provides non-nullable accessors for common getters.
NTH_VALUE windowed aggregate function
returns the value of an expression evaluated at the nth row of the
window frame.NTILE aggregate function
return the value of given expression evaluated at given offset.The
NULLIF function.SqlNullSemantics defines the possible comparison rules for values which might
be null.
An operator that decides how to handle null input
(
RESPECT NULLS and IGNORE NULLS).A numeric SQL literal.
A class that describes how many operands an operator can take.
Helpers for
SqlOperandCountRange.Strategy interface to process operands of an operator call.
Extension to
SqlOperandTypeChecker that also provides
names and types of particular operands.Strategy interface to check for allowed operand types of an operator call.
Strategy used to make arguments consistent.
Strategy to infer unknown types of the operands of an operator call.
A
SqlOperator is a type of node in a SQL parse tree (it is NOT a
node in a SQL parse tree).SqlOperatorBinding represents the binding of an
SqlOperator to actual operands, along with any additional information
required to validate those operands if needed.A fixture for testing the SQL operators.
Types for cast.
Name of a virtual machine that can potentially implement an operator.
SqlOperatorTable defines a directory interface for enumerating and looking up
SQL operators and functions.
Utilities for
SqlOperatorTables.Contains unit tests for all operators.
Implementation of
SqlTester based on a
JDBC connection.Parse tree node that represents an
ORDER BY on a query other than a
SELECT (e.g.SqlOverlapsOperator represents the SQL:1999 standard
OVERLAPS
function.The
OVERLAY function.An operator describing a window function specification.
SqlParseException defines a checked exception corresponding to
SqlParser.A
SqlParser parses a SQL statement.Interface to define the configuration for a SQL parser.
Deprecated.
Helper class for building fluent parser tests such as
sql("values 1").ok();.Factory for
SqlAbstractParserImpl objects.SqlParserPos represents the position of a parsed token within SQL statement
text.
A
SqlParserTest is a unit-test for
the SQL parser.Callback to control how test actions are performed.
Default implementation of
SqlParserTest.Tester.Implementation of
SqlParserTest.Tester which makes sure that the results of
unparsing a query are consistent with the original query.Utility methods relating to parsing SQL.
Thrown by
SqlParserUtil.replaceEscapedChars(String).The components of a collation definition, per the SQL standard.
Class that holds a
SqlOperator and a SqlParserPos.Parse tree node that represents a PIVOT applied to a table reference
(or sub-query).
The
POSITION function.An operator describing the
~ operator.A postfix unary operator.
A unary operator.
Pretty printer for SQL statements.
SqlProcedureCallOperator represents the CALL statement.
Fully-qualified identifier.
Definition of the SQL
ALL and SOMEoperators.The
RAND_INTEGER function.Operator which aggregates sets of values into a result.
Definition of the SQL
REGR_COUNT aggregation function.Strategy interface to infer the type of an operator call from the type of the
operands.
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.Contains the context necessary for a
SqlRexConvertlet to convert a
SqlNode expression into a RexNode.Collection of
SqlRexConvertlets.Parse tree node representing a
ROLLBACK clause.SqlRowOperator represents the special ROW constructor.
A sql type name specification of row type.
Specification of a SQL sample.
Sample specification that orders substitution.
Sample specification.
Refinement to
SqlShuttle which maintains a stack of scopes.A
SqlSelect is a node of a parse tree which represents a select
statement.Defines the keywords which can occur immediately after the "SELECT" keyword.
An operator describing a query.
Operator that returns the current or next value of a sequence.
SqlSessionTableFunction implements an operator for per-key sessionization.
SqlSetOperator represents a relational set theory operator (UNION, INTERSECT,
MINUS).
SQL parse tree node to represent
SET and RESET statements,
optionally preceded by ALTER SYSTEM or ALTER SESSION.SetSemanticsTable appears as an parameter in a table function.
Command that executes its arguments as a SQL query
against Calcite's OS adapter.
Parse tree node representing a
SHOW clause.Basic implementation of
SqlVisitor which returns each leaf node
unchanged.A simple parser that takes an incomplete and turn it into a syntactically
correct statement.
Token representing an identifier.
Token.
Tokenizer.
SqlSingleOperandTypeChecker is an extension of
SqlOperandTypeChecker
for implementations which are capable of checking the type of a single
operand in isolation.Aggregate function that knows how to convert itself to a scalar value
when applied to a single row.
SINGLE_VALUE aggregate function returns the input value if there
is only one value in the input; Otherwise it triggers a run-time error.Parse tree node for "
FOR SYSTEM_TIME AS OF" temporal clause.An operator describing a FOR SYSTEM_TIME specification.
Utilities for spatial type functions.
Returns the geometries of a geometry.
Returns the points or rectangles in a grid that covers a given
geometry.
Implementation of
SqlSpatialTypeOperatorTable containing
the spatial operators and functions.Generic operator for nodes with special syntax.
List of tokens: the input to a parser.
Aggregate function that can be split into partial aggregates.
Common splitting strategy for
SUM and SUM0 functions.Splitting strategy for
COUNT.Collection in which one can register an element.
Aggregate function that splits into two applications of itself.
Splitting strategy for
SUM0 function.Splitting strategy for
SUM function.Deprecated.
Use
org.apache.calcite.avatica.SqlStateAggregate function whose value may be a constant expression, based on
only the contents of the GROUP BY clause.
Estimates row counts for tables and columns, and whether combinations of
columns form primary/unique and foreign keys.
Implementation of
SqlOperatorTable containing
the standard operators and functions.String that represents a kocher SQL statement, expression, or fragment.
Base class for string functions such as "USER", "CURRENT_ROLE", and
"CURRENT_PATH".
Definition of the "SUBSTRING" builtin SQL function.
Sum is an aggregator which returns the sum of the values which
go into it.Sum0 is an aggregator which returns the sum of the values which
go into it like Sum.Enumeration of possible syntactic types of
operators.A function that returns a table.
A
SqlTableRef is a node of a parse tree which represents
a table reference.Callback for testing SQL queries and expressions.
Parameter checker.
Result checker.
Type checker.
Action that is called after validation.
A function to apply to the result of validation.
Name of a virtual machine that can potentially implement an operator.
As
SqlTestFactory but has no state, and therefore
configuration is passed to each method.Creates a
SqlValidatorCatalogReader for tests.Creates a
RelOptPlanner for tests.Creates a
RelDataTypeFactory for tests.Creates
SqlValidator for tests.Utility methods.
Stage of query processing.
Type checker which compares types to a specified string.
An internal operator that throws an exception.
A SQL literal representing a TIME value, for example
TIME
'14:33:44.567'.Indicates that an operation timed out.
The
TIMESTAMPADD function, which adds an interval to a
datetime (TIMESTAMP, TIME or DATE).A SQL literal representing a TIMESTAMP value, for example
TIMESTAMP
'1969-07-21 03:15'.A SQL literal representing a TIMESTAMP WITH TIME ZONE value, for example
TIMESTAMP
'1969-07-21 03:15 GMT+00:00'.A SQL literal representing a TIME WITH TIME ZONE value, for example
TIME WITH TIME ZONE
'14:33:44.567 GMT+08'.Interface to define the configuration for a SqlToRelConverter.
Visitor that looks for an SqlIdentifier inside a tree of
SqlNode objects and return Boolean.TRUE when it finds
one.Parameters for a SQL-to-RelNode test.
SqlToRelTestBase is an abstract base for tests which involve conversion from
SQL to relational algebra.
Custom implementation of Correlate for testing.
Definition of the "TRANSLATE" built-in SQL function that takes 3 arguments.
Common base for the
TRANSLATE(USING) and
CONVERT(USING) function, which is different from
SqlLibraryOperators.TRANSLATE3 and
SqlLibraryOperators.MSSQL_CONVERT.Definition of the "TRIM" builtin SQL function.
Defines the enumerated values "LEADING", "TRAILING", "BOTH".
Base class for an TRUNCATE statements parse tree nodes.
Parse tree for
TRUNCATE TABLE statement.SqlTumbleTableFunction implements an operator for tumbling.
Rules that determine whether a type is assignable from another type.
Rules that determine whether a type is castable from another type.
Type Constructor function.
SqlTypeExplicitPrecedenceList implements the
RelDataTypePrecedenceList interface via an explicit list of
SqlTypeName entries.SqlTypeFactoryImpl provides a default implementation of
RelDataTypeFactory which supports SQL types.SqlTypeFamily provides SQL type categorization.
Interface that defines rules within type mappings.
This class defines some utilities to build type mapping matrix
which would then use to construct the
SqlTypeMappingRule rules.Keeps state while building the type mappings.
Enumeration of the type names which can be used to construct a SQL type.
Limit.
A
SqlTypeNameSpec is a type name specification that allows user to
customize sql node unparsing and data type deriving.Strategy to transform one type to another.
Strategy to infer the type of an operator call from the type of the operands
by using one
SqlReturnTypeInference rule and a combination of
SqlTypeTransforms.SqlTypeTransforms defines a number of reusable instances of
SqlTypeTransform.Contains utility methods used during SQL validation or type derivation.
Literal whose type is not yet known.
The
UNNEST operator.Parse tree node that represents UNPIVOT applied to a table reference
(or sub-query).
Placeholder for an unresolved function.
A
SqlUpdate is a node of a parse tree which represents an UPDATE
statement.User-defined aggregate function.
User-defined scalar function.
User-defined table function.
User-defined table macro.
A sql type name specification of user defined type.
Contains utility functions related to SQL parsing, all static.
Handles particular
DatabaseMetaData methods; invocations of other
methods will fall through to the base class,
BarfingInvocationHandler, which will throw
an error.Validates the parse tree of a SQL statement, and provides semantic
information about the parse tree.
Interface to define the configuration for a SqlValidator.
Supplies catalog information for
SqlValidator.Exception thrown while validating a SQL statement.
A fixture for testing the SQL validator.
Default implementation of
SqlValidator.Common base class for DML statement namespaces.
Utility object used to maintain information about the parameters in a
function call.
Information about an identifier in a particular scope.
Validation status.
A namespace describes the relation returned by a section of a SQL query.
Name-resolution scope.
A path that has no steps.
A sequence of steps by which an identifier was resolved.
A match found when looking up a name.
Default implementation of
SqlValidatorScope.Resolved.A step in resolving an identifier.
Supplies a
SqlValidator with the metadata for a table.An abstract base class for implementing tests against
SqlValidator.Implementation of
SqlTester that can parse and validate SQL,
and convert it to relational algebra.Utility methods related to validation.
Deprecated.
Flattens any FILTER, WITHIN DISTINCT, WITHIN GROUP surrounding a call to
an aggregate function.
Suggests candidates for unique names, given the number of attempts so far
and the number of expressions in the project list.
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).The
VALUES operator.Visitor class, follows the
visitor pattern.SQL window specification.
Base class for a table-valued function that computes windows.
Partial implementation of operand type checker.
The WITH clause of a query.
An operator that applies a distinct operation before rows are included in an
aggregate function.
An operator that applies a sort operation before rows are included in an aggregate function.
Used for PERCENTILE_DISC return type inference.
An item in a WITH clause of a query.
A
SqlWithItemTableRef is a node created during validation for
recursive queries which represents a table reference in a WITH RECURSIVE clause.A
SqlWriter is the target to construct a SQL statement from a
parse tree.A Frame is a piece of generated text which shares a common indentation
level.
Frame type.
Enumerates the types of frame.
Style of formatting sub-queries.
Configuration for
SqlWriter and SqlPrettyWriter.Policy for how to do deal with long lines.
Deprecated.
A helper class for generating formatted text.
Standard implementation of
SqlRexConvertletTable.A
SqlDialect implementation for the StarRocks database.Virtual table that is composed of two or more tables joined together.
Relational expression that scans a
StarTable.Statement.
A table function that returns states and their boundaries; also national
parks.
Definitions of objects to be statically imported.
Statistics about a
Table.Utility functions regarding
Statistic.Table function that reads stdin and returns one row per line.
Table that can be converted to a stream.
Rules and relational operators for streaming relational expressions.
Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
Rule configuration.
Planner rule that converts
Delta over a TableScan of
a table other than StreamableTable to
an empty Values.Rule configuration.
Rule configuration.
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.
The base implementation of strict aggregate function.
The base implementation of strict window aggregate function.
Contains a string, the offset of a token within the string, and a parser
position containing the beginning and end line number.
Example query for checking query projections.
Utility methods for encoding and decoding strings for Splunk REST calls.
Utilities for strong predicates.
How whether an operator's operands are null affects whether a call to
that operator evaluates to null.
Describes a policy for resolving fields in record types.
SubQueryConverter provides the interface for classes that convert sub-queries
into equivalent expressions.
Transform that converts IN, EXISTS and scalar sub-queries into joins.
Rule configuration.
A rule that implements this interface indicates that the new RelNode
is typically better than the old one.
Substitutes part of a tree of relational expressions with another tree.
Abstract base class for implementing
SubstitutionVisitor.UnifyRule.Exception thrown to exit a matcher.
Operand to a
SubstitutionVisitor.UnifyRule.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.Rule that attempts to match a query relational expression
against a target relational expression.
Converts Calcite SUBSTRING call to Druid Expression when possible.
Represents one case of a
SwitchStatement.Represents a control expression that handles multiple selections by passing
control to
SwitchCase.A
SqlDialect implementation for the Sybase database.Sub-class should be a Enum and can convert to a
SqlLiteral.Table function that executes the OS "system_info".
Table.
Deprecated.
As of 1.30.0, if you need to know how tables in a plan are accessed you are
encouraged to implement your own logic (using a RelNode visitor or other).
Access mode.
A table-valued input parameter of a table function is classified by three
characteristics.
Builder for
TableCharacteristic.Input table has either row semantics or set semantics.
Enumerates the collection type of a table:
MULTISET allows duplicates
and SET does not.Namespace for a table constructor
VALUES (expr, expr, ...).Factory for creating table expressions that may be used in generated code
for accessing table data.
Factory for
Table objects.Function that returns a table during execution time.
Implements a table-valued function call.
Implementation of
TableFunction based on a
method.TableFunctionReturnTypeInference implements rules for deriving table function
output row types by expanding references to cursor parameters.
Relational expression that calls a table-valued function.
Interpreter node that implements a
TableFunctionScan.Function that returns a
Table.Implementation of
TableMacro based on a
method.Relational expression that modifies a table.
Enumeration of supported modification operations.
Relational operator that returns the contents of a table.
Interpreter node that implements a
TableScan.Deprecated.
org.apache.calcite.rel.core.RelFactories.TableScanFactoryImpl
has called RelOptTable.toRel(RelOptTable.ToRelContext).Rule configuration.
Spool that writes into a table.
String template.
Table that is temporal.
A
SqlDialect implementation for the Teradata database.Represents an expression that has a ternary operator.
Static utilities for JUnit tests.
Represents a
throw statement.Definition of a particular combination of dimensions and measures of a
lattice that is the basis of a materialization.
Algorithm that suggests a set of initial tiles (materialized aggregate views)
for a given lattice.
Implementation of Druid time format extraction function.
Time frame.
Utilities for
TimeFrame.Set of
TimeFrame definitions.Builds a collection of time frames.
Timestamp literal.
Timestamp with time-zone literal.
Time literal.
Time with time-zone literal.
The date/time format compiled component for the 3 letter timezone code (such as UTC).
The date/time format component for the 3 letter timezone code (such as UTC).
The date/time format compiled component for the hours of the timezone offset.
The date/time format component for the hours of the timezone offset.
The date/time format compiled component for the minutes of the timezone offset.
The date/time format component for the minutes of the timezone offset.
The date/time format compiled component for the hours and minutes of the timezone offset.
The date/time format component for the hours and minutes of the timezone offset.
Shuttle to convert any rel plan to a plan with all logical nodes.
Iterates over the edges of a graph in topological order.
Schema that provides TPC-DS tables, populated according to a
particular scale factor.
Factory that creates a
TpcdsSchema.Schema that provides TPC-H tables, populated according to a
particular scale factor.
TPC-H table schema.
Customer in TPC-H.
Line Item in TPC-H.
Part in TPC-H.
Part supplier in TPC-H.
Factory that creates a
TpchSchema.TraitMatchingRule adapts a converter rule, restricting it to fire only when
its input already matches the expected output trait.
Rule configuration.
Logical transformation rule, only logical operator can be rule operand,
and only generate logical alternatives.
Enumerator that applies a transform to each value from a backing
enumerator.
A transient table is a named table that may come into existence implicitly during the
evaluation of a query expression or the execution of a trigger.
Extension to
Table that specifies how it is to be translated to
a relational expression.Represents a
try ... catch ... finally block.Thread-local variable that returns a handle that can be closed.
Remembers to set the value back.
Represents an operation between an expression and a type.
Default strategies to coerce differing types that participate in
operations into compatible ones.
Factory for
TypeCoercion objects.Default implementation of Calcite implicit type cast.
Factory class for type coercion instantiation of different sql dialects.
Adds type information to a
Enumerable.Array type.
Map type.
Field that belongs to a record.
Base class for record-like types that do not mapped to (currently
loaded) Java
Class objects.Represents an expression that has a unary operator.
Unary prefix Operator conversion class; used to convert expressions like
Unary NOT and Minus.
Unary suffix operator conversion; used to convert function likes expression
Unary_Operator.
Metadata that needs to be bound to a
RelNode and
RelMetadataQuery before it can be used.Relational expression that unnests its input's columns into a relation.
Interpreter node that implements a
Uncollect.Relational expression that returns the union of the rows of its inputs,
optionally eliminating duplicates.
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.Rule configuration.
Rule configuration.
Deprecated.
Use
SetOpNodeUsed at run time by the ST_Union function.
Planner rule that pulls up constants through a Union operator.
Rule configuration.
Rule configuration.
Rule configuration.
Synthetic record with zero fields.
A view onto an array that cannot be modified by the client.
Namespace for an
UNPIVOT clause.Scope for expressions in an
UNPIVOT clause.Contains methods that call JDK methods that the
forbidden
APIs checker does not approve of.
Contains methods that call JDK methods that the
forbidden
APIs checker does not approve of.
This class is used to disable SSL Certificate Verification in Calcite adapters that make http
calls.
A collection of functions used in Url processing.
Miscellaneous utility functions.
Exception used to interrupt a tree walk of any kind.
Visitor which looks for an OVER clause inside a tree of
SqlNode objects.Utility methods called by generated code.
An Exception thrown when attempting to validate a SQL parse tree.
Relational expression whose value is a sequence of zero or more literal row
values.
Interpreter node that implements a
Values.Planner rule that folds projections and filters into an underlying
LogicalValues.Rule configuration.
Version string parsed into major and minor parts.
A
SqlDialect implementation for the Vertica database.Utilities for
RelOptTable.ViewExpander and
RelOptTable.ToRelContext.Table whose contents are defined using an SQL statement.
Table function that implements a view.
Druid Json Expression based Virtual Column.
Virtual Column builder.
Define column strategies for the "VIRTUALCOLUMNS" table.
Node visitor.
DataContext for evaluating a RexExpression.
Default implementation of
Visitor, which traverses a tree but does
nothing.Table function that executes the OS "vmstat" command
to share memory statistics.
VolcanoPlanner optimizes queries by transforming expressions selectively
according to a dynamic programming algorithm.
Deprecated.
VolcanoRuleCall implements the RelOptRuleCall interface
for VolcanoPlanner.Indicates that planning timed out.
Represents a "while" statement.
Information for a call to
AggImplementor.implementAdd(AggContext, AggAddContext).Implementation of
WinAggAddContext.Marker interface to allow
AggImplementor
to tell if it is used in regular or windowed context.Provides information on the current window.
Provides information on the current window when computing the result of
the aggregation.
Implements a windowed aggregate function by generating expressions to
initialize, add to, and get a result from, an accumulator.
Allows to access rows in window partition relative to first/last and
current row.
Information for a call to
AggImplementor.implementReset(AggContext, AggResetContext).Implementation of
WinAggResetContext.Information for a call to
AggImplementor.implementResult(AggContext, AggResultContext).Implementation of
WinAggResultContext.A relational expression representing a set of window aggregates.
Group of windowed aggregate calls that have the same window specification.
A call to a windowed aggregate function.
Interpreter node that implements a
Window.Namespace for
WITH clause.Mix-in interface that allows you to find sub-objects.
A collection of functions used in Xml processing.
Streaming XML output.
The date/time format compiled component for the year formatted with a comma after
the thousands (such as "2,024").
The date/time format component for the year formatted with a comma after the thousands
(such as "2,024").
Join.