com.hazelcast.org.apache.calcite.sql.fun.SqlStdOperatorTable Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.org.apache.calcite.sql.fun;
import com.hazelcast.org.apache.calcite.avatica.util.TimeUnit;
import com.hazelcast.org.apache.calcite.sql.SqlAggFunction;
import com.hazelcast.org.apache.calcite.sql.SqlAsOperator;
import com.hazelcast.org.apache.calcite.sql.SqlBasicCall;
import com.hazelcast.org.apache.calcite.sql.SqlBinaryOperator;
import com.hazelcast.org.apache.calcite.sql.SqlCall;
import com.hazelcast.org.apache.calcite.sql.SqlDescriptorOperator;
import com.hazelcast.org.apache.calcite.sql.SqlFilterOperator;
import com.hazelcast.org.apache.calcite.sql.SqlFunction;
import com.hazelcast.org.apache.calcite.sql.SqlFunctionCategory;
import com.hazelcast.org.apache.calcite.sql.SqlGroupedWindowFunction;
import com.hazelcast.org.apache.calcite.sql.SqlHopTableFunction;
import com.hazelcast.org.apache.calcite.sql.SqlInternalOperator;
import com.hazelcast.org.apache.calcite.sql.SqlJsonConstructorNullClause;
import com.hazelcast.org.apache.calcite.sql.SqlKind;
import com.hazelcast.org.apache.calcite.sql.SqlLateralOperator;
import com.hazelcast.org.apache.calcite.sql.SqlLiteral;
import com.hazelcast.org.apache.calcite.sql.SqlMatchFunction;
import com.hazelcast.org.apache.calcite.sql.SqlNode;
import com.hazelcast.org.apache.calcite.sql.SqlNullTreatmentOperator;
import com.hazelcast.org.apache.calcite.sql.SqlNumericLiteral;
import com.hazelcast.org.apache.calcite.sql.SqlOperandCountRange;
import com.hazelcast.org.apache.calcite.sql.SqlOperator;
import com.hazelcast.org.apache.calcite.sql.SqlOverOperator;
import com.hazelcast.org.apache.calcite.sql.SqlPostfixOperator;
import com.hazelcast.org.apache.calcite.sql.SqlPrefixOperator;
import com.hazelcast.org.apache.calcite.sql.SqlProcedureCallOperator;
import com.hazelcast.org.apache.calcite.sql.SqlRankFunction;
import com.hazelcast.org.apache.calcite.sql.SqlSampleSpec;
import com.hazelcast.org.apache.calcite.sql.SqlSessionTableFunction;
import com.hazelcast.org.apache.calcite.sql.SqlSetOperator;
import com.hazelcast.org.apache.calcite.sql.SqlSpecialOperator;
import com.hazelcast.org.apache.calcite.sql.SqlSyntax;
import com.hazelcast.org.apache.calcite.sql.SqlTumbleTableFunction;
import com.hazelcast.org.apache.calcite.sql.SqlUnnestOperator;
import com.hazelcast.org.apache.calcite.sql.SqlUtil;
import com.hazelcast.org.apache.calcite.sql.SqlValuesOperator;
import com.hazelcast.org.apache.calcite.sql.SqlWindow;
import com.hazelcast.org.apache.calcite.sql.SqlWithinGroupOperator;
import com.hazelcast.org.apache.calcite.sql.SqlWriter;
import com.hazelcast.org.apache.calcite.sql.type.InferTypes;
import com.hazelcast.org.apache.calcite.sql.type.OperandTypes;
import com.hazelcast.org.apache.calcite.sql.type.ReturnTypes;
import com.hazelcast.org.apache.calcite.sql.type.SqlOperandCountRanges;
import com.hazelcast.org.apache.calcite.sql.type.SqlTypeName;
import com.hazelcast.org.apache.calcite.sql.util.ReflectiveSqlOperatorTable;
import com.hazelcast.org.apache.calcite.sql.validate.SqlConformance;
import com.hazelcast.org.apache.calcite.sql.validate.SqlModality;
import com.hazelcast.org.apache.calcite.sql2rel.AuxiliaryConverter;
import com.hazelcast.org.apache.calcite.util.Litmus;
import com.hazelcast.org.apache.calcite.util.Optionality;
import com.hazelcast.org.apache.calcite.util.Pair;
import com.hazelcast.com.google.common.collect.ImmutableList;
import java.util.List;
/**
* Implementation of {@link com.hazelcast.org.apache.calcite.sql.SqlOperatorTable} containing
* the standard operators and functions.
*/
public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
//~ Static fields/initializers ---------------------------------------------
/**
* The standard operator table.
*/
private static SqlStdOperatorTable instance;
//-------------------------------------------------------------
// SET OPERATORS
//-------------------------------------------------------------
// The set operators can be compared to the arithmetic operators
// UNION -> +
// EXCEPT -> -
// INTERSECT -> *
// which explains the different precedence values
public static final SqlSetOperator UNION =
new SqlSetOperator("UNION", SqlKind.UNION, 14, false);
public static final SqlSetOperator UNION_ALL =
new SqlSetOperator("UNION ALL", SqlKind.UNION, 14, true);
public static final SqlSetOperator EXCEPT =
new SqlSetOperator("EXCEPT", SqlKind.EXCEPT, 14, false);
public static final SqlSetOperator EXCEPT_ALL =
new SqlSetOperator("EXCEPT ALL", SqlKind.EXCEPT, 14, true);
public static final SqlSetOperator INTERSECT =
new SqlSetOperator("INTERSECT", SqlKind.INTERSECT, 18, false);
public static final SqlSetOperator INTERSECT_ALL =
new SqlSetOperator("INTERSECT ALL", SqlKind.INTERSECT, 18, true);
/**
* The {@code MULTISET UNION DISTINCT} operator.
*/
public static final SqlMultisetSetOperator MULTISET_UNION_DISTINCT =
new SqlMultisetSetOperator("MULTISET UNION DISTINCT", 14, false);
/**
* The {@code MULTISET UNION [ALL]} operator.
*/
public static final SqlMultisetSetOperator MULTISET_UNION =
new SqlMultisetSetOperator("MULTISET UNION ALL", 14, true);
/**
* The {@code MULTISET EXCEPT DISTINCT} operator.
*/
public static final SqlMultisetSetOperator MULTISET_EXCEPT_DISTINCT =
new SqlMultisetSetOperator("MULTISET EXCEPT DISTINCT", 14, false);
/**
* The {@code MULTISET EXCEPT [ALL]} operator.
*/
public static final SqlMultisetSetOperator MULTISET_EXCEPT =
new SqlMultisetSetOperator("MULTISET EXCEPT ALL", 14, true);
/**
* The {@code MULTISET INTERSECT DISTINCT} operator.
*/
public static final SqlMultisetSetOperator MULTISET_INTERSECT_DISTINCT =
new SqlMultisetSetOperator("MULTISET INTERSECT DISTINCT", 18, false);
/**
* The {@code MULTISET INTERSECT [ALL]} operator.
*/
public static final SqlMultisetSetOperator MULTISET_INTERSECT =
new SqlMultisetSetOperator("MULTISET INTERSECT ALL", 18, true);
//-------------------------------------------------------------
// BINARY OPERATORS
//-------------------------------------------------------------
/**
* Logical AND operator.
*/
public static final SqlBinaryOperator AND =
new SqlBinaryOperator(
"AND",
SqlKind.AND,
24,
true,
ReturnTypes.BOOLEAN_NULLABLE_OPTIMIZED,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN_BOOLEAN);
/**
* AS operator associates an expression in the SELECT clause
* with an alias.
*/
public static final SqlAsOperator AS = new SqlAsOperator();
/**
* ARGUMENT_ASSIGNMENT operator (=<)
* assigns an argument to a function call to a particular named parameter.
*/
public static final SqlSpecialOperator ARGUMENT_ASSIGNMENT =
new SqlArgumentAssignmentOperator();
/**
* DEFAULT operator indicates that an argument to a function call
* is to take its default value..
*/
public static final SqlSpecialOperator DEFAULT = new SqlDefaultOperator();
/** FILTER operator filters which rows are included in an
* aggregate function. */
public static final SqlFilterOperator FILTER = new SqlFilterOperator();
/** WITHIN_GROUP operator performs aggregations on ordered data input. */
public static final SqlWithinGroupOperator WITHIN_GROUP = new SqlWithinGroupOperator();
/** {@code CUBE} operator, occurs within {@code GROUP BY} clause
* or nested within a {@code GROUPING SETS}. */
public static final SqlInternalOperator CUBE =
new SqlRollupOperator("CUBE", SqlKind.CUBE);
/** {@code ROLLUP} operator, occurs within {@code GROUP BY} clause
* or nested within a {@code GROUPING SETS}. */
public static final SqlInternalOperator ROLLUP =
new SqlRollupOperator("ROLLUP", SqlKind.ROLLUP);
/** {@code GROUPING SETS} operator, occurs within {@code GROUP BY} clause
* or nested within a {@code GROUPING SETS}. */
public static final SqlInternalOperator GROUPING_SETS =
new SqlRollupOperator("GROUPING SETS", SqlKind.GROUPING_SETS);
/** {@code GROUPING(c1 [, c2, ...])} function.
*
* Occurs in similar places to an aggregate
* function ({@code SELECT}, {@code HAVING} clause, etc. of an aggregate
* query), but not technically an aggregate function. */
public static final SqlAggFunction GROUPING =
new SqlGroupingFunction("GROUPING");
/** {@code GROUP_ID()} function. (Oracle-specific.) */
public static final SqlAggFunction GROUP_ID =
new SqlGroupIdFunction();
/** {@code GROUPING_ID} function is a synonym for {@code GROUPING}.
*
*
Some history. The {@code GROUPING} function is in the SQL standard,
* and originally supported only one argument. {@code GROUPING_ID} is not
* standard (though supported in Oracle and SQL Server) and supports one or
* more arguments.
*
*
The SQL standard has changed to allow {@code GROUPING} to have multiple
* arguments. It is now equivalent to {@code GROUPING_ID}, so we made
* {@code GROUPING_ID} a synonym for {@code GROUPING}. */
public static final SqlAggFunction GROUPING_ID =
new SqlGroupingFunction("GROUPING_ID");
/** {@code EXTEND} operator. */
public static final SqlInternalOperator EXTEND = new SqlExtendOperator();
/**
* String concatenation operator, '||'.
*/
public static final SqlBinaryOperator CONCAT =
new SqlBinaryOperator(
"||",
SqlKind.OTHER,
60,
true,
ReturnTypes.DYADIC_STRING_SUM_PRECISION_NULLABLE,
null,
OperandTypes.STRING_SAME_SAME);
/**
* Arithmetic division operator, '/'.
*/
public static final SqlBinaryOperator DIVIDE =
new SqlBinaryOperator(
"/",
SqlKind.DIVIDE,
60,
true,
ReturnTypes.QUOTIENT_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.DIVISION_OPERATOR);
/**
* Arithmetic remainder operator, '%',
* an alternative to {@link #MOD} allowed if under certain conformance levels.
*
* @see SqlConformance#isPercentRemainderAllowed
*/
public static final SqlBinaryOperator PERCENT_REMAINDER =
new SqlBinaryOperator(
"%",
SqlKind.MOD,
60,
true,
ReturnTypes.ARG1_NULLABLE,
null,
OperandTypes.EXACT_NUMERIC_EXACT_NUMERIC);
/** The {@code RAND_INTEGER([seed, ] bound)} function, which yields a random
* integer, optionally with seed. */
public static final SqlRandIntegerFunction RAND_INTEGER =
new SqlRandIntegerFunction();
/** The {@code RAND([seed])} function, which yields a random double,
* optionally with seed. */
public static final SqlRandFunction RAND = new SqlRandFunction();
/**
* Internal integer arithmetic division operator, '/INT'. This
* is only used to adjust scale for numerics. We distinguish it from
* user-requested division since some personalities want a floating-point
* computation, whereas for the internal scaling use of division, we always
* want integer division.
*/
public static final SqlBinaryOperator DIVIDE_INTEGER =
new SqlBinaryOperator(
"/INT",
SqlKind.DIVIDE,
60,
true,
ReturnTypes.INTEGER_QUOTIENT_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.DIVISION_OPERATOR);
/**
* Dot operator, '.', used for referencing fields of records.
*/
public static final SqlOperator DOT = new SqlDotOperator();
/**
* Logical equals operator, '='.
*/
public static final SqlBinaryOperator EQUALS =
new SqlBinaryOperator(
"=",
SqlKind.EQUALS,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED);
/**
* Logical greater-than operator, '>'.
*/
public static final SqlBinaryOperator GREATER_THAN =
new SqlBinaryOperator(
">",
SqlKind.GREATER_THAN,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_ORDERED_COMPARABLE_ORDERED);
/**
* IS DISTINCT FROM operator.
*/
public static final SqlBinaryOperator IS_DISTINCT_FROM =
new SqlBinaryOperator(
"IS DISTINCT FROM",
SqlKind.IS_DISTINCT_FROM,
30,
true,
ReturnTypes.BOOLEAN,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED);
/**
* IS NOT DISTINCT FROM operator. Is equivalent to NOT(x
* IS DISTINCT FROM y)
*/
public static final SqlBinaryOperator IS_NOT_DISTINCT_FROM =
new SqlBinaryOperator(
"IS NOT DISTINCT FROM",
SqlKind.IS_NOT_DISTINCT_FROM,
30,
true,
ReturnTypes.BOOLEAN,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED);
/**
* The internal $IS_DIFFERENT_FROM operator is the same as the
* user-level {@link #IS_DISTINCT_FROM} in all respects except that
* the test for equality on character datatypes treats trailing spaces as
* significant.
*/
public static final SqlBinaryOperator IS_DIFFERENT_FROM =
new SqlBinaryOperator(
"$IS_DIFFERENT_FROM",
SqlKind.OTHER,
30,
true,
ReturnTypes.BOOLEAN,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED);
/**
* Logical greater-than-or-equal operator, '>='.
*/
public static final SqlBinaryOperator GREATER_THAN_OR_EQUAL =
new SqlBinaryOperator(
">=",
SqlKind.GREATER_THAN_OR_EQUAL,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_ORDERED_COMPARABLE_ORDERED);
/**
* IN operator tests for a value's membership in a sub-query or
* a list of values.
*/
public static final SqlBinaryOperator IN = new SqlInOperator(SqlKind.IN);
/**
* NOT IN operator tests for a value's membership in a sub-query
* or a list of values.
*/
public static final SqlBinaryOperator NOT_IN =
new SqlInOperator(SqlKind.NOT_IN);
/**
* The < SOME operator (synonymous with
* < ANY).
*/
public static final SqlQuantifyOperator SOME_LT =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.LESS_THAN);
public static final SqlQuantifyOperator SOME_LE =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.LESS_THAN_OR_EQUAL);
public static final SqlQuantifyOperator SOME_GT =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.GREATER_THAN);
public static final SqlQuantifyOperator SOME_GE =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.GREATER_THAN_OR_EQUAL);
public static final SqlQuantifyOperator SOME_EQ =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.EQUALS);
public static final SqlQuantifyOperator SOME_NE =
new SqlQuantifyOperator(SqlKind.SOME, SqlKind.NOT_EQUALS);
/**
* The < ALL operator.
*/
public static final SqlQuantifyOperator ALL_LT =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.LESS_THAN);
public static final SqlQuantifyOperator ALL_LE =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.LESS_THAN_OR_EQUAL);
public static final SqlQuantifyOperator ALL_GT =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.GREATER_THAN);
public static final SqlQuantifyOperator ALL_GE =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.GREATER_THAN_OR_EQUAL);
public static final SqlQuantifyOperator ALL_EQ =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.EQUALS);
public static final SqlQuantifyOperator ALL_NE =
new SqlQuantifyOperator(SqlKind.ALL, SqlKind.NOT_EQUALS);
/**
* Logical less-than operator, '<'.
*/
public static final SqlBinaryOperator LESS_THAN =
new SqlBinaryOperator(
"<",
SqlKind.LESS_THAN,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_ORDERED_COMPARABLE_ORDERED);
/**
* Logical less-than-or-equal operator, '<='.
*/
public static final SqlBinaryOperator LESS_THAN_OR_EQUAL =
new SqlBinaryOperator(
"<=",
SqlKind.LESS_THAN_OR_EQUAL,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_ORDERED_COMPARABLE_ORDERED);
/**
* Infix arithmetic minus operator, '-'.
*
*
Its precedence is less than the prefix {@link #UNARY_PLUS +}
* and {@link #UNARY_MINUS -} operators.
*/
public static final SqlBinaryOperator MINUS =
new SqlMonotonicBinaryOperator(
"-",
SqlKind.MINUS,
40,
true,
// Same type inference strategy as sum
ReturnTypes.NULLABLE_SUM,
InferTypes.FIRST_KNOWN,
OperandTypes.MINUS_OPERATOR);
/**
* Arithmetic multiplication operator, '*'.
*/
public static final SqlBinaryOperator MULTIPLY =
new SqlMonotonicBinaryOperator(
"*",
SqlKind.TIMES,
60,
true,
ReturnTypes.PRODUCT_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.MULTIPLY_OPERATOR);
/**
* Logical not-equals operator, '<>'.
*/
public static final SqlBinaryOperator NOT_EQUALS =
new SqlBinaryOperator(
"<>",
SqlKind.NOT_EQUALS,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
InferTypes.FIRST_KNOWN,
OperandTypes.COMPARABLE_UNORDERED_COMPARABLE_UNORDERED);
/**
* Logical OR operator.
*/
public static final SqlBinaryOperator OR =
new SqlBinaryOperator(
"OR",
SqlKind.OR,
22,
true,
ReturnTypes.BOOLEAN_NULLABLE_OPTIMIZED,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN_BOOLEAN);
/**
* Infix arithmetic plus operator, '+'.
*/
public static final SqlBinaryOperator PLUS =
new SqlMonotonicBinaryOperator(
"+",
SqlKind.PLUS,
40,
true,
ReturnTypes.NULLABLE_SUM,
InferTypes.FIRST_KNOWN,
OperandTypes.PLUS_OPERATOR);
/**
* Infix datetime plus operator, 'DATETIME + INTERVAL'.
*/
public static final SqlSpecialOperator DATETIME_PLUS =
new SqlDatetimePlusOperator();
/**
* Multiset {@code MEMBER OF}, which returns whether a element belongs to a
* multiset.
*
*
For example, the following returns false:
*
*
* 'green' MEMBER OF MULTISET ['red','almost green','blue']
*
*/
public static final SqlBinaryOperator MEMBER_OF =
new SqlMultisetMemberOfOperator();
/**
* Submultiset. Checks to see if an multiset is a sub-set of another
* multiset.
*
* For example, the following returns false:
*
*
* MULTISET ['green'] SUBMULTISET OF
* MULTISET['red', 'almost green', 'blue']
*
*
* The following returns true, in part because multisets are
* order-independent:
*
*
* MULTISET ['blue', 'red'] SUBMULTISET OF
* MULTISET ['red', 'almost green', 'blue']
*
*/
public static final SqlBinaryOperator SUBMULTISET_OF =
// TODO: check if precedence is correct
new SqlBinaryOperator(
"SUBMULTISET OF",
SqlKind.OTHER,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
null,
OperandTypes.MULTISET_MULTISET);
public static final SqlBinaryOperator NOT_SUBMULTISET_OF =
// TODO: check if precedence is correct
new SqlBinaryOperator(
"NOT SUBMULTISET OF",
SqlKind.OTHER,
30,
true,
ReturnTypes.BOOLEAN_NULLABLE,
null,
OperandTypes.MULTISET_MULTISET);
//-------------------------------------------------------------
// POSTFIX OPERATORS
//-------------------------------------------------------------
public static final SqlPostfixOperator DESC =
new SqlPostfixOperator(
"DESC",
SqlKind.DESCENDING,
20,
ReturnTypes.ARG0,
InferTypes.RETURN_TYPE,
OperandTypes.ANY);
public static final SqlPostfixOperator NULLS_FIRST =
new SqlPostfixOperator(
"NULLS FIRST",
SqlKind.NULLS_FIRST,
18,
ReturnTypes.ARG0,
InferTypes.RETURN_TYPE,
OperandTypes.ANY);
public static final SqlPostfixOperator NULLS_LAST =
new SqlPostfixOperator(
"NULLS LAST",
SqlKind.NULLS_LAST,
18,
ReturnTypes.ARG0,
InferTypes.RETURN_TYPE,
OperandTypes.ANY);
public static final SqlPostfixOperator IS_NOT_NULL =
new SqlPostfixOperator(
"IS NOT NULL",
SqlKind.IS_NOT_NULL,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.VARCHAR_1024,
OperandTypes.ANY);
public static final SqlPostfixOperator IS_NULL =
new SqlPostfixOperator(
"IS NULL",
SqlKind.IS_NULL,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.VARCHAR_1024,
OperandTypes.ANY);
public static final SqlPostfixOperator IS_NOT_TRUE =
new SqlPostfixOperator(
"IS NOT TRUE",
SqlKind.IS_NOT_TRUE,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_TRUE =
new SqlPostfixOperator(
"IS TRUE",
SqlKind.IS_TRUE,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_NOT_FALSE =
new SqlPostfixOperator(
"IS NOT FALSE",
SqlKind.IS_NOT_FALSE,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_FALSE =
new SqlPostfixOperator(
"IS FALSE",
SqlKind.IS_FALSE,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_NOT_UNKNOWN =
new SqlPostfixOperator(
"IS NOT UNKNOWN",
SqlKind.IS_NOT_NULL,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_UNKNOWN =
new SqlPostfixOperator(
"IS UNKNOWN",
SqlKind.IS_NULL,
28,
ReturnTypes.BOOLEAN_NOT_NULL,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
public static final SqlPostfixOperator IS_A_SET =
new SqlPostfixOperator(
"IS A SET",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.MULTISET);
public static final SqlPostfixOperator IS_NOT_A_SET =
new SqlPostfixOperator(
"IS NOT A SET",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.MULTISET);
public static final SqlPostfixOperator IS_EMPTY =
new SqlPostfixOperator(
"IS EMPTY",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.COLLECTION_OR_MAP);
public static final SqlPostfixOperator IS_NOT_EMPTY =
new SqlPostfixOperator(
"IS NOT EMPTY",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.COLLECTION_OR_MAP);
public static final SqlPostfixOperator IS_JSON_VALUE =
new SqlPostfixOperator(
"IS JSON VALUE",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_NOT_JSON_VALUE =
new SqlPostfixOperator(
"IS NOT JSON VALUE",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_JSON_OBJECT =
new SqlPostfixOperator(
"IS JSON OBJECT",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_NOT_JSON_OBJECT =
new SqlPostfixOperator(
"IS NOT JSON OBJECT",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_JSON_ARRAY =
new SqlPostfixOperator(
"IS JSON ARRAY",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_NOT_JSON_ARRAY =
new SqlPostfixOperator(
"IS NOT JSON ARRAY",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_JSON_SCALAR =
new SqlPostfixOperator(
"IS JSON SCALAR",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator IS_NOT_JSON_SCALAR =
new SqlPostfixOperator(
"IS NOT JSON SCALAR",
SqlKind.OTHER,
28,
ReturnTypes.BOOLEAN,
null,
OperandTypes.CHARACTER);
public static final SqlPostfixOperator JSON_VALUE_EXPRESSION =
new SqlJsonValueExpressionOperator();
//-------------------------------------------------------------
// PREFIX OPERATORS
//-------------------------------------------------------------
public static final SqlPrefixOperator EXISTS =
new SqlPrefixOperator(
"EXISTS",
SqlKind.EXISTS,
40,
ReturnTypes.BOOLEAN,
null,
OperandTypes.ANY) {
public boolean argumentMustBeScalar(int ordinal) {
return false;
}
@Override public boolean validRexOperands(int count, Litmus litmus) {
if (count != 0) {
return litmus.fail("wrong operand count {} for {}", count, this);
}
return litmus.succeed();
}
};
public static final SqlPrefixOperator NOT =
new SqlPrefixOperator(
"NOT",
SqlKind.NOT,
26,
ReturnTypes.ARG0,
InferTypes.BOOLEAN,
OperandTypes.BOOLEAN);
/**
* Prefix arithmetic minus operator, '-'.
*
* Its precedence is greater than the infix '{@link #PLUS +}' and
* '{@link #MINUS -}' operators.
*/
public static final SqlPrefixOperator UNARY_MINUS =
new SqlPrefixOperator(
"-",
SqlKind.MINUS_PREFIX,
80,
ReturnTypes.ARG0,
InferTypes.RETURN_TYPE,
OperandTypes.NUMERIC_OR_INTERVAL);
/**
* Prefix arithmetic plus operator, '+'.
*
*
Its precedence is greater than the infix '{@link #PLUS +}' and
* '{@link #MINUS -}' operators.
*/
public static final SqlPrefixOperator UNARY_PLUS =
new SqlPrefixOperator(
"+",
SqlKind.PLUS_PREFIX,
80,
ReturnTypes.ARG0,
InferTypes.RETURN_TYPE,
OperandTypes.NUMERIC_OR_INTERVAL);
/**
* Keyword which allows an identifier to be explicitly flagged as a table.
* For example, select * from (TABLE t) or TABLE
* t. See also {@link #COLLECTION_TABLE}.
*/
public static final SqlPrefixOperator EXPLICIT_TABLE =
new SqlPrefixOperator(
"TABLE",
SqlKind.EXPLICIT_TABLE,
2,
null,
null,
null);
/** {@code FINAL} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlPrefixOperator FINAL =
new SqlPrefixOperator(
"FINAL",
SqlKind.FINAL,
80,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.ANY);
/** {@code RUNNING} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlPrefixOperator RUNNING =
new SqlPrefixOperator(
"RUNNING",
SqlKind.RUNNING,
80,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.ANY);
//-------------------------------------------------------------
// AGGREGATE OPERATORS
//-------------------------------------------------------------
/**
* SUM aggregate function.
*/
public static final SqlAggFunction SUM = new SqlSumAggFunction(null);
/**
* COUNT aggregate function.
*/
public static final SqlAggFunction COUNT = new SqlCountAggFunction("COUNT");
/**
* APPROX_COUNT_DISTINCT aggregate function.
*/
public static final SqlAggFunction APPROX_COUNT_DISTINCT =
new SqlCountAggFunction("APPROX_COUNT_DISTINCT");
/**
* MIN aggregate function.
*/
public static final SqlAggFunction MIN =
new SqlMinMaxAggFunction(SqlKind.MIN);
/**
* MAX aggregate function.
*/
public static final SqlAggFunction MAX =
new SqlMinMaxAggFunction(SqlKind.MAX);
/**
* EVERY aggregate function.
*/
public static final SqlAggFunction EVERY =
new SqlMinMaxAggFunction("EVERY", SqlKind.MIN, OperandTypes.BOOLEAN);
/**
* SOME aggregate function.
*/
public static final SqlAggFunction SOME =
new SqlMinMaxAggFunction("SOME", SqlKind.MAX, OperandTypes.BOOLEAN);
/**
* LAST_VALUE aggregate function.
*/
public static final SqlAggFunction LAST_VALUE =
new SqlFirstLastValueAggFunction(SqlKind.LAST_VALUE);
/**
* ANY_VALUE aggregate function.
*/
public static final SqlAggFunction ANY_VALUE =
new SqlAnyValueAggFunction(SqlKind.ANY_VALUE);
/**
* FIRST_VALUE aggregate function.
*/
public static final SqlAggFunction FIRST_VALUE =
new SqlFirstLastValueAggFunction(SqlKind.FIRST_VALUE);
/**
* NTH_VALUE aggregate function.
*/
public static final SqlAggFunction NTH_VALUE =
new SqlNthValueAggFunction(SqlKind.NTH_VALUE);
/**
* LEAD aggregate function.
*/
public static final SqlAggFunction LEAD =
new SqlLeadLagAggFunction(SqlKind.LEAD);
/**
* LAG aggregate function.
*/
public static final SqlAggFunction LAG =
new SqlLeadLagAggFunction(SqlKind.LAG);
/**
* NTILE aggregate function.
*/
public static final SqlAggFunction NTILE =
new SqlNtileAggFunction();
/**
* SINGLE_VALUE aggregate function.
*/
public static final SqlAggFunction SINGLE_VALUE =
new SqlSingleValueAggFunction(null);
/**
* AVG aggregate function.
*/
public static final SqlAggFunction AVG =
new SqlAvgAggFunction(SqlKind.AVG);
/**
* STDDEV_POP aggregate function.
*/
public static final SqlAggFunction STDDEV_POP =
new SqlAvgAggFunction(SqlKind.STDDEV_POP);
/**
* REGR_COUNT aggregate function.
*/
public static final SqlAggFunction REGR_COUNT =
new SqlRegrCountAggFunction(SqlKind.REGR_COUNT);
/**
* REGR_SXX aggregate function.
*/
public static final SqlAggFunction REGR_SXX =
new SqlCovarAggFunction(SqlKind.REGR_SXX);
/**
* REGR_SYY aggregate function.
*/
public static final SqlAggFunction REGR_SYY =
new SqlCovarAggFunction(SqlKind.REGR_SYY);
/**
* COVAR_POP aggregate function.
*/
public static final SqlAggFunction COVAR_POP =
new SqlCovarAggFunction(SqlKind.COVAR_POP);
/**
* COVAR_SAMP aggregate function.
*/
public static final SqlAggFunction COVAR_SAMP =
new SqlCovarAggFunction(SqlKind.COVAR_SAMP);
/**
* STDDEV_SAMP aggregate function.
*/
public static final SqlAggFunction STDDEV_SAMP =
new SqlAvgAggFunction(SqlKind.STDDEV_SAMP);
/**
* STDDEV aggregate function.
*/
public static final SqlAggFunction STDDEV =
new SqlAvgAggFunction("STDDEV", SqlKind.STDDEV_SAMP);
/**
* VAR_POP aggregate function.
*/
public static final SqlAggFunction VAR_POP =
new SqlAvgAggFunction(SqlKind.VAR_POP);
/**
* VAR_SAMP aggregate function.
*/
public static final SqlAggFunction VAR_SAMP =
new SqlAvgAggFunction(SqlKind.VAR_SAMP);
/**
* VARIANCE aggregate function.
*/
public static final SqlAggFunction VARIANCE =
new SqlAvgAggFunction("VARIANCE", SqlKind.VAR_SAMP);
/**
* BIT_AND aggregate function.
*/
public static final SqlAggFunction BIT_AND =
new SqlBitOpAggFunction(SqlKind.BIT_AND);
/**
* BIT_OR aggregate function.
*/
public static final SqlAggFunction BIT_OR =
new SqlBitOpAggFunction(SqlKind.BIT_OR);
/**
* BIT_XOR aggregate function.
*/
public static final SqlAggFunction BIT_XOR =
new SqlBitOpAggFunction(SqlKind.BIT_XOR);
//-------------------------------------------------------------
// WINDOW Aggregate Functions
//-------------------------------------------------------------
/**
* HISTOGRAM aggregate function support. Used by window
* aggregate versions of MIN/MAX
*/
public static final SqlAggFunction HISTOGRAM_AGG =
new SqlHistogramAggFunction(null);
/**
* HISTOGRAM_MIN window aggregate function.
*/
public static final SqlFunction HISTOGRAM_MIN =
new SqlFunction(
"$HISTOGRAM_MIN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OR_STRING,
SqlFunctionCategory.NUMERIC);
/**
* HISTOGRAM_MAX window aggregate function.
*/
public static final SqlFunction HISTOGRAM_MAX =
new SqlFunction(
"$HISTOGRAM_MAX",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OR_STRING,
SqlFunctionCategory.NUMERIC);
/**
* HISTOGRAM_FIRST_VALUE window aggregate function.
*/
public static final SqlFunction HISTOGRAM_FIRST_VALUE =
new SqlFunction(
"$HISTOGRAM_FIRST_VALUE",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OR_STRING,
SqlFunctionCategory.NUMERIC);
/**
* HISTOGRAM_LAST_VALUE window aggregate function.
*/
public static final SqlFunction HISTOGRAM_LAST_VALUE =
new SqlFunction(
"$HISTOGRAM_LAST_VALUE",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OR_STRING,
SqlFunctionCategory.NUMERIC);
/**
* SUM0 aggregate function.
*/
public static final SqlAggFunction SUM0 =
new SqlSumEmptyIsZeroAggFunction();
//-------------------------------------------------------------
// WINDOW Rank Functions
//-------------------------------------------------------------
/**
* CUME_DIST window function.
*/
public static final SqlRankFunction CUME_DIST =
new SqlRankFunction(SqlKind.CUME_DIST, ReturnTypes.FRACTIONAL_RANK, true);
/**
* DENSE_RANK window function.
*/
public static final SqlRankFunction DENSE_RANK =
new SqlRankFunction(SqlKind.DENSE_RANK, ReturnTypes.RANK, true);
/**
* PERCENT_RANK window function.
*/
public static final SqlRankFunction PERCENT_RANK =
new SqlRankFunction(SqlKind.PERCENT_RANK,
ReturnTypes.FRACTIONAL_RANK,
true);
/**
* RANK window function.
*/
public static final SqlRankFunction RANK =
new SqlRankFunction(SqlKind.RANK, ReturnTypes.RANK, true);
/**
* ROW_NUMBER window function.
*/
public static final SqlRankFunction ROW_NUMBER =
new SqlRankFunction(SqlKind.ROW_NUMBER, ReturnTypes.RANK, false);
//-------------------------------------------------------------
// SPECIAL OPERATORS
//-------------------------------------------------------------
public static final SqlRowOperator ROW = new SqlRowOperator("ROW");
/** IGNORE NULLS operator. */
public static final SqlNullTreatmentOperator IGNORE_NULLS =
new SqlNullTreatmentOperator(SqlKind.IGNORE_NULLS);
/** RESPECT NULLS operator. */
public static final SqlNullTreatmentOperator RESPECT_NULLS =
new SqlNullTreatmentOperator(SqlKind.RESPECT_NULLS);
/**
* A special operator for the subtraction of two DATETIMEs. The format of
* DATETIME subtraction is:
*
*
"(" <datetime> "-" <datetime> ")"
* <interval qualifier>
*
* This operator is special since it needs to hold the
* additional interval qualifier specification.
*/
public static final SqlDatetimeSubtractionOperator MINUS_DATE =
new SqlDatetimeSubtractionOperator();
/**
* The MULTISET Value Constructor. e.g. "MULTISET[1,2,3]".
*/
public static final SqlMultisetValueConstructor MULTISET_VALUE =
new SqlMultisetValueConstructor();
/**
* The MULTISET Query Constructor. e.g. "SELECT dname, MULTISET(SELECT
* FROM emp WHERE deptno = dept.deptno) FROM dept".
*/
public static final SqlMultisetQueryConstructor MULTISET_QUERY =
new SqlMultisetQueryConstructor();
/**
* The ARRAY Query Constructor. e.g. "SELECT dname, ARRAY(SELECT
* FROM emp WHERE deptno = dept.deptno) FROM dept".
*/
public static final SqlMultisetQueryConstructor ARRAY_QUERY =
new SqlArrayQueryConstructor();
/**
* The MAP Query Constructor. e.g. "MAP(SELECT empno, deptno
* FROM emp)".
*/
public static final SqlMultisetQueryConstructor MAP_QUERY =
new SqlMapQueryConstructor();
/**
* The CURSOR constructor. e.g. "SELECT * FROM
* TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), 'name'))".
*/
public static final SqlCursorConstructor CURSOR =
new SqlCursorConstructor();
/**
* The COLUMN_LIST constructor. e.g. the ROW() call in "SELECT * FROM
* TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), ROW(name, empno)))".
*/
public static final SqlColumnListConstructor COLUMN_LIST =
new SqlColumnListConstructor();
/**
* The UNNEST operator.
*/
public static final SqlUnnestOperator UNNEST =
new SqlUnnestOperator(false);
/**
* The UNNEST WITH ORDINALITY operator.
*/
public static final SqlUnnestOperator UNNEST_WITH_ORDINALITY =
new SqlUnnestOperator(true);
/**
* The LATERAL operator.
*/
public static final SqlSpecialOperator LATERAL =
new SqlLateralOperator(SqlKind.LATERAL);
/**
* The "table function derived table" operator, which a table-valued
* function into a relation, e.g. "SELECT * FROM
* TABLE(ramp(5))".
*
* This operator has function syntax (with one argument), whereas
* {@link #EXPLICIT_TABLE} is a prefix operator.
*/
public static final SqlSpecialOperator COLLECTION_TABLE =
new SqlCollectionTableOperator("TABLE", SqlModality.RELATION);
public static final SqlOverlapsOperator OVERLAPS =
new SqlOverlapsOperator(SqlKind.OVERLAPS);
public static final SqlOverlapsOperator CONTAINS =
new SqlOverlapsOperator(SqlKind.CONTAINS);
public static final SqlOverlapsOperator PRECEDES =
new SqlOverlapsOperator(SqlKind.PRECEDES);
public static final SqlOverlapsOperator IMMEDIATELY_PRECEDES =
new SqlOverlapsOperator(SqlKind.IMMEDIATELY_PRECEDES);
public static final SqlOverlapsOperator SUCCEEDS =
new SqlOverlapsOperator(SqlKind.SUCCEEDS);
public static final SqlOverlapsOperator IMMEDIATELY_SUCCEEDS =
new SqlOverlapsOperator(SqlKind.IMMEDIATELY_SUCCEEDS);
public static final SqlOverlapsOperator PERIOD_EQUALS =
new SqlOverlapsOperator(SqlKind.PERIOD_EQUALS);
public static final SqlSpecialOperator VALUES =
new SqlValuesOperator();
public static final SqlLiteralChainOperator LITERAL_CHAIN =
new SqlLiteralChainOperator();
public static final SqlThrowOperator THROW = new SqlThrowOperator();
public static final SqlFunction JSON_EXISTS = new SqlJsonExistsFunction();
public static final SqlFunction JSON_VALUE =
new SqlJsonValueFunction("JSON_VALUE");
public static final SqlFunction JSON_QUERY = new SqlJsonQueryFunction();
public static final SqlFunction JSON_OBJECT = new SqlJsonObjectFunction();
public static final SqlJsonObjectAggAggFunction JSON_OBJECTAGG =
new SqlJsonObjectAggAggFunction(SqlKind.JSON_OBJECTAGG,
SqlJsonConstructorNullClause.NULL_ON_NULL);
public static final SqlFunction JSON_ARRAY = new SqlJsonArrayFunction();
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_TYPE = SqlLibraryOperators.JSON_TYPE;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_DEPTH = SqlLibraryOperators.JSON_DEPTH;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_LENGTH = SqlLibraryOperators.JSON_LENGTH;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_KEYS = SqlLibraryOperators.JSON_KEYS;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_PRETTY = SqlLibraryOperators.JSON_PRETTY;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_REMOVE = SqlLibraryOperators.JSON_REMOVE;
@Deprecated // to be removed before 2.0
public static final SqlFunction JSON_STORAGE_SIZE = SqlLibraryOperators.JSON_STORAGE_SIZE;
public static final SqlJsonArrayAggAggFunction JSON_ARRAYAGG =
new SqlJsonArrayAggAggFunction(SqlKind.JSON_ARRAYAGG,
SqlJsonConstructorNullClause.ABSENT_ON_NULL);
public static final SqlBetweenOperator BETWEEN =
new SqlBetweenOperator(
SqlBetweenOperator.Flag.ASYMMETRIC,
false);
public static final SqlBetweenOperator SYMMETRIC_BETWEEN =
new SqlBetweenOperator(
SqlBetweenOperator.Flag.SYMMETRIC,
false);
public static final SqlBetweenOperator NOT_BETWEEN =
new SqlBetweenOperator(
SqlBetweenOperator.Flag.ASYMMETRIC,
true);
public static final SqlBetweenOperator SYMMETRIC_NOT_BETWEEN =
new SqlBetweenOperator(
SqlBetweenOperator.Flag.SYMMETRIC,
true);
public static final SqlSpecialOperator NOT_LIKE =
new SqlLikeOperator("NOT LIKE", SqlKind.LIKE, true);
public static final SqlSpecialOperator LIKE =
new SqlLikeOperator("LIKE", SqlKind.LIKE, false);
public static final SqlSpecialOperator NOT_SIMILAR_TO =
new SqlLikeOperator("NOT SIMILAR TO", SqlKind.SIMILAR, true);
public static final SqlSpecialOperator SIMILAR_TO =
new SqlLikeOperator("SIMILAR TO", SqlKind.SIMILAR, false);
public static final SqlBinaryOperator POSIX_REGEX_CASE_SENSITIVE = new SqlPosixRegexOperator(
"POSIX REGEX CASE SENSITIVE", SqlKind.POSIX_REGEX_CASE_SENSITIVE, true, false);
public static final SqlBinaryOperator POSIX_REGEX_CASE_INSENSITIVE = new SqlPosixRegexOperator(
"POSIX REGEX CASE INSENSITIVE", SqlKind.POSIX_REGEX_CASE_INSENSITIVE, false, false);
public static final SqlBinaryOperator NEGATED_POSIX_REGEX_CASE_SENSITIVE =
new SqlPosixRegexOperator("NEGATED POSIX REGEX CASE SENSITIVE",
SqlKind.POSIX_REGEX_CASE_SENSITIVE, true, true);
public static final SqlBinaryOperator NEGATED_POSIX_REGEX_CASE_INSENSITIVE =
new SqlPosixRegexOperator("NEGATED POSIX REGEX CASE INSENSITIVE",
SqlKind.POSIX_REGEX_CASE_INSENSITIVE, false, true);
/**
* Internal operator used to represent the ESCAPE clause of a LIKE or
* SIMILAR TO expression.
*/
public static final SqlSpecialOperator ESCAPE =
new SqlSpecialOperator("ESCAPE", SqlKind.ESCAPE, 0);
public static final SqlCaseOperator CASE = SqlCaseOperator.INSTANCE;
public static final SqlOperator PROCEDURE_CALL =
new SqlProcedureCallOperator();
public static final SqlOperator NEW = new SqlNewOperator();
/**
* The OVER operator, which applies an aggregate functions to a
* {@link SqlWindow window}.
*
*
Operands are as follows:
*
*
* - name of window function ({@link com.hazelcast.org.apache.calcite.sql.SqlCall})
* - window name ({@link com.hazelcast.org.apache.calcite.sql.SqlLiteral}) or window
* in-line specification (@link SqlWindowOperator})
*
*/
public static final SqlBinaryOperator OVER = new SqlOverOperator();
/**
* An REINTERPRET operator is internal to the planner. When the
* physical storage of two types is the same, this operator may be used to
* reinterpret values of one type as the other. This operator is similar to
* a cast, except that it does not alter the data value. Like a regular cast
* it accepts one operand and stores the target type as the return type. It
* performs an overflow check if it has any second operand, whether
* true or not.
*/
public static final SqlSpecialOperator REINTERPRET =
new SqlSpecialOperator("Reinterpret", SqlKind.REINTERPRET) {
public SqlOperandCountRange getOperandCountRange() {
return SqlOperandCountRanges.between(1, 2);
}
};
//-------------------------------------------------------------
// FUNCTIONS
//-------------------------------------------------------------
/**
* The character substring function: SUBSTRING(string FROM start [FOR
* length]).
*
* If the length parameter is a constant, the length of the result is the
* minimum of the length of the input and that length. Otherwise it is the
* length of the input.
*/
public static final SqlFunction SUBSTRING = new SqlSubstringFunction();
/** The {@code REPLACE(string, search, replace)} function. Not standard SQL,
* but in Oracle and Postgres. */
public static final SqlFunction REPLACE =
new SqlFunction("REPLACE", SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE_VARYING, null,
OperandTypes.STRING_STRING_STRING, SqlFunctionCategory.STRING);
public static final SqlFunction CONVERT =
new SqlConvertFunction("CONVERT");
/**
* The TRANSLATE(char_value USING translation_name) function
* alters the character set of a string value from one base character set to another.
*
*
It is defined in the SQL standard. See also the non-standard
* {@link SqlLibraryOperators#TRANSLATE3}, which has a different purpose.
*/
public static final SqlFunction TRANSLATE =
new SqlConvertFunction("TRANSLATE");
public static final SqlFunction OVERLAY = new SqlOverlayFunction();
/** The "TRIM" function. */
public static final SqlFunction TRIM = SqlTrimFunction.INSTANCE;
public static final SqlFunction POSITION = new SqlPositionFunction();
public static final SqlFunction CHAR_LENGTH =
new SqlFunction(
"CHAR_LENGTH",
SqlKind.OTHER_FUNCTION,
ReturnTypes.INTEGER_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction CHARACTER_LENGTH =
new SqlFunction(
"CHARACTER_LENGTH",
SqlKind.OTHER_FUNCTION,
ReturnTypes.INTEGER_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction UPPER =
new SqlFunction(
"UPPER",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.STRING);
public static final SqlFunction LOWER =
new SqlFunction(
"LOWER",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.STRING);
public static final SqlFunction INITCAP =
new SqlFunction(
"INITCAP",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.STRING);
public static final SqlFunction ASCII =
new SqlFunction(
"ASCII",
SqlKind.OTHER_FUNCTION,
ReturnTypes.INTEGER_NULLABLE,
null,
OperandTypes.CHARACTER,
SqlFunctionCategory.STRING);
/**
* Uses SqlOperatorTable.useDouble for its return type since we don't know
* what the result type will be by just looking at the operand types. For
* example POW(int, int) can return a non integer if the second operand is
* negative.
*/
public static final SqlFunction POWER =
new SqlFunction(
"POWER",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC_NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction SQRT =
new SqlFunction(
"SQRT",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
/**
* Arithmetic remainder function {@code MOD}.
*
* @see #PERCENT_REMAINDER
*/
public static final SqlFunction MOD =
// Return type is same as divisor (2nd operand)
// SQL2003 Part2 Section 6.27, Syntax Rules 9
new SqlFunction(
"MOD",
SqlKind.MOD,
ReturnTypes.NULLABLE_MOD,
null,
OperandTypes.EXACT_NUMERIC_EXACT_NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction LN =
new SqlFunction(
"LN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction LOG10 =
new SqlFunction(
"LOG10",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ABS =
new SqlFunction(
"ABS",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0,
null,
OperandTypes.NUMERIC_OR_INTERVAL,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ACOS =
new SqlFunction(
"ACOS",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ASIN =
new SqlFunction(
"ASIN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ATAN =
new SqlFunction(
"ATAN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ATAN2 =
new SqlFunction(
"ATAN2",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC_NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction CBRT =
new SqlFunction(
"CBRT",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction COS =
new SqlFunction(
"COS",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction COT =
new SqlFunction(
"COT",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction DEGREES =
new SqlFunction(
"DEGREES",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction EXP =
new SqlFunction(
"EXP",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction RADIANS =
new SqlFunction(
"RADIANS",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction ROUND =
new SqlFunction(
"ROUND",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OPTIONAL_INTEGER,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction SIGN =
new SqlFunction(
"SIGN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction SIN =
new SqlFunction(
"SIN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction TAN =
new SqlFunction(
"TAN",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE_NULLABLE,
null,
OperandTypes.NUMERIC,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction TRUNCATE =
new SqlFunction(
"TRUNCATE",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.NUMERIC_OPTIONAL_INTEGER,
SqlFunctionCategory.NUMERIC);
public static final SqlFunction PI =
new SqlFunction(
"PI",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DOUBLE,
null,
OperandTypes.NILADIC,
SqlFunctionCategory.NUMERIC) {
public SqlSyntax getSyntax() {
return SqlSyntax.FUNCTION_ID;
}
};
/** {@code FIRST} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlFunction FIRST =
new SqlFunction("FIRST", SqlKind.FIRST, ReturnTypes.ARG0_NULLABLE,
null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
/** {@code LAST} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlMatchFunction LAST =
new SqlMatchFunction("LAST", SqlKind.LAST, ReturnTypes.ARG0_NULLABLE,
null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
/** {@code PREV} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlMatchFunction PREV =
new SqlMatchFunction("PREV", SqlKind.PREV, ReturnTypes.ARG0_NULLABLE,
null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
/** {@code NEXT} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlFunction NEXT =
new SqlFunction("NEXT", SqlKind.NEXT, ReturnTypes.ARG0_NULLABLE, null,
OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
/** {@code CLASSIFIER} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlMatchFunction CLASSIFIER =
new SqlMatchFunction("CLASSIFIER", SqlKind.CLASSIFIER, ReturnTypes.VARCHAR_2000,
null, OperandTypes.NILADIC, SqlFunctionCategory.MATCH_RECOGNIZE);
/** {@code MATCH_NUMBER} function to be used within {@code MATCH_RECOGNIZE}. */
public static final SqlFunction MATCH_NUMBER =
new SqlFunction("MATCH_NUMBER ", SqlKind.MATCH_NUMBER, ReturnTypes.BIGINT_NULLABLE,
null, OperandTypes.NILADIC, SqlFunctionCategory.MATCH_RECOGNIZE);
public static final SqlFunction NULLIF = new SqlNullifFunction();
/**
* The COALESCE builtin function.
*/
public static final SqlFunction COALESCE = new SqlCoalesceFunction();
/**
* The FLOOR function.
*/
public static final SqlFunction FLOOR = new SqlFloorFunction(SqlKind.FLOOR);
/**
* The CEIL function.
*/
public static final SqlFunction CEIL = new SqlFloorFunction(SqlKind.CEIL);
/**
* The USER function.
*/
public static final SqlFunction USER =
new SqlStringContextVariable("USER");
/**
* The CURRENT_USER function.
*/
public static final SqlFunction CURRENT_USER =
new SqlStringContextVariable("CURRENT_USER");
/**
* The SESSION_USER function.
*/
public static final SqlFunction SESSION_USER =
new SqlStringContextVariable("SESSION_USER");
/**
* The SYSTEM_USER function.
*/
public static final SqlFunction SYSTEM_USER =
new SqlStringContextVariable("SYSTEM_USER");
/**
* The CURRENT_PATH function.
*/
public static final SqlFunction CURRENT_PATH =
new SqlStringContextVariable("CURRENT_PATH");
/**
* The CURRENT_ROLE function.
*/
public static final SqlFunction CURRENT_ROLE =
new SqlStringContextVariable("CURRENT_ROLE");
/**
* The CURRENT_CATALOG function.
*/
public static final SqlFunction CURRENT_CATALOG =
new SqlStringContextVariable("CURRENT_CATALOG");
/**
* The CURRENT_SCHEMA function.
*/
public static final SqlFunction CURRENT_SCHEMA =
new SqlStringContextVariable("CURRENT_SCHEMA");
/**
* The LOCALTIME [(precision)] function.
*/
public static final SqlFunction LOCALTIME =
new SqlAbstractTimeFunction("LOCALTIME", SqlTypeName.TIME);
/**
* The LOCALTIMESTAMP [(precision)] function.
*/
public static final SqlFunction LOCALTIMESTAMP =
new SqlAbstractTimeFunction("LOCALTIMESTAMP", SqlTypeName.TIMESTAMP);
/**
* The CURRENT_TIME [(precision)] function.
*/
public static final SqlFunction CURRENT_TIME =
new SqlAbstractTimeFunction("CURRENT_TIME", SqlTypeName.TIME);
/**
* The CURRENT_TIMESTAMP [(precision)] function.
*/
public static final SqlFunction CURRENT_TIMESTAMP =
new SqlAbstractTimeFunction("CURRENT_TIMESTAMP", SqlTypeName.TIMESTAMP);
/**
* The CURRENT_DATE function.
*/
public static final SqlFunction CURRENT_DATE =
new SqlCurrentDateFunction();
/** The TIMESTAMPADD function. */
public static final SqlFunction TIMESTAMP_ADD = new SqlTimestampAddFunction();
/** The TIMESTAMPDIFF function. */
public static final SqlFunction TIMESTAMP_DIFF = new SqlTimestampDiffFunction();
/**
* Use of the IN_FENNEL operator forces the argument to be
* evaluated in Fennel. Otherwise acts as identity function.
*/
public static final SqlFunction IN_FENNEL =
new SqlMonotonicUnaryFunction(
"$IN_FENNEL",
SqlKind.OTHER_FUNCTION,
ReturnTypes.ARG0,
null,
OperandTypes.ANY,
SqlFunctionCategory.SYSTEM);
/**
* The SQL CAST operator.
*
*
The SQL syntax is
*
*
CAST(expression AS type)
*
*
* When the CAST operator is applies as a {@link SqlCall}, it has two
* arguments: the expression and the type. The type must not include a
* constraint, so CAST(x AS INTEGER NOT NULL), for instance, is
* invalid.
*
* When the CAST operator is applied as a RexCall, the
* target type is simply stored as the return type, not an explicit operand.
* For example, the expression CAST(1 + 2 AS DOUBLE) will
* become a call to CAST with the expression 1 + 2
* as its only operand.
*
* The RexCall form can also have a type which contains a
* NOT NULL constraint. When this expression is implemented, if
* the value is NULL, an exception will be thrown.
*/
public static final SqlFunction CAST = new SqlCastFunction();
/**
* The SQL EXTRACT operator. Extracts a specified field value
* from a DATETIME or an INTERVAL. E.g.
* EXTRACT(HOUR FROM INTERVAL '364 23:59:59') returns
* 23
*/
public static final SqlFunction EXTRACT = new SqlExtractFunction();
/**
* The SQL YEAR operator. Returns the Year
* from a DATETIME E.g.
* YEAR(date '2008-9-23') returns
* 2008
*/
public static final SqlDatePartFunction YEAR =
new SqlDatePartFunction("YEAR", TimeUnit.YEAR);
/**
* The SQL QUARTER operator. Returns the Quarter
* from a DATETIME E.g.
* QUARTER(date '2008-9-23') returns
* 3
*/
public static final SqlDatePartFunction QUARTER =
new SqlDatePartFunction("QUARTER", TimeUnit.QUARTER);
/**
* The SQL MONTH operator. Returns the Month
* from a DATETIME E.g.
* MONTH(date '2008-9-23') returns
* 9
*/
public static final SqlDatePartFunction MONTH =
new SqlDatePartFunction("MONTH", TimeUnit.MONTH);
/**
* The SQL WEEK operator. Returns the Week
* from a DATETIME E.g.
* WEEK(date '2008-9-23') returns
* 39
*/
public static final SqlDatePartFunction WEEK =
new SqlDatePartFunction("WEEK", TimeUnit.WEEK);
/**
* The SQL DAYOFYEAR operator. Returns the DOY
* from a DATETIME E.g.
* DAYOFYEAR(date '2008-9-23') returns
* 267
*/
public static final SqlDatePartFunction DAYOFYEAR =
new SqlDatePartFunction("DAYOFYEAR", TimeUnit.DOY);
/**
* The SQL DAYOFMONTH operator. Returns the Day
* from a DATETIME E.g.
* DAYOFMONTH(date '2008-9-23') returns
* 23
*/
public static final SqlDatePartFunction DAYOFMONTH =
new SqlDatePartFunction("DAYOFMONTH", TimeUnit.DAY);
/**
* The SQL DAYOFWEEK operator. Returns the DOW
* from a DATETIME E.g.
* DAYOFWEEK(date '2008-9-23') returns
* 2
*/
public static final SqlDatePartFunction DAYOFWEEK =
new SqlDatePartFunction("DAYOFWEEK", TimeUnit.DOW);
/**
* The SQL HOUR operator. Returns the Hour
* from a DATETIME E.g.
* HOUR(timestamp '2008-9-23 01:23:45') returns
* 1
*/
public static final SqlDatePartFunction HOUR =
new SqlDatePartFunction("HOUR", TimeUnit.HOUR);
/**
* The SQL MINUTE operator. Returns the Minute
* from a DATETIME E.g.
* MINUTE(timestamp '2008-9-23 01:23:45') returns
* 23
*/
public static final SqlDatePartFunction MINUTE =
new SqlDatePartFunction("MINUTE", TimeUnit.MINUTE);
/**
* The SQL SECOND operator. Returns the Second
* from a DATETIME E.g.
* SECOND(timestamp '2008-9-23 01:23:45') returns
* 45
*/
public static final SqlDatePartFunction SECOND =
new SqlDatePartFunction("SECOND", TimeUnit.SECOND);
public static final SqlFunction LAST_DAY =
new SqlFunction(
"LAST_DAY",
SqlKind.OTHER_FUNCTION,
ReturnTypes.DATE_NULLABLE,
null,
OperandTypes.DATETIME,
SqlFunctionCategory.TIMEDATE);
/**
* The ELEMENT operator, used to convert a multiset with only one item to a
* "regular" type. Example ... log(ELEMENT(MULTISET[1])) ...
*/
public static final SqlFunction ELEMENT =
new SqlFunction(
"ELEMENT",
SqlKind.OTHER_FUNCTION,
ReturnTypes.MULTISET_ELEMENT_NULLABLE,
null,
OperandTypes.COLLECTION,
SqlFunctionCategory.SYSTEM);
/**
* The item operator {@code [ ... ]}, used to access a given element of an
* array or map. For example, {@code myArray[3]} or {@code "myMap['foo']"}.
*
* The SQL standard calls the ARRAY variant a
* <array element reference>. Index is 1-based. The standard says
* to raise "data exception - array element error" but we currently return
* null.
*
* MAP is not standard SQL.
*/
public static final SqlOperator ITEM = new SqlItemOperator();
/**
* The ARRAY Value Constructor. e.g. "ARRAY[1, 2, 3]".
*/
public static final SqlArrayValueConstructor ARRAY_VALUE_CONSTRUCTOR =
new SqlArrayValueConstructor();
/**
* The MAP Value Constructor,
* e.g. "MAP['washington', 1, 'obama', 44]".
*/
public static final SqlMapValueConstructor MAP_VALUE_CONSTRUCTOR =
new SqlMapValueConstructor();
/**
* The internal "$SLICE" operator takes a multiset of records and returns a
* multiset of the first column of those records.
*
* It is introduced when multisets of scalar types are created, in order
* to keep types consistent. For example, MULTISET [5] has type
* INTEGER MULTISET but is translated to an expression of type
* RECORD(INTEGER EXPR$0) MULTISET because in our internal
* representation of multisets, every element must be a record. Applying the
* "$SLICE" operator to this result converts the type back to an
* INTEGER MULTISET multiset value.
*
*
$SLICE is often translated away when the multiset type is
* converted back to scalar values.
*/
public static final SqlInternalOperator SLICE =
new SqlInternalOperator(
"$SLICE",
SqlKind.OTHER,
0,
false,
ReturnTypes.MULTISET_PROJECT0,
null,
OperandTypes.RECORD_COLLECTION) {
};
/**
* The internal "$ELEMENT_SLICE" operator returns the first field of the
* only element of a multiset.
*
*
It is introduced when multisets of scalar types are created, in order
* to keep types consistent. For example, ELEMENT(MULTISET [5])
* is translated to $ELEMENT_SLICE(MULTISET (VALUES ROW (5
* EXPR$0)) It is translated away when the multiset type is converted
* back to scalar values.
*
* NOTE: jhyde, 2006/1/9: Usages of this operator are commented out, but
* I'm not deleting the operator, because some multiset tests are disabled,
* and we may need this operator to get them working!
*/
public static final SqlInternalOperator ELEMENT_SLICE =
new SqlInternalOperator(
"$ELEMENT_SLICE",
SqlKind.OTHER,
0,
false,
ReturnTypes.MULTISET_RECORD,
null,
OperandTypes.MULTISET) {
public void unparse(
SqlWriter writer,
SqlCall call,
int leftPrec,
int rightPrec) {
SqlUtil.unparseFunctionSyntax(
this,
writer, call);
}
};
/**
* The internal "$SCALAR_QUERY" operator returns a scalar value from a
* record type. It assumes the record type only has one field, and returns
* that field as the output.
*/
public static final SqlInternalOperator SCALAR_QUERY =
new SqlInternalOperator(
"$SCALAR_QUERY",
SqlKind.SCALAR_QUERY,
0,
false,
ReturnTypes.RECORD_TO_SCALAR,
null,
OperandTypes.RECORD_TO_SCALAR) {
public void unparse(
SqlWriter writer,
SqlCall call,
int leftPrec,
int rightPrec) {
final SqlWriter.Frame frame = writer.startList("(", ")");
call.operand(0).unparse(writer, 0, 0);
writer.endList(frame);
}
public boolean argumentMustBeScalar(int ordinal) {
// Obvious, really.
return false;
}
};
/**
* The internal {@code $STRUCT_ACCESS} operator is used to access a
* field of a record.
*
* In contrast with {@link #DOT} operator, it never appears in an
* {@link SqlNode} tree and allows to access fields by position and
* not by name.
*/
public static final SqlInternalOperator STRUCT_ACCESS =
new SqlInternalOperator("$STRUCT_ACCESS", SqlKind.OTHER);
/**
* The CARDINALITY operator, used to retrieve the number of elements in a
* MULTISET, ARRAY or MAP.
*/
public static final SqlFunction CARDINALITY =
new SqlFunction(
"CARDINALITY",
SqlKind.OTHER_FUNCTION,
ReturnTypes.INTEGER_NULLABLE,
null,
OperandTypes.COLLECTION_OR_MAP,
SqlFunctionCategory.SYSTEM);
/**
* The COLLECT operator. Multiset aggregator function.
*/
public static final SqlAggFunction COLLECT =
new SqlAggFunction("COLLECT",
null,
SqlKind.COLLECT,
ReturnTypes.TO_MULTISET,
null,
OperandTypes.ANY,
SqlFunctionCategory.SYSTEM, false, false,
Optionality.OPTIONAL) {
};
/**
* The LISTAGG operator. Multiset aggregator function.
*/
public static final SqlAggFunction LISTAGG =
new SqlAggFunction("LISTAGG",
null,
SqlKind.LISTAGG,
ReturnTypes.ARG0_NULLABLE,
null,
OperandTypes.or(OperandTypes.STRING, OperandTypes.STRING_STRING),
SqlFunctionCategory.SYSTEM, false, false,
Optionality.OPTIONAL) {
};
/**
* The FUSION operator. Multiset aggregator function.
*/
public static final SqlAggFunction FUSION =
new SqlAggFunction("FUSION", null,
SqlKind.FUSION,
ReturnTypes.ARG0,
null,
OperandTypes.MULTISET,
SqlFunctionCategory.SYSTEM, false, false,
Optionality.FORBIDDEN) {
};
/**
* The INTERSECTION operator. Multiset aggregator function.
*/
public static final SqlAggFunction INTERSECTION =
new SqlAggFunction("INTERSECTION", null,
SqlKind.INTERSECTION,
ReturnTypes.ARG0,
null,
OperandTypes.MULTISET,
SqlFunctionCategory.SYSTEM, false, false,
Optionality.FORBIDDEN) {
};
/**
* The sequence next value function: NEXT VALUE FOR sequence
*/
public static final SqlOperator NEXT_VALUE =
new SqlSequenceValueOperator(SqlKind.NEXT_VALUE);
/**
* The sequence current value function: CURRENT VALUE FOR
* sequence
*/
public static final SqlOperator CURRENT_VALUE =
new SqlSequenceValueOperator(SqlKind.CURRENT_VALUE);
/**
* The TABLESAMPLE operator.
*
*
Examples:
*
*
* <query> TABLESAMPLE SUBSTITUTE('sampleName')
* (non-standard)
* <query> TABLESAMPLE BERNOULLI(<percent>)
* [REPEATABLE(<seed>)] (standard, but not implemented for FTRS
* yet)
* <query> TABLESAMPLE SYSTEM(<percent>)
* [REPEATABLE(<seed>)] (standard, but not implemented for FTRS
* yet)
*
*
* Operand #0 is a query or table; Operand #1 is a {@link SqlSampleSpec}
* wrapped in a {@link SqlLiteral}.
*/
public static final SqlSpecialOperator TABLESAMPLE =
new SqlSpecialOperator(
"TABLESAMPLE",
SqlKind.TABLESAMPLE,
20,
true,
ReturnTypes.ARG0,
null,
OperandTypes.VARIADIC) {
public void unparse(
SqlWriter writer,
SqlCall call,
int leftPrec,
int rightPrec) {
call.operand(0).unparse(writer, leftPrec, 0);
writer.keyword("TABLESAMPLE");
call.operand(1).unparse(writer, 0, rightPrec);
}
};
/** DESCRIPTOR(column_name, ...). */
public static final SqlOperator DESCRIPTOR = new SqlDescriptorOperator();
/** TUMBLE as a table function. */
public static final SqlFunction TUMBLE = new SqlTumbleTableFunction();
/** HOP as a table function. */
public static final SqlFunction HOP = new SqlHopTableFunction();
/** SESSION as a table function. */
public static final SqlFunction SESSION = new SqlSessionTableFunction();
/** The {@code TUMBLE} group function.
*
*
This operator is named "$TUMBLE" (not "TUMBLE") because it is created
* directly by the parser, not by looking up an operator by name.
*
*
Why did we add TUMBLE to the parser? Because we plan to support TUMBLE
* as a table function (see [CALCITE-3272]); "TUMBLE" as a name will only be
* used by the TUMBLE table function.
*
*
After the TUMBLE table function is introduced, we plan to deprecate
* this TUMBLE group function, and in fact all group functions. See
* [CALCITE-3340] for details.
*/
public static final SqlGroupedWindowFunction TUMBLE_OLD =
new SqlGroupedWindowFunction("$TUMBLE", SqlKind.TUMBLE,
null, ReturnTypes.ARG0, null,
OperandTypes.or(OperandTypes.DATETIME_INTERVAL,
OperandTypes.DATETIME_INTERVAL_TIME),
SqlFunctionCategory.SYSTEM) {
@Override public List getAuxiliaryFunctions() {
return ImmutableList.of(TUMBLE_START, TUMBLE_END);
}
};
/** The {@code TUMBLE_START} auxiliary function of
* the {@code TUMBLE} group function. */
public static final SqlGroupedWindowFunction TUMBLE_START =
TUMBLE_OLD.auxiliary(SqlKind.TUMBLE_START);
/** The {@code TUMBLE_END} auxiliary function of
* the {@code TUMBLE} group function. */
public static final SqlGroupedWindowFunction TUMBLE_END =
TUMBLE_OLD.auxiliary(SqlKind.TUMBLE_END);
/** The {@code HOP} group function. */
public static final SqlGroupedWindowFunction HOP_OLD =
new SqlGroupedWindowFunction("$HOP", SqlKind.HOP, null,
ReturnTypes.ARG0, null,
OperandTypes.or(OperandTypes.DATETIME_INTERVAL_INTERVAL,
OperandTypes.DATETIME_INTERVAL_INTERVAL_TIME),
SqlFunctionCategory.SYSTEM) {
@Override public List getAuxiliaryFunctions() {
return ImmutableList.of(HOP_START, HOP_END);
}
};
/** The {@code HOP_START} auxiliary function of
* the {@code HOP} group function. */
public static final SqlGroupedWindowFunction HOP_START =
HOP_OLD.auxiliary(SqlKind.HOP_START);
/** The {@code HOP_END} auxiliary function of
* the {@code HOP} group function. */
public static final SqlGroupedWindowFunction HOP_END =
HOP_OLD.auxiliary(SqlKind.HOP_END);
/** The {@code SESSION} group function. */
public static final SqlGroupedWindowFunction SESSION_OLD =
new SqlGroupedWindowFunction("$SESSION", SqlKind.SESSION,
null, ReturnTypes.ARG0, null,
OperandTypes.or(OperandTypes.DATETIME_INTERVAL,
OperandTypes.DATETIME_INTERVAL_TIME),
SqlFunctionCategory.SYSTEM) {
@Override public List getAuxiliaryFunctions() {
return ImmutableList.of(SESSION_START, SESSION_END);
}
};
/** The {@code SESSION_START} auxiliary function of
* the {@code SESSION} group function. */
public static final SqlGroupedWindowFunction SESSION_START =
SESSION_OLD.auxiliary(SqlKind.SESSION_START);
/** The {@code SESSION_END} auxiliary function of
* the {@code SESSION} group function. */
public static final SqlGroupedWindowFunction SESSION_END =
SESSION_OLD.auxiliary(SqlKind.SESSION_END);
/** {@code |} operator to create alternate patterns
* within {@code MATCH_RECOGNIZE}.
*
* If {@code p1} and {@code p2} are patterns then {@code p1 | p2} is a
* pattern that matches {@code p1} or {@code p2}. */
public static final SqlBinaryOperator PATTERN_ALTER =
new SqlBinaryOperator("|", SqlKind.PATTERN_ALTER, 70, true, null, null, null);
/** Operator to concatenate patterns within {@code MATCH_RECOGNIZE}.
*
*
If {@code p1} and {@code p2} are patterns then {@code p1 p2} is a
* pattern that matches {@code p1} followed by {@code p2}. */
public static final SqlBinaryOperator PATTERN_CONCAT =
new SqlBinaryOperator("", SqlKind.PATTERN_CONCAT, 80, true, null, null, null);
/** Operator to quantify patterns within {@code MATCH_RECOGNIZE}.
*
*
If {@code p} is a pattern then {@code p{3, 5}} is a
* pattern that matches between 3 and 5 occurrences of {@code p}. */
public static final SqlSpecialOperator PATTERN_QUANTIFIER =
new SqlSpecialOperator("PATTERN_QUANTIFIER", SqlKind.PATTERN_QUANTIFIER,
90) {
@Override public void unparse(SqlWriter writer, SqlCall call,
int leftPrec, int rightPrec) {
call.operand(0).unparse(writer, this.getLeftPrec(), this.getRightPrec());
int startNum = ((SqlNumericLiteral) call.operand(1)).intValue(true);
SqlNumericLiteral endRepNum = call.operand(2);
boolean isReluctant = ((SqlLiteral) call.operand(3)).booleanValue();
int endNum = endRepNum.intValue(true);
if (startNum == endNum) {
writer.keyword("{ " + startNum + " }");
} else {
if (endNum == -1) {
if (startNum == 0) {
writer.keyword("*");
} else if (startNum == 1) {
writer.keyword("+");
} else {
writer.keyword("{ " + startNum + ", }");
}
} else {
if (startNum == 0 && endNum == 1) {
writer.keyword("?");
} else if (startNum == -1) {
writer.keyword("{ , " + endNum + " }");
} else {
writer.keyword("{ " + startNum + ", " + endNum + " }");
}
}
if (isReluctant) {
writer.keyword("?");
}
}
}
};
/** {@code PERMUTE} operator to combine patterns within
* {@code MATCH_RECOGNIZE}.
*
*
If {@code p1} and {@code p2} are patterns then {@code PERMUTE (p1, p2)}
* is a pattern that matches all permutations of {@code p1} and
* {@code p2}. */
public static final SqlSpecialOperator PATTERN_PERMUTE =
new SqlSpecialOperator("PATTERN_PERMUTE", SqlKind.PATTERN_PERMUTE, 100) {
@Override public void unparse(SqlWriter writer, SqlCall call,
int leftPrec, int rightPrec) {
writer.keyword("PERMUTE");
SqlWriter.Frame frame = writer.startList("(", ")");
for (int i = 0; i < call.getOperandList().size(); i++) {
SqlNode pattern = call.getOperandList().get(i);
pattern.unparse(writer, 0, 0);
if (i != call.getOperandList().size() - 1) {
writer.print(",");
}
}
writer.endList(frame);
}
};
/** {@code EXCLUDE} operator within {@code MATCH_RECOGNIZE}.
*
*
If {@code p} is a pattern then {@code {- p -} }} is a
* pattern that excludes {@code p} from the output. */
public static final SqlSpecialOperator PATTERN_EXCLUDE =
new SqlSpecialOperator("PATTERN_EXCLUDE", SqlKind.PATTERN_EXCLUDED,
100) {
@Override public void unparse(SqlWriter writer, SqlCall call,
int leftPrec, int rightPrec) {
SqlWriter.Frame frame = writer.startList("{-", "-}");
SqlNode node = call.getOperandList().get(0);
node.unparse(writer, 0, 0);
writer.endList(frame);
}
};
//~ Methods ----------------------------------------------------------------
/**
* Returns the standard operator table, creating it if necessary.
*/
public static synchronized SqlStdOperatorTable instance() {
if (instance == null) {
// Creates and initializes the standard operator table.
// Uses two-phase construction, because we can't initialize the
// table until the constructor of the sub-class has completed.
instance = new SqlStdOperatorTable();
instance.init();
}
return instance;
}
/** Returns the group function for which a given kind is an auxiliary
* function, or null if it is not an auxiliary function. */
public static SqlGroupedWindowFunction auxiliaryToGroup(SqlKind kind) {
switch (kind) {
case TUMBLE_START:
case TUMBLE_END:
return TUMBLE_OLD;
case HOP_START:
case HOP_END:
return HOP_OLD;
case SESSION_START:
case SESSION_END:
return SESSION_OLD;
default:
return null;
}
}
/** Converts a call to a grouped auxiliary function
* to a call to the grouped window function. For other calls returns null.
*
*
For example, converts {@code TUMBLE_START(rowtime, INTERVAL '1' HOUR))}
* to {@code TUMBLE(rowtime, INTERVAL '1' HOUR))}. */
public static SqlCall convertAuxiliaryToGroupCall(SqlCall call) {
final SqlOperator op = call.getOperator();
if (op instanceof SqlGroupedWindowFunction
&& op.isGroupAuxiliary()) {
return copy(call, ((SqlGroupedWindowFunction) op).groupFunction);
}
return null;
}
/** Converts a call to a grouped window function to a call to its auxiliary
* window function(s). For other calls returns null.
*
*
For example, converts {@code TUMBLE_START(rowtime, INTERVAL '1' HOUR))}
* to {@code TUMBLE(rowtime, INTERVAL '1' HOUR))}. */
public static List> convertGroupToAuxiliaryCalls(
SqlCall call) {
final SqlOperator op = call.getOperator();
if (op instanceof SqlGroupedWindowFunction
&& op.isGroup()) {
ImmutableList.Builder> builder =
ImmutableList.builder();
for (final SqlGroupedWindowFunction f
: ((SqlGroupedWindowFunction) op).getAuxiliaryFunctions()) {
builder.add(
Pair.of(copy(call, f),
new AuxiliaryConverter.Impl(f)));
}
return builder.build();
}
return ImmutableList.of();
}
/** Creates a copy of a call with a new operator. */
private static SqlCall copy(SqlCall call, SqlOperator operator) {
final List list = call.getOperandList();
return new SqlBasicCall(operator, list.toArray(new SqlNode[0]),
call.getParserPosition());
}
/** Returns the operator for {@code SOME comparisonKind}. */
public static SqlQuantifyOperator some(SqlKind comparisonKind) {
switch (comparisonKind) {
case EQUALS:
return SOME_EQ;
case NOT_EQUALS:
return SOME_NE;
case LESS_THAN:
return SOME_LT;
case LESS_THAN_OR_EQUAL:
return SOME_LE;
case GREATER_THAN:
return SOME_GT;
case GREATER_THAN_OR_EQUAL:
return SOME_GE;
default:
throw new AssertionError(comparisonKind);
}
}
/** Returns the operator for {@code ALL comparisonKind}. */
public static SqlQuantifyOperator all(SqlKind comparisonKind) {
switch (comparisonKind) {
case EQUALS:
return ALL_EQ;
case NOT_EQUALS:
return ALL_NE;
case LESS_THAN:
return ALL_LT;
case LESS_THAN_OR_EQUAL:
return ALL_LE;
case GREATER_THAN:
return ALL_GT;
case GREATER_THAN_OR_EQUAL:
return ALL_GE;
default:
throw new AssertionError(comparisonKind);
}
}
}