Enumerator that reads from a collection of Arrow value-vectors.

Abstract base class for implementations of OS table functions.

Holds intermediate state from which a RexImpTable can be constructed.

Implementation of {@link CachingCalciteSchema.Cached} that drives from {@link CachingCalciteSchema#cache}. @param <T> element type

Abstract base to handle {@link SQLException}s.

Converts a relational expression to any given output convention. <p>Unlike most {@link org.apache.calcite.rel.convert.Converter}s, an abstract conver

Abstract implementation of the {@link Enumerable} interface that implements the extension methods. <p>It is helpful to derive from this class if you

Abstract implementation of the {@link org.apache.calcite.linq4j.Enumerable} interface that implements the extension methods. <p>It is helpful to deri

Just a little trick to store factory ref before field init in fixture.

Base class for flat lists. @param <T> element type

Base class that allows sharing same geode instance across all tests. <p>Also, due to legacy reasons, there can't be more than one Geode instance (run

Base class for lists whose contents are constant after creation. @param <E> Element type

Extension to {@link com.google.common.collect.UnmodifiableListIterator} that operates by index. @param <E> element type

Rule to convert a {@link org.apache.calcite.rel.core.Sort} to a {@link InnodbSort}. @param <C> The rule configuration type.

Rule to convert an {@link org.apache.calcite.rel.core.Join inner join} to a {@link org.apache.calcite.rel.core.Filter filter} on top of a {@link org.a

Abstract implementation of {@link Mapping}.

Abstract base class for implementations of {@link ModifiableTable}.

Abstract base class for implementations of {@link ModifiableTable}.

Abstract base class for implementations of {@link ModifiableView}.

Abstract implementation of {@link SqlValidatorNamespace}.

Abstract implementation of {@link Node}.

Partial implementation of operand type checker.

Base class for all implementations of PairList. @param <T> First type @param <U> Second type

Base class for implementations of {@link Pattern}.

Common methods inheritable by all Pig-specific test classes.

Abstract implementation of {@link PreparingTable} with an implementation for {@link #columnHasDefaultValue}.

Abstract implementation of the {@link Queryable} interface that implements the extension methods. <p>It is helpful to derive from this class if you a

Abstract base class for implementing {@link org.apache.calcite.schema.Table}.

Base class for Range implementations.

Base class for every relational expression ({@link RelNode}).

A benchmark of alternative implementations for {@link AbstractRelNode#getRelTypeName()} method.

Abstract base for implementations of the {@link RelOptPlanner} interface.

Abstract implementation of the {@link RexCallImplementor} interface. <p>It is not always safe to execute the {@link RexCall} directly due to the spec

Abstract implementation of {@link Schema}. <p>Behavior is as follows: <ul> <li>The schema has no tables unless you override {@link #getTableM

An interpreter that takes expects one incoming source relational expression. @param <T> Type of relational expression

Simple implementation of {@link org.apache.calcite.util.mapping.Mappings.TargetMapping} where the number of sources and targets are specified as const

Abstract implementation of {@link SqlTester} that talks to a mock catalog. <p>This is to implement the default behavior: testing is only against the

Abstract base class for SQL implementations of {@link RelDataType}.

Common splitting strategy for {@code SUM} and {@code SUM0} functions.

Abstract base class for implementing {@link Table}. <p>Sub-classes should override {@link #isRolledUp} and {@link Table#rolledUpColumnValidInsideAgg(

Abstract implementation of {@link org.apache.calcite.linq4j.Queryable} for {@link QueryableTable}. <p>Not to be confused with {@link org.apache.calci

Simple implementation of {@link org.apache.calcite.util.mapping.Mappings.TargetMapping} where the number of sources and targets are specified as const

Base class for all the type coercion rules. If you want to have a custom type coercion rules, inheriting this class is not necessary, but would have s

Abstract base class for implementing {@link UnifyRule}.

A <code>SqlDialect</code> implementation for the Access database.

Refinement of JavaSourceClassLoader which keeps track of the total bytecode length of the classes it has compiled.

Used at run time by the ST_Accum function.

Defines function implementation for things like {@code count()} and {@code sum()}.

Decorator class of a sequence of accumulator adder functions.

Creates an {@link Accumulator}.

A list of accumulators used during grouping.

Callback for {@link #check}. Test code will typically use {@code builder} to create some expressions, call {@link org.apache.calcite.rex.RexExecutorIm

Rule that adds an intermediate node above the {@link PhysLeafRel}.

Geometry editor operation that adds a point to a geometry.

Post-processor that adds a {@link Schema} and sets it as default.

Post-processor that adds a {@link CalciteAssert.SchemaSpec} (set of schemes) to a connection.

Post-processor that adds a type.

Operation that adds a z value to a geometry.

Iterator that returns consecutive pairs of elements from an underlying iterator. @param <E> Element type

Planner rule that adjusts projects when counts are added.

Rule configuration.

Options for {@code AFTER MATCH} clause.

Information for a call to {@link org.apache.calcite.adapter.enumerable.AggImplementor#implementAdd(AggContext, AggAddContext)}. <p>Typically, the agg

Implementation of {@link org.apache.calcite.adapter.enumerable.AggAddContext}.

Working state for {@link #aggregateRex}.

Information necessary to create a call to an aggregate function. @see RelBuilder#aggregateCall

Implementation of the {@link SqlOperatorBinding} interface for an {@link AggregateCall aggregate call} applied to a set of operands in the context of

Implementation of {@link AggCall}.

Implementation of {@link AggCall} that wraps an {@link AggregateCall}.

Internal methods shared by all implementations of {@link AggCall}.

Visitor which throws an exception if any component of the expression is not a group expression.

Information on the aggregate calculation context. {@link AggAddContext} provides basic static information on types of arguments and the return value o

An implementation of {@link AggContext}.

Converts expressions to aggregates. <p>Consider the expression <blockquote> {@code SELECT deptno, SUM(2 sal) FROM emp GROUP BY deptno} </blockquote>

Visitor that looks for an aggregate function inside a tree of {@link SqlNode} objects and throws {@link Util.FoundOne} when it finds one.

Represents internal state when implementing aggregate functions.

Implements an aggregate function by generating expressions to initialize, add to, and get a result from, an accumulator. @see org.apache.calcite.adap

Iterates over all aggregates.

Information for a call to {@link AggImplementor#implementReset(AggContext, AggResetContext)}. <p>{@link AggResetContext} provides access to the accum

Implementation of {@link org.apache.calcite.adapter.enumerable.AggResetContext}.

Information for a call to {@link AggImplementor#implementResult(AggContext, AggResultContext)} <p>Typically, the aggregation implementation will conv

Implementation of {@link org.apache.calcite.adapter.enumerable.AggResultContext}.

Visitor that can find aggregate and windowed aggregate functions. @see AggFinder

Relational operator that eliminates duplicates and computes totals. <p>It corresponds to the {@code GROUP BY} operator in a SQL query statement, toge

Call to an aggregate function within an {@link org.apache.calcite.rel.core.Aggregate}.

Rule that converts CASE-style filtered aggregates into true filtered aggregates. <p>For example, <blockquote> <code>SELECT SUM(CASE WHEN gender =

Planner rule that expands distinct aggregates (such as {@code COUNT(DISTINCT x)}) from a {@link org.apache.calcite.rel.core.Aggregate}. <p>How this i

Planner rule that rewrites an {@link Aggregate} that contains {@code WITHIN DISTINCT} aggregate functions. <p>For example, <blockquote> <pre>SELECT

Rule to extract a {@link org.apache.calcite.rel.core.Project} from an {@link org.apache.calcite.rel.core.Aggregate} and push it down towards the input

Can create a {@link LogicalAggregate} of the appropriate type for this rule's calling convention.

Implementation of {@link RelFactories.AggregateFactory} that returns a vanilla {@link LogicalAggregate}.

Rule that converts true filtered aggregates into CASE-style filtered aggregates. <p>For example, <blockquote> <code>SELECT SUM(salary) FILTER (WHE

Rule that converts an aggregate on top of a filter into a filtered aggregate. <p>Before <pre><code> SELECT SUM(salary) FROM Emp WHERE deptno =

Unit tests for {@link AggregateFilterToFilteredAggregateRule}. <p>Relevant tickets: <ul> <li><a href="https://issues.apache.org/jira/browse/CALCITE-7

Planner rule that matches an {@link org.apache.calcite.rel.core.Aggregate} on a {@link org.apache.calcite.rel.core.Filter} and transposes them, pushin

Visitor that collects all aggregate functions in a {@link SqlNode} tree.

Find aggregate functions in operands.

Function that combines several values into a scalar result.

Implementation of {@link AggregateFunction} via user-defined class. The class should implement {@code A init()}, {@code A add(A, V)}, and {@code R res