| Package | Description |
|---|---|
| org.apache.calcite.adapter.enumerable |
Query optimizer rules for Java calling convention.
|
| org.apache.calcite.plan |
Defines interfaces for constructing rule-based optimizers of
relational expressions.
|
| org.apache.calcite.prepare |
Preparation of queries (parsing, planning and implementation).
|
| org.apache.calcite.rel.externalize |
Facilities to externalize
RelNodes to and from
XML and JSON format. |
| org.apache.calcite.rel.rel2sql |
Translates a relational expression to SQL parse tree.
|
| org.apache.calcite.rel.rules |
Provides a core set of planner rules.
|
| org.apache.calcite.rex |
Provides a language for representing row-expressions.
|
| org.apache.calcite.sql |
Provides a SQL parser and object model.
|
| org.apache.calcite.sql.dialect |
SQL unparsers for JDBC dialects.
|
| org.apache.calcite.sql.fun |
Defines the set of standard SQL row-level functions and
operators.
|
| org.apache.calcite.sql.parser |
Provides a SQL parser.
|
| org.apache.calcite.sql.type |
SQL type system.
|
| org.apache.calcite.sql.util |
Utility classes for the SQL object model, parsing, and validation.
|
| org.apache.calcite.sql.validate |
SQL validation.
|
| org.apache.calcite.sql2rel |
Translates a SQL parse tree to relational expression.
|
| org.apache.calcite.tools |
Provides utility classes.
|
| Modifier and Type | Field and Description |
|---|---|
static Map<Method,SqlOperator> |
RexToLixTranslator.JAVA_TO_SQL_METHOD_MAP |
private Map<SqlOperator,CallImplementor> |
RexImpTable.map |
| Modifier and Type | Method and Description |
|---|---|
private void |
RexImpTable.defineBinary(SqlOperator operator,
ExpressionType expressionType,
NullPolicy nullPolicy,
String backupMethodName) |
private void |
RexImpTable.defineImplementor(SqlOperator operator,
NullPolicy nullPolicy,
NotNullImplementor implementor,
boolean harmonize) |
private void |
RexImpTable.defineMethod(SqlOperator operator,
Method method,
NullPolicy nullPolicy) |
private void |
RexImpTable.defineMethod(SqlOperator operator,
String functionName,
NullPolicy nullPolicy) |
private void |
RexImpTable.defineMethodReflective(SqlOperator operator,
Method method,
NullPolicy nullPolicy) |
private void |
RexImpTable.defineUnary(SqlOperator operator,
ExpressionType expressionType,
NullPolicy nullPolicy) |
CallImplementor |
RexImpTable.get(SqlOperator operator) |
| Modifier and Type | Field and Description |
|---|---|
(package private) Map<RexInputRef,RexImplicationChecker.InputRefUsage<SqlOperator,RexNode>> |
RexImplicationChecker.InputUsageFinder.usageMap |
| Modifier and Type | Method and Description |
|---|---|
static SqlOperator |
RelOptUtil.op(SqlKind kind,
SqlOperator operator) |
private SqlOperator |
RexImplicationChecker.InputUsageFinder.reverse(SqlOperator op) |
| Modifier and Type | Method and Description |
|---|---|
private RexImplicationChecker.InputRefUsage<SqlOperator,RexNode> |
RexImplicationChecker.InputUsageFinder.getUsageMap(RexInputRef rex) |
| Modifier and Type | Method and Description |
|---|---|
static SqlOperator |
RelOptUtil.op(SqlKind kind,
SqlOperator operator) |
private SqlOperator |
RexImplicationChecker.InputUsageFinder.reverse(SqlOperator op) |
private void |
RexImplicationChecker.InputUsageFinder.updateUsage(SqlOperator op,
RexInputRef inputRef,
RexNode literal) |
| Modifier and Type | Method and Description |
|---|---|
static RexNode |
RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList,
List<RelNode> inputs,
RexNode condition,
List<List<RexNode>> joinKeys,
List<Integer> filterNulls,
List<SqlOperator> rangeOp)
Splits out the equi-join (and optionally, a single non-equi) components
of a join condition, and returns what's left.
|
private static void |
RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList,
List<RelNode> inputs,
RexNode condition,
List<List<RexNode>> joinKeys,
List<Integer> filterNulls,
List<SqlOperator> rangeOp,
List<RexNode> nonEquiList) |
static RexNode |
RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList,
RelNode leftRel,
RelNode rightRel,
RexNode condition,
List<RexNode> leftJoinKeys,
List<RexNode> rightJoinKeys,
List<Integer> filterNulls,
List<SqlOperator> rangeOp)
Splits out the equi-join (and optionally, a single non-equi) components
of a join condition, and returns what's left.
|
| Modifier and Type | Method and Description |
|---|---|
private static SqlOperator |
CalciteCatalogReader.toOp(RelDataTypeFactory typeFactory,
SqlIdentifier name,
Function function)
Converts a function to a
SqlOperator. |
private SqlOperator |
CalciteCatalogReader.toOp(SqlIdentifier name,
Function function) |
| Modifier and Type | Method and Description |
|---|---|
List<SqlOperator> |
CalciteCatalogReader.getOperatorList() |
| Modifier and Type | Method and Description |
|---|---|
void |
CalciteCatalogReader.lookupOperatorOverloads(SqlIdentifier opName,
SqlFunctionCategory category,
SqlSyntax syntax,
List<SqlOperator> operatorList) |
| Modifier and Type | Method and Description |
|---|---|
private SqlOperator |
RelJson.toOp(String op,
Map<String,Object> map) |
| Modifier and Type | Method and Description |
|---|---|
private String |
RelJson.toJson(SqlOperator operator) |
| Modifier and Type | Method and Description |
|---|---|
private static SqlOperator |
SqlImplementor.reverseOperatorDirection(SqlOperator op) |
| Modifier and Type | Method and Description |
|---|---|
private SqlNode |
SqlImplementor.Context.createLeftCall(SqlOperator op,
List<SqlNode> nodeList) |
private static SqlOperator |
SqlImplementor.reverseOperatorDirection(SqlOperator op) |
| Modifier and Type | Field and Description |
|---|---|
private Map<SqlOperator,ReduceDecimalsRule.RexExpander> |
ReduceDecimalsRule.ExpanderMap.map |
private Set<SqlOperator> |
PushProjector.OperatorExprCondition.operatorSet |
private Deque<SqlOperator> |
ReduceExpressionsRule.ReducibleExprLocator.parentCallTypeStack |
| Modifier and Type | Method and Description |
|---|---|
private Boolean |
ReduceExpressionsRule.ReducibleExprLocator.isUdf(SqlOperator operator) |
| Constructor and Description |
|---|
OperatorExprCondition(Iterable<? extends SqlOperator> operatorSet)
Creates an OperatorExprCondition.
|
| Modifier and Type | Field and Description |
|---|---|
SqlOperator |
RexCall.op |
private SqlOperator |
RexSqlStandardConvertletTable.EquivConvertlet.op |
| Modifier and Type | Field and Description |
|---|---|
private static Set<SqlOperator> |
RexMultisetUtil.MULTISET_OPERATORS
A set defining all implementable multiset calls
|
private Set<SqlOperator> |
RexTransformer.transformableOperators |
| Modifier and Type | Method and Description |
|---|---|
SqlOperator |
RexCall.getOperator() |
(package private) static SqlOperator |
RexUtil.op(SqlKind kind) |
| Modifier and Type | Method and Description |
|---|---|
RelDataType |
RexBuilder.deriveReturnType(SqlOperator op,
List<? extends RexNode> exprs)
Derives the return type of a call to an operator.
|
static RexCall |
RexUtil.findOperatorCall(SqlOperator operator,
RexNode node)
Returns whether a given node contains a RexCall with a specified operator
|
static List<RexNode> |
RexUtil.flatten(List<? extends RexNode> exprs,
SqlOperator op)
Converts a list of operands into a list that is flat with respect to
the given operator.
|
private static void |
RexUtil.flattenRecurse(List<RexNode> list,
List<? extends RexNode> exprs,
SqlOperator op) |
private static boolean |
RexUtil.isAssociative(SqlOperator op)
Returns whether an operator is associative.
|
static boolean |
RexUtil.isCallTo(RexNode expr,
SqlOperator op)
|
private static boolean |
RexUtil.isFlat(List<? extends RexNode> exprs,
SqlOperator op)
Returns whether a call to
op with exprs as arguments
would be considered "flat". |
RexNode |
RexBuilder.makeCall(RelDataType returnType,
SqlOperator op,
List<RexNode> exprs)
Creates a call with a list of arguments and a predetermined type.
|
RexNode |
RexBuilder.makeCall(SqlOperator op,
List<? extends RexNode> exprs)
Creates a call with an array of arguments.
|
RexNode |
RexBuilder.makeCall(SqlOperator op,
RexNode... exprs)
Creates a call with a list of arguments.
|
private void |
RexSqlStandardConvertletTable.registerCaseOp(SqlOperator op)
Creates and registers a convertlet for the CASE operator,
which takes different forms for SQL vs Rex.
|
protected void |
RexSqlStandardConvertletTable.registerEquivOp(SqlOperator op)
Creates and registers a convertlet for an operator in which
the SQL and Rex representations are structurally equivalent.
|
protected void |
RexSqlReflectiveConvertletTable.registerOp(SqlOperator op,
RexSqlConvertlet convertlet)
Registers a convertlet for a given operator instance
|
private void |
RexSqlStandardConvertletTable.registerTypeAppendOp(SqlOperator op)
Creates and registers a convertlet for an operator in which
the SQL representation needs the result type appended
as an extra argument (e.g.
|
| Constructor and Description |
|---|
EquivConvertlet(SqlOperator op) |
RexCall(RelDataType type,
SqlOperator op,
List<? extends RexNode> operands) |
RexCallBinding(RelDataTypeFactory typeFactory,
SqlOperator sqlOperator,
List<? extends RexNode> operands,
List<RelCollation> inputCollations) |
RexCastCallBinding(RelDataTypeFactory typeFactory,
SqlOperator sqlOperator,
List<? extends RexNode> operands,
RelDataType type,
List<RelCollation> inputCollations) |
RexSubQuery(RelDataType type,
SqlOperator op,
com.google.common.collect.ImmutableList<RexNode> operands,
RelNode rel) |
| Modifier and Type | Class and Description |
|---|---|
class |
SqlAggFunction
Abstract base class for the definition of an aggregate function: an operator
which aggregates sets of values into a result.
|
class |
SqlAsOperator
The
AS operator associates an expression with an alias. |
class |
SqlBinaryOperator
SqlBinaryOperator is a binary operator. |
class |
SqlFilterOperator
An operator that applies a filter before rows are included in an aggregate
function.
|
class |
SqlFunction
A
SqlFunction is a type of operator which has conventional
function-call syntax. |
class |
SqlFunctionalOperator
SqlFunctionalOperator is a base class for special operators which use
functional syntax.
|
class |
SqlGroupedWindowFunction
SQL function that computes keys by which rows can be partitioned and
aggregated.
|
class |
SqlInfixOperator
A generalization of a binary operator to involve several (two or more)
arguments, and keywords between each pair of arguments.
|
class |
SqlInternalOperator
Generic operator for nodes with internal syntax.
|
class |
SqlJdbcFunctionCall
A
SqlJdbcFunctionCall is a node of a parse tree which represents
a JDBC function call. |
static class |
SqlJoin.SqlJoinOperator
SqlJoinOperator describes the syntax of the SQL
JOIN operator. |
class |
SqlLateralOperator
An operator describing a LATERAL specification.
|
static class |
SqlMatchRecognize.SqlMatchRecognizeOperator
An operator describing a MATCH_RECOGNIZE specification.
|
private static class |
SqlOrderBy.Operator
Definition of
ORDER BY operator. |
class |
SqlOverOperator
An operator describing a window function specification.
|
class |
SqlPostfixOperator
A postfix unary operator.
|
class |
SqlPrefixOperator
A unary operator.
|
class |
SqlProcedureCallOperator
SqlProcedureCallOperator represents the CALL statement.
|
class |
SqlRankFunction
Operator which aggregates sets of values into a result.
|
class |
SqlSelectOperator
An operator describing a query.
|
class |
SqlSetOperator
SqlSetOperator represents a relational set theory operator (UNION, INTERSECT,
MINUS).
|
class |
SqlSpecialOperator
Generic operator for nodes with special syntax.
|
class |
SqlUnnestOperator
The
UNNEST operator. |
class |
SqlUnresolvedFunction
Placeholder for an unresolved function.
|
class |
SqlValuesOperator
The
VALUES operator. |
private static class |
SqlWindow.SqlWindowOperator
An operator describing a window specification.
|
private static class |
SqlWith.SqlWithOperator
SqlWithOperator is used to represent a WITH clause of a query.
|
private static class |
SqlWithItem.SqlWithItemOperator
SqlWithItemOperator is used to represent an item in a WITH clause of a
query.
|
| Modifier and Type | Field and Description |
|---|---|
protected static SqlOperator |
SqlDdl.DDL_OPERATOR
Use this operator only if you don't have a better one.
|
private SqlOperator |
SqlDdl.operator |
private SqlOperator |
SqlBasicCall.operator |
(package private) SqlOperator |
SqlJdbcFunctionCall.SimpleMakeCall.operator |
private SqlOperator |
SqlOperatorBinding.sqlOperator |
| Modifier and Type | Method and Description |
|---|---|
SqlOperator |
SqlSelect.getOperator() |
SqlOperator |
SqlOrderBy.getOperator() |
SqlOperator |
SqlDdl.getOperator() |
SqlOperator |
SqlInsert.getOperator() |
SqlOperator |
SqlWindow.getOperator() |
SqlOperator |
SqlUpdate.getOperator() |
SqlOperator |
SqlBasicCall.getOperator() |
abstract SqlOperator |
SqlCall.getOperator() |
SqlOperator |
SqlDescribeTable.getOperator() |
SqlOperator |
SqlOperatorBinding.getOperator() |
SqlOperator |
SqlWithItem.getOperator() |
SqlOperator |
SqlMerge.getOperator() |
SqlOperator |
SqlDescribeSchema.getOperator() |
SqlOperator |
SqlSetOption.getOperator() |
SqlOperator |
SqlExplain.getOperator() |
SqlOperator |
SqlMatchRecognize.getOperator() |
SqlOperator |
SqlJoin.getOperator() |
SqlOperator |
SqlWith.getOperator() |
SqlOperator |
SqlDelete.getOperator() |
SqlOperator |
SqlJdbcFunctionCall.MakeCall.getOperator() |
SqlOperator |
SqlJdbcFunctionCall.SimpleMakeCall.getOperator() |
static SqlOperator |
SqlUtil.lookupRoutine(SqlOperatorTable opTab,
SqlIdentifier funcName,
List<RelDataType> argTypes,
List<String> argNames,
SqlFunctionCategory category,
SqlSyntax syntax,
SqlKind sqlKind)
Looks up a (possibly overloaded) routine based on name and argument
types.
|
SqlOperator |
SqlSpecialOperator.TokenSequence.op(int i) |
| Modifier and Type | Method and Description |
|---|---|
private static Iterator<SqlOperator> |
SqlUtil.filterOperatorRoutinesByKind(Iterator<SqlOperator> routines,
SqlKind sqlKind) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByParameterCount(Iterator<SqlOperator> routines,
List<RelDataType> argTypes) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByParameterType(SqlSyntax syntax,
Iterator<SqlOperator> routines,
List<RelDataType> argTypes,
List<String> argNames) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByTypePrecedence(SqlSyntax sqlSyntax,
Iterator<SqlOperator> routines,
List<RelDataType> argTypes) |
List<SqlOperator> |
SqlOperatorTable.getOperatorList()
Retrieves a list of all functions and operators in this table.
|
static Iterator<SqlOperator> |
SqlUtil.lookupSubjectRoutines(SqlOperatorTable opTab,
SqlIdentifier funcName,
List<RelDataType> argTypes,
List<String> argNames,
SqlSyntax sqlSyntax,
SqlKind sqlKind,
SqlFunctionCategory category)
Looks up all subject routines matching the given name and argument types.
|
private static Iterator<SqlOperator> |
SqlUtil.lookupSubjectRoutinesByName(SqlOperatorTable opTab,
SqlIdentifier funcName,
SqlSyntax syntax,
SqlFunctionCategory category) |
| Modifier and Type | Method and Description |
|---|---|
static String |
SqlUtil.getAliasedSignature(SqlOperator op,
String opName,
List<?> typeList)
Constructs an operator signature from a type list, substituting an alias
for the operator name.
|
static String |
SqlUtil.getOperatorSignature(SqlOperator op,
List<?> typeList)
Constructs an operator signature from a type list.
|
static boolean |
SqlUtil.isCallTo(SqlNode node,
SqlOperator operator)
|
void |
SqlBasicCall.setOperator(SqlOperator operator) |
private SqlJdbcFunctionCall.MakeCall |
SqlJdbcFunctionCall.JdbcToInternalLookupTable.simple(SqlOperator operator) |
boolean |
SqlDialect.supportsFunction(SqlOperator operator,
RelDataType type,
List<RelDataType> paramTypes)
Returns whether this dialect supports a given function or operator.
|
abstract void |
SqlSyntax.unparse(SqlWriter writer,
SqlOperator operator,
SqlCall call,
int leftPrec,
int rightPrec)
Converts a call to an operator of this syntax into a string.
|
static void |
SqlUtil.unparseBinarySyntax(SqlOperator operator,
SqlCall call,
SqlWriter writer,
int leftPrec,
int rightPrec) |
static void |
SqlUtil.unparseFunctionSyntax(SqlOperator operator,
SqlWriter writer,
SqlCall call)
Unparses a call to an operator which has function syntax.
|
| Modifier and Type | Method and Description |
|---|---|
private static Iterator<SqlOperator> |
SqlUtil.filterOperatorRoutinesByKind(Iterator<SqlOperator> routines,
SqlKind sqlKind) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByParameterCount(Iterator<SqlOperator> routines,
List<RelDataType> argTypes) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByParameterType(SqlSyntax syntax,
Iterator<SqlOperator> routines,
List<RelDataType> argTypes,
List<String> argNames) |
private static Iterator<SqlOperator> |
SqlUtil.filterRoutinesByTypePrecedence(SqlSyntax sqlSyntax,
Iterator<SqlOperator> routines,
List<RelDataType> argTypes) |
void |
SqlOperatorTable.lookupOperatorOverloads(SqlIdentifier opName,
SqlFunctionCategory category,
SqlSyntax syntax,
List<SqlOperator> operatorList)
Retrieves a list of operators with a given name and syntax.
|
| Constructor and Description |
|---|
ExplicitOperatorBinding(RelDataTypeFactory typeFactory,
SqlOperator operator,
List<RelDataType> types) |
ExplicitOperatorBinding(SqlOperatorBinding delegate,
RelDataTypeFactory typeFactory,
SqlOperator operator,
List<RelDataType> types) |
PermutingMakeCall(SqlOperator operator,
int[] order)
Creates a MakeCall strategy object with reordering of operands.
|
SimpleMakeCall(SqlOperator operator) |
SqlBasicCall(SqlOperator operator,
SqlNode[] operands,
SqlParserPos pos) |
SqlBasicCall(SqlOperator operator,
SqlNode[] operands,
SqlParserPos pos,
boolean expanded,
SqlLiteral functionQualifier) |
SqlCreate(SqlOperator operator,
SqlParserPos pos,
boolean replace,
boolean ifNotExists)
Creates a SqlCreate.
|
SqlDdl(SqlOperator operator,
SqlParserPos pos)
Creates a SqlDdl.
|
SqlDrop(SqlOperator operator,
SqlParserPos pos,
boolean ifExists)
Creates a SqlDrop.
|
SqlOperatorBinding(RelDataTypeFactory typeFactory,
SqlOperator sqlOperator)
Creates a SqlOperatorBinding.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
JethroDataSqlDialect.supportsFunction(SqlOperator operator,
RelDataType type,
List<RelDataType> paramTypes) |
| Modifier and Type | Class and Description |
|---|---|
class |
SqlAbstractGroupFunction
Base class for grouping functions
GROUP_ID, GROUPING_ID,
GROUPING. |
class |
SqlAbstractTimeFunction
Base class for time functions such as "LOCALTIME", "LOCALTIME(n)".
|
(package private) class |
SqlArgumentAssignmentOperator
Operator that assigns an argument to a function call to a particular named
parameter.
|
class |
SqlArrayQueryConstructor
Definition of the SQL:2003 standard ARRAY query constructor,
ARRAY (<query>). |
class |
SqlArrayValueConstructor
Definition of the SQL:2003 standard ARRAY constructor,
ARRAY
[<expr>, ...]. |
class |
SqlAvgAggFunction
Avg is an aggregator which returns the average of the values
which go into it. |
class |
SqlBaseContextVariable
Base class for functions such as "PI", "USER", "CURRENT_ROLE", and
"CURRENT_PATH".
|
class |
SqlBetweenOperator
Defines the BETWEEN operator.
|
class |
SqlCaseOperator
An operator describing a
CASE, NULLIF or
COALESCE expression. |
class |
SqlCastFunction
SqlCastFunction.
|
class |
SqlCoalesceFunction
The
COALESCE function. |
class |
SqlCollectionTableOperator
SqlCollectionTableOperator is the "table function derived table" operator.
|
class |
SqlColumnListConstructor
SqlColumnListConstructor defines the non-standard constructor used to pass a
COLUMN_LIST parameter to a UDX.
|
class |
SqlConvertFunction
Common base for the
CONVERT and TRANSLATE
functions. |
class |
SqlCountAggFunction
Definition of the SQL
COUNT aggregation function. |
class |
SqlCovarAggFunction
Covar is an aggregator which returns the Covariance of the
values which go into it. |
class |
SqlCurrentDateFunction
The
CURRENT_DATE function. |
class |
SqlCursorConstructor
SqlCursorConstructor defines the non-standard CURSOR(<query>)
constructor.
|
class |
SqlDatePartFunction
SqlDatePartFunction represents the SQL:1999 standard
YEAR,
QUARTER, MONTH and DAY functions. |
class |
SqlDatetimeSubtractionOperator
A special operator for the subtraction of two DATETIMEs.
|
(package private) class |
SqlDefaultOperator
Operator that indicates that an argument to a function call is to take its
default value.
|
class |
SqlDotOperator
The dot operator
., used to access a field of a
record. |
(package private) class |
SqlExtendOperator
EXTEND operator. |
class |
SqlExtractFunction
The SQL
EXTRACT operator. |
class |
SqlFirstLastValueAggFunction
FIRST_VALUE and LAST_VALUE aggregate functions
return the first or the last value in a list of values that are input to the
function. |
class |
SqlFloorFunction
Definition of the "FLOOR" and "CEIL" built-in SQL functions.
|
(package private) class |
SqlGroupIdFunction
The
GROUP_ID() function. |
(package private) class |
SqlGroupingFunction
The
GROUPING function. |
(package private) class |
SqlGroupingIdFunction
Deprecated.
Now that
GROUPING has the same functionality,
this function is deprecated. |
class |
SqlHistogramAggFunction
HISTOGRAM is the base operator that supports the Histogram
MIN/MAX aggregate functions. |
class |
SqlInOperator
Definition of the SQL
IN operator, which tests for a value's
membership in a sub-query or a list of values. |
(package private) class |
SqlItemOperator
The item operator {@code [ ...
|
class |
SqlLeadLagAggFunction
LEAD and LAG aggregate functions
return the value of given expression evaluated at given offset. |
class |
SqlLikeOperator
An operator describing the
LIKE and SIMILAR
operators. |
class |
SqlLiteralChainOperator
Internal operator, by which the parser represents a continued string literal.
|
class |
SqlMapQueryConstructor
Definition of the MAP query constructor,
MAP (<query>). |
class |
SqlMapValueConstructor
Definition of the MAP constructor,
MAP [<key>, <value>, ...]. |
class |
SqlMinMaxAggFunction
Definition of the
MIN and MAX aggregate functions,
returning the returns the smallest/largest of the values which go into it. |
class |
SqlMonotonicBinaryOperator
Base class for binary operators such as addition, subtraction, and
multiplication which are monotonic for the patterns
m op c and
c op m where m is any monotonic expression and c is a constant. |
class |
SqlMonotonicUnaryFunction
Base class for unary operators such as FLOOR/CEIL which are monotonic for
monotonic inputs.
|
class |
SqlMultisetMemberOfOperator
Multiset MEMBER OF.
|
class |
SqlMultisetQueryConstructor
Definition of the SQL:2003 standard MULTISET query constructor,
MULTISET (<query>). |
class |
SqlMultisetSetOperator
An operator which performs set operations on multisets, such as "MULTISET
UNION ALL".
|
class |
SqlMultisetValueConstructor
Definition of the SQL:2003 standard MULTISET constructor,
MULTISET
[<expr>, ...]. |
class |
SqlNewOperator
SqlNewOperator represents an SQL
new specification such as
NEW UDT(1, 2). |
class |
SqlNtileAggFunction
NTILE aggregate function
return the value of given expression evaluated at given offset. |
class |
SqlNullifFunction
The
NULLIF function. |
class |
SqlOverlapsOperator
SqlOverlapsOperator represents the SQL:1999 standard
OVERLAPS
function. |
class |
SqlOverlayFunction
The
OVERLAY function. |
class |
SqlPositionFunction
The
POSITION function. |
class |
SqlQuantifyOperator
Definition of the SQL
ALL and SOMEoperators. |
class |
SqlRandFunction
The
RAND function. |
class |
SqlRandIntegerFunction
The
RAND_INTEGER function. |
(package private) class |
SqlRollupOperator
Operator that appears in a
GROUP BY clause: CUBE,
ROLLUP, GROUPING SETS. |
class |
SqlRowOperator
SqlRowOperator represents the special ROW constructor.
|
class |
SqlSequenceValueOperator
Operator that returns the current or next value of a sequence.
|
class |
SqlSingleValueAggFunction
SINGLE_VALUE aggregate function returns the input value if there
is only one value in the input; Otherwise it triggers a run-time error. |
class |
SqlStringContextVariable
Base class for string functions such as "USER", "CURRENT_ROLE", and
"CURRENT_PATH".
|
class |
SqlSubstringFunction
Definition of the "SUBSTRING" builtin SQL function.
|
class |
SqlSumAggFunction
Sum is an aggregator which returns the sum of the values which
go into it. |
class |
SqlSumEmptyIsZeroAggFunction
Sum0 is an aggregator which returns the sum of the values which
go into it like Sum. |
class |
SqlThrowOperator
An internal operator that throws an exception.
|
(package private) class |
SqlTimestampAddFunction
The
TIMESTAMPADD function, which adds an interval to a
timestamp. |
(package private) class |
SqlTimestampDiffFunction
The
TIMESTAMPDIFF function, which calculates the difference
between two timestamps. |
class |
SqlTranslate3Function
Definition of the "TRANSLATE" built-in SQL function that takes 3 arguments.
|
class |
SqlTrimFunction
Definition of the "TRIM" builtin SQL function.
|
| Modifier and Type | Field and Description |
|---|---|
static SqlOperator |
SqlStdOperatorTable.CURRENT_VALUE
The sequence current value function:
CURRENT VALUE FOR
sequence |
static SqlOperator |
SqlStdOperatorTable.DOT
Dot operator, '
.', used for referencing fields of records. |
static SqlOperator |
SqlStdOperatorTable.ITEM
The item operator {@code [ ...
|
static SqlOperator |
SqlStdOperatorTable.NEW |
static SqlOperator |
SqlStdOperatorTable.NEXT_VALUE
The sequence next value function:
NEXT VALUE FOR sequence |
static SqlOperator |
SqlStdOperatorTable.PROCEDURE_CALL |
| Modifier and Type | Method and Description |
|---|---|
SqlOperator |
SqlCase.getOperator() |
| Modifier and Type | Method and Description |
|---|---|
private static SqlCall |
SqlStdOperatorTable.copy(SqlCall call,
SqlOperator operator)
Creates a copy of a call with a new operator.
|
| Modifier and Type | Field and Description |
|---|---|
private SqlOperator |
SqlParserUtil.ToTreeListItem.op |
| Modifier and Type | Method and Description |
|---|---|
SqlOperator |
SqlParserUtil.ToTreeListItem.getOperator() |
SqlOperator |
SqlParserUtil.TokenSequenceImpl.op(int i) |
SqlOperator |
SqlParserUtil.OldTokenSequenceImpl.op(int i) |
| Constructor and Description |
|---|
ToTreeListItem(SqlOperator op,
SqlParserPos pos) |
| Modifier and Type | Method and Description |
|---|---|
String |
SetopOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
SameOperandTypeExceptLastOperandChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
SameOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
MultisetOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
CompositeOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
OperandTypes.PeriodOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
SqlOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName)
Returns a string describing the allowed formal signatures of a call, e.g.
|
String |
FamilyOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
LiteralOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
String |
AssignableOperandTypeChecker.getAllowedSignatures(SqlOperator op,
String opName) |
| Modifier and Type | Field and Description |
|---|---|
private List<SqlOperator> |
ListSqlOperatorTable.operatorList |
private com.google.common.collect.Multimap<ReflectiveSqlOperatorTable.Key,SqlOperator> |
ReflectiveSqlOperatorTable.operators |
| Modifier and Type | Method and Description |
|---|---|
List<SqlOperator> |
ReflectiveSqlOperatorTable.getOperatorList() |
List<SqlOperator> |
ChainedSqlOperatorTable.getOperatorList() |
List<SqlOperator> |
ListSqlOperatorTable.getOperatorList() |
| Modifier and Type | Method and Description |
|---|---|
void |
ListSqlOperatorTable.add(SqlOperator op) |
protected static SqlFunctionCategory |
ListSqlOperatorTable.category(SqlOperator operator) |
void |
ReflectiveSqlOperatorTable.register(SqlOperator op)
Registers a function or operator in the table.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ReflectiveSqlOperatorTable.lookupOperatorOverloads(SqlIdentifier opName,
SqlFunctionCategory category,
SqlSyntax syntax,
List<SqlOperator> operatorList) |
void |
ChainedSqlOperatorTable.lookupOperatorOverloads(SqlIdentifier opName,
SqlFunctionCategory category,
SqlSyntax syntax,
List<SqlOperator> operatorList) |
void |
ListSqlOperatorTable.lookupOperatorOverloads(SqlIdentifier opName,
SqlFunctionCategory category,
SqlSyntax syntax,
List<SqlOperator> operatorList) |
| Constructor and Description |
|---|
ListSqlOperatorTable(List<SqlOperator> operatorList) |
| Modifier and Type | Class and Description |
|---|---|
class |
SqlUserDefinedAggFunction
User-defined aggregate function.
|
class |
SqlUserDefinedFunction
User-defined scalar function.
|
class |
SqlUserDefinedTableFunction
User-defined table function.
|
class |
SqlUserDefinedTableMacro
User-defined table macro.
|
| Modifier and Type | Field and Description |
|---|---|
(package private) SqlOperator |
SqlValidatorImpl.NavigationExpander.op |
| Constructor and Description |
|---|
NavigationExpander(SqlOperator operator,
SqlNode offset) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
ReflectiveConvertletTable.addAlias(SqlOperator alias,
SqlOperator target)
Registers that one operator is an alias for another.
|
private RexNode |
StandardConvertletTable.convertCall(SqlRexContext cx,
SqlCall call,
SqlOperator op)
|
private RexNode |
RelStructuredTypeFlattener.RewriteRexShuttle.flattenComparison(RexBuilder rexBuilder,
SqlOperator op,
List<RexNode> exprs) |
private Set<RelColumnMapping> |
SqlToRelConverter.getColumnMappings(SqlOperator op) |
protected void |
ReflectiveConvertletTable.registerOp(SqlOperator op,
SqlRexConvertlet convertlet)
Registers a convertlet for a given operator instance
|
| Modifier and Type | Method and Description |
|---|---|
RexNode |
RelBuilder.call(SqlOperator operator,
Iterable<? extends RexNode> operands)
Creates a call to a scalar operator.
|
private RexNode |
RelBuilder.call(SqlOperator operator,
List<RexNode> operandList)
Creates a call to a scalar operator.
|
RexNode |
RelBuilder.call(SqlOperator operator,
RexNode... operands)
Creates a call to a scalar operator.
|
Copyright © 2012–2018 The Apache Software Foundation. All rights reserved.