Apache Calcite 文档翻译 - 关系代数

scan(tableName)

Creates a TableScan.

functionScan(operator, n, expr...) functionScan(operator, n, exprList)

Creates a TableFunctionScan of the n most recent relational expressions.

transientScan(tableName [, rowType])

Creates a TableScan on a TransientTable with the given type (if not specified, the most recent relational expression’s type will be used).

values(fieldNames, value...) values(rowType, tupleList)

Creates a Values.

filter([variablesSet, ] exprList) filter([variablesSet, ] expr...)

Creates a Filter over the AND of the given predicates; if variablesSet is specified, the predicates may reference those variables.

project(expr...) project(exprList [, fieldNames])

Creates a Project. To override the default name, wrap expressions using alias, or specify the fieldNames argument.

projectPlus(expr...) projectPlus(exprList)

Variant of project that keeps original fields and appends the given expressions.

projectExcept(expr...) projectExcept(exprList)

Variant of project that keeps original fields and removes the given expressions.

permute(mapping)

Creates a Project that permutes the fields using mapping.

convert(rowType [, rename])

Creates a Project that converts the fields to the given types, optionally also renaming them.

aggregate(groupKey, aggCall...) aggregate(groupKey, aggCallList)

Creates an Aggregate.

distinct()

Creates an Aggregate that eliminates duplicate records.

pivot(groupKey, aggCalls, axes, values)

Adds a pivot operation, implemented by generating an Aggregate with a column for each combination of measures and values

unpivot(includeNulls, measureNames, axisNames, axisMap)

Adds an unpivot operation, implemented by generating a Join to a Values that converts each row to several rows

sort(fieldOrdinal...) sort(expr...) sort(exprList)

Creates a Sort. In the first form, field ordinals are 0-based, and a negative ordinal indicates descending; for example, -2 means field 1 descending. In the other forms, you can wrap expressions in as, nullsFirst or nullsLast.

sortLimit(offset, fetch, expr...) sortLimit(offset, fetch, exprList)

Creates a Sort with offset and limit.

limit(offset, fetch)

Creates a Sort that does not sort, only applies with offset and limit.

exchange(distribution)

Creates an Exchange.

sortExchange(distribution, collation)

Creates a SortExchange.

correlate(joinType, correlationId, requiredField...) correlate(joinType, correlationId, requiredFieldList)

Creates a Correlate of the two most recent relational expressions, with a variable name and required field expressions for the left relation.

join(joinType, expr...) join(joinType, exprList) join(joinType, fieldName...)

Creates a Join of the two most recent relational expressions. The first form joins on a boolean expression (multiple conditions are combined using AND). The last form joins on named fields; each side must have a field of each name.

semiJoin(expr)

Creates a Join with SEMI join type of the two most recent relational expressions.

antiJoin(expr)

Creates a Join with ANTI join type of the two most recent relational expressions.

union(all [, n])

Creates a Union of the n (default two) most recent relational expressions.

intersect(all [, n])

Creates an Intersect of the n (default two) most recent relational expressions.

minus(all)

Creates a Minus of the two most recent relational expressions.

repeatUnion(tableName, all [, n])

Creates a RepeatUnion associated to a TransientTable of the two most recent relational expressions, with n maximum number of iterations (default -1, i.e. no limit).

snapshot(period)

Creates a Snapshot of the given snapshot period.

match(pattern, strictStart, strictEnd, patterns, measures, after, subsets, allRows, partitionKeys, orderKeys, interval)

Creates a Match.

as(alias)

Assigns a table alias to the top relational expression on the stack

variable(varHolder)

Creates a correlation variable referencing the top relational expression

build()

Pops the most recently created relational expression off the stack

push(rel)

Pushes a relational expression onto the stack. Relational methods such as scan, above, call this method, but user code generally does not

pushAll(collection)

Pushes a collection of relational expressions onto the stack

peek()

Returns the relational expression most recently put onto the stack, but does not remove it

literal(value)

Constant

field(fieldName)

Reference, by name, to a field of the top-most relational expression

field(fieldOrdinal)

Reference, by ordinal, to a field of the top-most relational expression

field(inputCount, inputOrdinal, fieldName)

Reference, by name, to a field of the (inputCount - inputOrdinal)th relational expression

field(inputCount, inputOrdinal, fieldOrdinal)

Reference, by ordinal, to a field of the (inputCount - inputOrdinal)th relational expression

field(inputCount, alias, fieldName)

Reference, by table alias and field name, to a field at most inputCount - 1 elements from the top of the stack

field(alias, fieldName)

Reference, by table alias and field name, to a field of the top-most relational expressions

field(expr, fieldName)

Reference, by name, to a field of a record-valued expression

field(expr, fieldOrdinal)

Reference, by ordinal, to a field of a record-valued expression

fields(fieldOrdinalList)

List of expressions referencing input fields by ordinal

fields(mapping)

List of expressions referencing input fields by a given mapping

fields(collation)

List of expressions, exprList, such that sort(exprList) would replicate collation

call(op, expr...) call(op, exprList)

Call to a function or operator

and(expr...) and(exprList)

Logical AND. Flattens nested ANDs, and optimizes cases involving TRUE and FALSE.

or(expr...) or(exprList)

Logical OR. Flattens nested ORs, and optimizes cases involving TRUE and FALSE.

not(expr)

Logical NOT

equals(expr, expr)

Equals

isNull(expr)

Checks whether an expression is null

isNotNull(expr)

Checks whether an expression is not null

alias(expr, fieldName)

Renames an expression (only valid as an argument to project)

cast(expr, typeName) cast(expr, typeName, precision) cast(expr, typeName, precision, scale)

Converts an expression to a given type

desc(expr)

Changes sort direction to descending (only valid as an argument to sort or sortLimit)

nullsFirst(expr)

Changes sort order to nulls first (only valid as an argument to sort or sortLimit)

nullsLast(expr)

Changes sort order to nulls last (only valid as an argument to sort or sortLimit)

cursor(n, input)

Reference to inputth (0-based) relational input of a TableFunctionScan with n inputs (see functionScan)

all(expr, op, relFn)

Returns whether expr has a particular relation to all of the values of the sub-query

arrayQuery(relFn)

Returns the rows of a sub-query as an ARRAY

exists(relFn)

Tests whether sub-query is non-empty

in(expr, relFn) in(exprList, relFn)

Tests whether a value occurs in a sub-query

mapQuery(relFn)

Returns the rows of a sub-query as a MAP

multisetQuery(relFn)

Returns the rows of a sub-query as a MULTISET

scalarQuery(relFn)

Returns the value of the sole column of the sole row of a sub-query

some(expr, op, relFn)

Returns whether expr has a particular relation to one or more of the values of the sub-query

unique(relFn)

Returns whether the rows of a sub-query are unique

patternConcat(pattern...)

Concatenates patterns

patternAlter(pattern...)

Alternates patterns

patternQuantify(pattern, min, max)

Quantifies a pattern

patternPermute(pattern...)

Permutes a pattern

patternExclude(pattern)

Excludes a pattern

groupKey(fieldName...) groupKey(fieldOrdinal...) groupKey(expr...) groupKey(exprList)

Creates a group key of the given expressions

groupKey(exprList, exprListList)

Creates a group key of the given expressions with grouping sets

groupKey(bitSet [, bitSets])

Creates a group key of the given input columns, with multiple grouping sets if bitSets is specified

aggregateCall(op, expr...) aggregateCall(op, exprList)

Creates a call to a given aggregate function

count([ distinct, alias, ] expr...) count([ distinct, alias, ] exprList)

Creates a call to the COUNT aggregate function

countStar(alias)

Creates a call to the COUNT(*) aggregate function

sum([ distinct, alias, ] expr)

Creates a call to the SUM aggregate function

min([ alias, ] expr)

Creates a call to the MIN aggregate function

max([ alias, ] expr)

Creates a call to the MAX aggregate function

approximate(approximate)

Allows approximate value for the aggregate of approximate

as(alias)

Assigns a column alias to this expression (see SQL AS)

distinct()

Eliminates duplicate values before aggregating (see SQL DISTINCT)

distinct(distinct)

Eliminates duplicate values before aggregating if distinct

filter(expr)

Filters rows before aggregating (see SQL FILTER (WHERE ...))

sort(expr...) sort(exprList)

Sorts rows before aggregating (see SQL WITHIN GROUP)

unique(expr...) unique(exprList)

Makes rows unique before aggregating (see SQL WITHIN DISTINCT)

over()

Converts this AggCall into a windowed aggregate (see OverCall below)

rangeUnbounded()

Creates an unbounded range-based window, RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING

rangeFrom(lower)

Creates a range-based window bounded below, RANGE BETWEEN lower AND CURRENT ROW

rangeTo(upper)

Creates a range-based window bounded above, RANGE BETWEEN CURRENT ROW AND upper

rangeBetween(lower, upper)

Creates a range-based window, RANGE BETWEEN lower AND upper

rowsUnbounded()

Creates an unbounded row-based window, ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING

rowsFrom(lower)

Creates a row-based window bounded below, ROWS BETWEEN lower AND CURRENT ROW

rowsTo(upper)

Creates a row-based window bounded above, ROWS BETWEEN CURRENT ROW AND upper

rowsBetween(lower, upper)

Creates a rows-based window, ROWS BETWEEN lower AND upper

partitionBy(expr...) partitionBy(exprList)

Partitions the window on the given expressions (see SQL PARTITION BY)

orderBy(expr...) sort(exprList)

Sorts the rows in the window (see SQL ORDER BY)

allowPartial(b)

Sets whether to allow partial width windows; default true

nullWhenCountZero(b)

Sets whether whether the aggregate function should evaluate to null if no rows are in the window; default false

as(alias)

Assigns a column alias (see SQL AS) and converts this OverCall to a RexNode

toRex()

Converts this OverCall to a RexNode