java.lang.Object
- org.apache.calcite.sql.util.ReflectiveSqlOperatorTable
- - org.apache.calcite.sql.fun.SqlStdOperatorTable

All Implemented Interfaces:

SqlOperatorTable
```
public class SqlStdOperatorTable
extends ReflectiveSqlOperatorTable
```
Implementation of SqlOperatorTable containing the standard operators and functions.

Field Summary

Fields
Modifier and Type	Field	Description
`static SqlFunction`	`ABS`
`static SqlFunction`	`ACOS`
`static SqlQuantifyOperator`	`ALL_EQ`
`static SqlQuantifyOperator`	`ALL_GE`
`static SqlQuantifyOperator`	`ALL_GT`
`static SqlQuantifyOperator`	`ALL_LE`
`static SqlQuantifyOperator`	`ALL_LT`	The `< ALL` operator.
`static SqlQuantifyOperator`	`ALL_NE`
`static SqlBinaryOperator`	`AND`	Logical `AND` operator.
`static SqlAggFunction`	`ANY_VALUE`	`ANY_VALUE` aggregate function.
`static SqlAggFunction`	`APPROX_COUNT_DISTINCT`	`APPROX_COUNT_DISTINCT` aggregate function.
`static SqlSpecialOperator`	`ARGUMENT_ASSIGNMENT`	`ARGUMENT_ASSIGNMENT` operator (`=<`) assigns an argument to a function call to a particular named parameter.
`static SqlMultisetQueryConstructor`	`ARRAY_QUERY`	The ARRAY Query Constructor.
`static SqlArrayValueConstructor`	`ARRAY_VALUE_CONSTRUCTOR`	The ARRAY Value Constructor.
`static SqlAsOperator`	`AS`	`AS` operator associates an expression in the SELECT clause with an alias.
`static SqlFunction`	`ASIN`
`static SqlFunction`	`ATAN`
`static SqlFunction`	`ATAN2`
`static SqlAggFunction`	`AVG`	`AVG` aggregate function.
`static SqlBetweenOperator`	`BETWEEN`
`static SqlFunction`	`CARDINALITY`	The CARDINALITY operator, used to retrieve the number of elements in a MULTISET, ARRAY or MAP.
`static SqlCaseOperator`	`CASE`
`static SqlFunction`	`CAST`	The SQL `CAST` operator.
`static SqlFunction`	`CEIL`	The `CEIL` function.
`static SqlFunction`	`CHAR_LENGTH`
`static SqlFunction`	`CHARACTER_LENGTH`
`static SqlFunction`	`CLASSIFIER`	`CLASSIFIER` function to be used within `MATCH_RECOGNIZE`.
`static SqlFunction`	`COALESCE`	The COALESCE builtin function.
`static SqlAggFunction`	`COLLECT`	The COLLECT operator.
`static SqlSpecialOperator`	`COLLECTION_TABLE`	The "table function derived table" operator, which a table-valued function into a relation, e.g.
`static SqlColumnListConstructor`	`COLUMN_LIST`	The COLUMN_LIST constructor.
`static SqlBinaryOperator`	`CONCAT`	String concatenation operator, '`\|\|`'.
`static SqlOverlapsOperator`	`CONTAINS`
`static SqlFunction`	`CONVERT`
`static SqlFunction`	`COS`
`static SqlFunction`	`COT`
`static SqlAggFunction`	`COUNT`	`COUNT` aggregate function.
`static SqlAggFunction`	`COVAR_POP`	`COVAR_POP` aggregate function.
`static SqlAggFunction`	`COVAR_SAMP`	`COVAR_SAMP` aggregate function.
`static SqlInternalOperator`	`CUBE`	`CUBE` operator, occurs within `GROUP BY` clause or nested within a `GROUPING SETS`.
`static SqlRankFunction`	`CUME_DIST`	`CUME_DIST` window function.
`static SqlFunction`	`CURRENT_CATALOG`	The `CURRENT_CATALOG` function.
`static SqlFunction`	`CURRENT_DATE`	The `CURRENT_DATE` function.
`static SqlFunction`	`CURRENT_PATH`	The `CURRENT_PATH` function.
`static SqlFunction`	`CURRENT_ROLE`	The `CURRENT_ROLE` function.
`static SqlFunction`	`CURRENT_SCHEMA`	The `CURRENT_SCHEMA` function.
`static SqlFunction`	`CURRENT_TIME`	The `CURRENT_TIME [(precision)]` function.
`static SqlFunction`	`CURRENT_TIMESTAMP`	The `CURRENT_TIMESTAMP [(precision)]` function.
`static SqlFunction`	`CURRENT_USER`	The `CURRENT_USER` function.
`static SqlOperator`	`CURRENT_VALUE`	The sequence current value function: `CURRENT VALUE FOR sequence`
`static SqlCursorConstructor`	`CURSOR`	The CURSOR constructor.
`static SqlSpecialOperator`	`DATETIME_PLUS`	Infix datetime plus operator, '`DATETIME + INTERVAL`'.
`static SqlDatePartFunction`	`DAYOFMONTH`	The SQL `DAYOFMONTH` operator.
`static SqlDatePartFunction`	`DAYOFWEEK`	The SQL `DAYOFWEEK` operator.
`static SqlDatePartFunction`	`DAYOFYEAR`	The SQL `DAYOFYEAR` operator.
`static SqlSpecialOperator`	`DEFAULT`	`DEFAULT` operator indicates that an argument to a function call is to take its default value..
`static SqlFunction`	`DEGREES`
`static SqlRankFunction`	`DENSE_RANK`	`DENSE_RANK` window function.
`static SqlPostfixOperator`	`DESC`
`static SqlBinaryOperator`	`DIVIDE`	Arithmetic division operator, '`/`'.
`static SqlBinaryOperator`	`DIVIDE_INTEGER`	Internal integer arithmetic division operator, '`/INT`'.
`static SqlOperator`	`DOT`	Dot operator, '`.`', used for referencing fields of records.
`static SqlFunction`	`ELEMENT`	The ELEMENT operator, used to convert a multiset with only one item to a "regular" type.
`static SqlInternalOperator`	`ELEMENT_SLICE`	The internal "$ELEMENT_SLICE" operator returns the first field of the only element of a multiset.
`static SqlBinaryOperator`	`EQUALS`	Logical equals operator, '`=`'.
`static SqlSpecialOperator`	`ESCAPE`	Internal operator used to represent the ESCAPE clause of a LIKE or SIMILAR TO expression.
`static SqlSetOperator`	`EXCEPT`
`static SqlSetOperator`	`EXCEPT_ALL`
`static SqlPrefixOperator`	`EXISTS`
`static SqlFunction`	`EXP`
`static SqlPrefixOperator`	`EXPLICIT_TABLE`	Keyword which allows an identifier to be explicitly flagged as a table.
`static SqlInternalOperator`	`EXTEND`	`EXTEND` operator.
`static SqlFunction`	`EXTRACT`	The SQL `EXTRACT` operator.
`static SqlFilterOperator`	`FILTER`	`FILTER` operator filters which rows are included in an aggregate function.
`static SqlPrefixOperator`	`FINAL`	`FINAL` function to be used within `MATCH_RECOGNIZE`.
`static SqlFunction`	`FIRST`	`FIRST` function to be used within `MATCH_RECOGNIZE`.
`static SqlAggFunction`	`FIRST_VALUE`	`FIRST_VALUE` aggregate function.
`static SqlFunction`	`FLOOR`	The `FLOOR` function.
`static SqlAggFunction`	`FUSION`	The FUSION operator.
`static SqlBinaryOperator`	`GREATER_THAN`	Logical greater-than operator, '`>`'.
`static SqlBinaryOperator`	`GREATER_THAN_OR_EQUAL`	Logical greater-than-or-equal operator, '`>=`'.
`static SqlGroupIdFunction`	`GROUP_ID`	`GROUP_ID()` function.
`static SqlGroupingFunction`	`GROUPING`	`GROUPING(c1 [, c2, ...])` function.
`static SqlGroupingFunction`	`GROUPING_ID`	`GROUPING_ID` function is a synonym for `GROUPING`.
`static SqlInternalOperator`	`GROUPING_SETS`	`GROUPING SETS` operator, occurs within `GROUP BY` clause or nested within a `GROUPING SETS`.
`static SqlAggFunction`	`HISTOGRAM_AGG`	`HISTOGRAM` aggregate function support.
`static SqlFunction`	`HISTOGRAM_FIRST_VALUE`	`HISTOGRAM_FIRST_VALUE` window aggregate function.
`static SqlFunction`	`HISTOGRAM_LAST_VALUE`	`HISTOGRAM_LAST_VALUE` window aggregate function.
`static SqlFunction`	`HISTOGRAM_MAX`	`HISTOGRAM_MAX` window aggregate function.
`static SqlFunction`	`HISTOGRAM_MIN`	`HISTOGRAM_MIN` window aggregate function.
`static SqlGroupedWindowFunction`	`HOP`	The `HOP` group function.
`static SqlGroupedWindowFunction`	`HOP_END`	The `HOP_END` auxiliary function of the `HOP` group function.
`static SqlGroupedWindowFunction`	`HOP_START`	The `HOP_START` auxiliary function of the `HOP` group function.
`static SqlDatePartFunction`	`HOUR`	The SQL `HOUR` operator.
`static SqlOverlapsOperator`	`IMMEDIATELY_PRECEDES`
`static SqlOverlapsOperator`	`IMMEDIATELY_SUCCEEDS`
`static SqlBinaryOperator`	`IN`	`IN` operator tests for a value's membership in a sub-query or a list of values.
`static SqlFunction`	`IN_FENNEL`	Use of the `IN_FENNEL` operator forces the argument to be evaluated in Fennel.
`static SqlFunction`	`INITCAP`
`private static SqlStdOperatorTable`	`instance`	The standard operator table.
`static SqlSetOperator`	`INTERSECT`
`static SqlSetOperator`	`INTERSECT_ALL`
`static SqlPostfixOperator`	`IS_A_SET`
`static SqlBinaryOperator`	`IS_DIFFERENT_FROM`	The internal `$IS_DIFFERENT_FROM` operator is the same as the user-level `IS_DISTINCT_FROM` in all respects except that the test for equality on character datatypes treats trailing spaces as significant.
`static SqlBinaryOperator`	`IS_DISTINCT_FROM`	`IS DISTINCT FROM` operator.
`static SqlPostfixOperator`	`IS_EMPTY`
`static SqlPostfixOperator`	`IS_FALSE`
`static SqlPostfixOperator`	`IS_JSON_ARRAY`
`static SqlPostfixOperator`	`IS_JSON_OBJECT`
`static SqlPostfixOperator`	`IS_JSON_SCALAR`
`static SqlPostfixOperator`	`IS_JSON_VALUE`
`static SqlPostfixOperator`	`IS_NOT_A_SET`
`static SqlBinaryOperator`	`IS_NOT_DISTINCT_FROM`	`IS NOT DISTINCT FROM` operator.
`static SqlPostfixOperator`	`IS_NOT_EMPTY`
`static SqlPostfixOperator`	`IS_NOT_FALSE`
`static SqlPostfixOperator`	`IS_NOT_JSON_ARRAY`
`static SqlPostfixOperator`	`IS_NOT_JSON_OBJECT`
`static SqlPostfixOperator`	`IS_NOT_JSON_SCALAR`
`static SqlPostfixOperator`	`IS_NOT_JSON_VALUE`
`static SqlPostfixOperator`	`IS_NOT_NULL`
`static SqlPostfixOperator`	`IS_NOT_TRUE`
`static SqlPostfixOperator`	`IS_NOT_UNKNOWN`
`static SqlPostfixOperator`	`IS_NULL`
`static SqlPostfixOperator`	`IS_TRUE`
`static SqlPostfixOperator`	`IS_UNKNOWN`
`static SqlOperator`	`ITEM`	The item operator `[ ... ]`, used to access a given element of an array or map.
`static SqlJsonApiCommonSyntaxOperator`	`JSON_API_COMMON_SYNTAX`
`static SqlFunction`	`JSON_ARRAY`
`static SqlJsonArrayAggAggFunction`	`JSON_ARRAYAGG`
`static SqlFunction`	`JSON_EXISTS`
`static SqlFunction`	`JSON_OBJECT`
`static SqlJsonObjectAggAggFunction`	`JSON_OBJECTAGG`
`static SqlFunction`	`JSON_QUERY`
`static SqlJsonValueExpressionOperator`	`JSON_STRUCTURED_VALUE_EXPRESSION`
`static SqlFunction`	`JSON_VALUE`
`static SqlFunction`	`JSON_VALUE_ANY`
`static SqlJsonValueExpressionOperator`	`JSON_VALUE_EXPRESSION`
`static SqlAggFunction`	`LAG`	`LAG` aggregate function.
`static SqlFunction`	`LAST`	`LAST` function to be used within `MATCH_RECOGNIZE`.
`static SqlAggFunction`	`LAST_VALUE`	`LAST_VALUE` aggregate function.
`static SqlSpecialOperator`	`LATERAL`	The `LATERAL` operator.
`static SqlAggFunction`	`LEAD`	`LEAD` aggregate function.
`static SqlBinaryOperator`	`LESS_THAN`	Logical less-than operator, '`<`'.
`static SqlBinaryOperator`	`LESS_THAN_OR_EQUAL`	Logical less-than-or-equal operator, '`<=`'.
`static SqlSpecialOperator`	`LIKE`
`static SqlLiteralChainOperator`	`LITERAL_CHAIN`
`static SqlFunction`	`LN`
`static SqlFunction`	`LOCALTIME`	The `LOCALTIME [(precision)]` function.
`static SqlFunction`	`LOCALTIMESTAMP`	The `LOCALTIMESTAMP [(precision)]` function.
`static SqlFunction`	`LOG10`
`static SqlFunction`	`LOWER`
`static SqlMultisetQueryConstructor`	`MAP_QUERY`	The MAP Query Constructor.
`static SqlMapValueConstructor`	`MAP_VALUE_CONSTRUCTOR`	The MAP Value Constructor, e.g.
`static SqlFunction`	`MATCH_NUMBER`	`MATCH_NUMBER` function to be used within `MATCH_RECOGNIZE`.
`static SqlAggFunction`	`MAX`	`MAX` aggregate function.
`static SqlBinaryOperator`	`MEMBER_OF`	Multiset `MEMBER OF`, which returns whether a element belongs to a multiset.
`static SqlAggFunction`	`MIN`	`MIN` aggregate function.
`static SqlBinaryOperator`	`MINUS`	Infix arithmetic minus operator, '`-`'.
`static SqlDatetimeSubtractionOperator`	`MINUS_DATE`	A special operator for the subtraction of two DATETIMEs.
`static SqlDatePartFunction`	`MINUTE`	The SQL `MINUTE` operator.
`static SqlFunction`	`MOD`	Arithmetic remainder function `MOD`.
`static SqlDatePartFunction`	`MONTH`	The SQL `MONTH` operator.
`static SqlBinaryOperator`	`MULTIPLY`	Arithmetic multiplication operator, '`*`'.
`static SqlMultisetSetOperator`	`MULTISET_EXCEPT`	The `MULTISET EXCEPT [ALL]` operator.
`static SqlMultisetSetOperator`	`MULTISET_EXCEPT_DISTINCT`	The `MULTISET EXCEPT DISTINCT` operator.
`static SqlMultisetSetOperator`	`MULTISET_INTERSECT`	The `MULTISET INTERSECT [ALL]` operator.
`static SqlMultisetSetOperator`	`MULTISET_INTERSECT_DISTINCT`	The `MULTISET INTERSECT DISTINCT` operator.
`static SqlMultisetQueryConstructor`	`MULTISET_QUERY`	The MULTISET Query Constructor.
`static SqlMultisetSetOperator`	`MULTISET_UNION`	The `MULTISET UNION [ALL]` operator.
`static SqlMultisetSetOperator`	`MULTISET_UNION_DISTINCT`	The `MULTISET UNION DISTINCT` operator.
`static SqlMultisetValueConstructor`	`MULTISET_VALUE`	The MULTISET Value Constructor.
`static SqlOperator`	`NEW`
`static SqlFunction`	`NEXT`	`NEXT` function to be used within `MATCH_RECOGNIZE`.
`static SqlOperator`	`NEXT_VALUE`	The sequence next value function: `NEXT VALUE FOR sequence`
`static SqlPrefixOperator`	`NOT`
`static SqlBetweenOperator`	`NOT_BETWEEN`
`static SqlBinaryOperator`	`NOT_EQUALS`	Logical not-equals operator, '`<>`'.
`static SqlBinaryOperator`	`NOT_IN`	`NOT IN` operator tests for a value's membership in a sub-query or a list of values.
`static SqlSpecialOperator`	`NOT_LIKE`
`static SqlSpecialOperator`	`NOT_SIMILAR_TO`
`static SqlBinaryOperator`	`NOT_SUBMULTISET_OF`
`static SqlAggFunction`	`NTH_VALUE`	`NTH_VALUE` aggregate function.
`static SqlAggFunction`	`NTILE`	`NTILE` aggregate function.
`static SqlFunction`	`NULLIF`
`static SqlPostfixOperator`	`NULLS_FIRST`
`static SqlPostfixOperator`	`NULLS_LAST`
`static SqlBinaryOperator`	`OR`	Logical `OR` operator.
`static SqlBinaryOperator`	`OVER`	The `OVER` operator, which applies an aggregate functions to a `window`.
`static SqlOverlapsOperator`	`OVERLAPS`
`static SqlFunction`	`OVERLAY`
`static SqlBinaryOperator`	`PATTERN_ALTER`	`\|` operator to create alternate patterns within `MATCH_RECOGNIZE`.
`static SqlBinaryOperator`	`PATTERN_CONCAT`	Operator to concatenate patterns within `MATCH_RECOGNIZE`.
`static SqlSpecialOperator`	`PATTERN_EXCLUDE`	`EXCLUDE` operator within `MATCH_RECOGNIZE`.
`static SqlSpecialOperator`	`PATTERN_PERMUTE`	`PERMUTE` operator to combine patterns within `MATCH_RECOGNIZE`.
`static SqlSpecialOperator`	`PATTERN_QUANTIFIER`	Operator to quantify patterns within `MATCH_RECOGNIZE`.
`static SqlRankFunction`	`PERCENT_RANK`	`PERCENT_RANK` window function.
`static SqlBinaryOperator`	`PERCENT_REMAINDER`	Arithmetic remainder operator, '`%`', an alternative to `MOD` allowed if under certain conformance levels.
`static SqlOverlapsOperator`	`PERIOD_EQUALS`
`static SqlFunction`	`PI`
`static SqlBinaryOperator`	`PLUS`	Infix arithmetic plus operator, '`+`'.
`static SqlFunction`	`POSITION`
`static SqlFunction`	`POWER`	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.
`static SqlOverlapsOperator`	`PRECEDES`
`static SqlFunction`	`PREV`	`PREV` function to be used within `MATCH_RECOGNIZE`.
`static SqlOperator`	`PROCEDURE_CALL`
`static SqlDatePartFunction`	`QUARTER`	The SQL `QUARTER` operator.
`static SqlFunction`	`RADIANS`
`static SqlRandFunction`	`RAND`	The `RAND([seed])` function, which yields a random double, optionally with seed.
`static SqlRandIntegerFunction`	`RAND_INTEGER`	The `RAND_INTEGER([seed, ] bound)` function, which yields a random integer, optionally with seed.
`static SqlRankFunction`	`RANK`	`RANK` window function.
`static SqlAggFunction`	`REGR_COUNT`	`REGR_COUNT` aggregate function.
`static SqlAggFunction`	`REGR_SXX`	`REGR_SXX` aggregate function.
`static SqlAggFunction`	`REGR_SYY`	`REGR_SYY` aggregate function.
`static SqlSpecialOperator`	`REINTERPRET`	An `REINTERPRET` operator is internal to the planner.
`static SqlFunction`	`REPLACE`	The `REPLACE(string, search, replace)` function.
`static SqlInternalOperator`	`ROLLUP`	`ROLLUP` operator, occurs within `GROUP BY` clause or nested within a `GROUPING SETS`.
`static SqlFunction`	`ROUND`
`static SqlRowOperator`	`ROW`
`static SqlRankFunction`	`ROW_NUMBER`	`ROW_NUMBER` window function.
`static SqlPrefixOperator`	`RUNNING`	`RUNNING` function to be used within `MATCH_RECOGNIZE`.
`static SqlInternalOperator`	`SCALAR_QUERY`	The internal "$SCALAR_QUERY" operator returns a scalar value from a record type.
`static SqlDatePartFunction`	`SECOND`	The SQL `SECOND` operator.
`static SqlGroupedWindowFunction`	`SESSION`	The `SESSION` group function.
`static SqlGroupedWindowFunction`	`SESSION_END`	The `SESSION_END` auxiliary function of the `SESSION` group function.
`static SqlGroupedWindowFunction`	`SESSION_START`	The `SESSION_START` auxiliary function of the `SESSION` group function.
`static SqlFunction`	`SESSION_USER`	The `SESSION_USER` function.
`static SqlFunction`	`SIGN`
`static SqlSpecialOperator`	`SIMILAR_TO`
`static SqlFunction`	`SIN`
`static SqlAggFunction`	`SINGLE_VALUE`	`SINGLE_VALUE` aggregate function.
`static SqlInternalOperator`	`SLICE`	The internal "$SLICE" operator takes a multiset of records and returns a multiset of the first column of those records.
`static SqlQuantifyOperator`	`SOME_EQ`
`static SqlQuantifyOperator`	`SOME_GE`
`static SqlQuantifyOperator`	`SOME_GT`
`static SqlQuantifyOperator`	`SOME_LE`
`static SqlQuantifyOperator`	`SOME_LT`	The `< SOME` operator (synonymous with `< ANY`).
`static SqlQuantifyOperator`	`SOME_NE`
`static SqlFunction`	`SQRT`
`static SqlAggFunction`	`STDDEV`	`STDDEV` aggregate function.
`static SqlAggFunction`	`STDDEV_POP`	`STDDEV_POP` aggregate function.
`static SqlAggFunction`	`STDDEV_SAMP`	`STDDEV_SAMP` aggregate function.
`static SqlInternalOperator`	`STRUCT_ACCESS`	The internal `$STRUCT_ACCESS` operator is used to access a field of a record.
`static SqlBinaryOperator`	`SUBMULTISET_OF`	Submultiset.
`static SqlFunction`	`SUBSTRING`	The character substring function: `SUBSTRING(string FROM start [FOR length])`.
`static SqlOverlapsOperator`	`SUCCEEDS`
`static SqlAggFunction`	`SUM`	`SUM` aggregate function.
`static SqlAggFunction`	`SUM0`	`SUM0` aggregate function.
`static SqlBetweenOperator`	`SYMMETRIC_BETWEEN`
`static SqlBetweenOperator`	`SYMMETRIC_NOT_BETWEEN`
`static SqlFunction`	`SYSTEM_USER`	The `SYSTEM_USER` function.
`static SqlSpecialOperator`	`TABLESAMPLE`	The `TABLESAMPLE` operator.
`static SqlFunction`	`TAN`
`static SqlThrowOperator`	`THROW`
`static SqlFunction`	`TIMESTAMP_ADD`	The `TIMESTAMPADD` function.
`static SqlFunction`	`TIMESTAMP_DIFF`	The `TIMESTAMPDIFF` function.
`static SqlFunction`	`TRANSLATE`	The `TRANSLATE(char_value USING translation_name)` function alters the character set of a string value from one base character set to another.
`static SqlFunction`	`TRIM`	The "TRIM" function.
`static SqlFunction`	`TRUNCATE`
`static SqlGroupedWindowFunction`	`TUMBLE`	The `TUMBLE` group function.
`static SqlGroupedWindowFunction`	`TUMBLE_END`	The `TUMBLE_END` auxiliary function of the `TUMBLE` group function.
`static SqlGroupedWindowFunction`	`TUMBLE_START`	The `TUMBLE_START` auxiliary function of the `TUMBLE` group function.
`static SqlPrefixOperator`	`UNARY_MINUS`	Prefix arithmetic minus operator, '`-`'.
`static SqlPrefixOperator`	`UNARY_PLUS`	Prefix arithmetic plus operator, '`+`'.
`static SqlSetOperator`	`UNION`
`static SqlSetOperator`	`UNION_ALL`
`static SqlUnnestOperator`	`UNNEST`	The `UNNEST` operator.
`static SqlUnnestOperator`	`UNNEST_WITH_ORDINALITY`	The `UNNEST WITH ORDINALITY` operator.
`static SqlFunction`	`UPPER`
`static SqlFunction`	`USER`	The `USER` function.
`static SqlSpecialOperator`	`VALUES`
`static SqlAggFunction`	`VAR_POP`	`VAR_POP` aggregate function.
`static SqlAggFunction`	`VAR_SAMP`	`VAR_SAMP` aggregate function.
`static SqlAggFunction`	`VARIANCE`	`VARIANCE` aggregate function.
`static SqlDatePartFunction`	`WEEK`	The SQL `WEEK` operator.
`static SqlWithinGroupOperator`	`WITHIN_GROUP`	`WITHIN_GROUP` operator performs aggregations on ordered data input.
`static SqlDatePartFunction`	`YEAR`	The SQL `YEAR` operator.

Fields inherited from class org.apache.calcite.sql.util.ReflectiveSqlOperatorTable
IS_NAME

Constructor Summary

Constructors
Constructor Description

SqlStdOperatorTable()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static SqlQuantifyOperator`	`all(SqlKind comparisonKind)`	Returns the operator for `ALL comparisonKind`.
`static SqlGroupedWindowFunction`	`auxiliaryToGroup(SqlKind kind)`	Returns the group function for which a given kind is an auxiliary function, or null if it is not an auxiliary function.
`static SqlCall`	`convertAuxiliaryToGroupCall(SqlCall call)`	Converts a call to a grouped auxiliary function to a call to the grouped window function.
`static java.util.List<Pair<SqlNode,AuxiliaryConverter>>`	`convertGroupToAuxiliaryCalls(SqlCall call)`	Converts a call to a grouped window function to a call to its auxiliary window function(s).
`private static SqlCall`	`copy(SqlCall call, SqlOperator operator)`	Creates a copy of a call with a new operator.
`static SqlStdOperatorTable`	`instance()`	Returns the standard operator table, creating it if necessary.
`static SqlQuantifyOperator`	`some(SqlKind comparisonKind)`	Returns the operator for `SOME comparisonKind`.

Methods inherited from class org.apache.calcite.sql.util.ReflectiveSqlOperatorTable
getOperatorList, init, lookupOperatorOverloads, register

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - instance
```
private static SqlStdOperatorTable instance
```
    The standard operator table.
  - UNION
```
public static final SqlSetOperator UNION
```
  - UNION_ALL
```
public static final SqlSetOperator UNION_ALL
```
  - EXCEPT
```
public static final SqlSetOperator EXCEPT
```
  - EXCEPT_ALL
```
public static final SqlSetOperator EXCEPT_ALL
```
  - INTERSECT
```
public static final SqlSetOperator INTERSECT
```
  - INTERSECT_ALL
```
public static final SqlSetOperator INTERSECT_ALL
```
  - MULTISET_UNION_DISTINCT
```
public static final SqlMultisetSetOperator MULTISET_UNION_DISTINCT
```
    The MULTISET UNION DISTINCT operator.
  - MULTISET_UNION
```
public static final SqlMultisetSetOperator MULTISET_UNION
```
    The MULTISET UNION [ALL] operator.
  - MULTISET_EXCEPT_DISTINCT
```
public static final SqlMultisetSetOperator MULTISET_EXCEPT_DISTINCT
```
    The MULTISET EXCEPT DISTINCT operator.
  - MULTISET_EXCEPT
```
public static final SqlMultisetSetOperator MULTISET_EXCEPT
```
    The MULTISET EXCEPT [ALL] operator.
  - MULTISET_INTERSECT_DISTINCT
```
public static final SqlMultisetSetOperator MULTISET_INTERSECT_DISTINCT
```
    The MULTISET INTERSECT DISTINCT operator.
  - MULTISET_INTERSECT
```
public static final SqlMultisetSetOperator MULTISET_INTERSECT
```
    The MULTISET INTERSECT [ALL] operator.
  - AND
```
public static final SqlBinaryOperator AND
```
    Logical AND operator.
  - AS
```
public static final SqlAsOperator AS
```
    AS operator associates an expression in the SELECT clause with an alias.
  - ARGUMENT_ASSIGNMENT
```
public static final SqlSpecialOperator ARGUMENT_ASSIGNMENT
```
    ARGUMENT_ASSIGNMENT operator (=<) assigns an argument to a function call to a particular named parameter.
  - DEFAULT
```
public static final SqlSpecialOperator DEFAULT
```
    DEFAULT operator indicates that an argument to a function call is to take its default value..
  - FILTER
```
public static final SqlFilterOperator FILTER
```
    FILTER operator filters which rows are included in an aggregate function.
  - WITHIN_GROUP
```
public static final SqlWithinGroupOperator WITHIN_GROUP
```
    WITHIN_GROUP operator performs aggregations on ordered data input.
  - CUBE
```
public static final SqlInternalOperator CUBE
```
    CUBE operator, occurs within GROUP BY clause or nested within a GROUPING SETS.
  - ROLLUP
```
public static final SqlInternalOperator ROLLUP
```
    ROLLUP operator, occurs within GROUP BY clause or nested within a GROUPING SETS.
  - GROUPING_SETS
```
public static final SqlInternalOperator GROUPING_SETS
```
    GROUPING SETS operator, occurs within GROUP BY clause or nested within a GROUPING SETS.
  - GROUPING
```
public static final SqlGroupingFunction GROUPING
```
    GROUPING(c1 [, c2, ...]) function.
    Occurs in similar places to an aggregate function (SELECT, HAVING clause, etc. of an aggregate query), but not technically an aggregate function.
  - GROUP_ID
```
public static final SqlGroupIdFunction GROUP_ID
```
    GROUP_ID() function. (Oracle-specific.)
  - GROUPING_ID
```
public static final SqlGroupingFunction GROUPING_ID
```
    GROUPING_ID function is a synonym for GROUPING.
    Some history. The GROUPING function is in the SQL standard, and originally supported only one argument. 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 GROUPING to have multiple arguments. It is now equivalent to GROUPING_ID, so we made GROUPING_ID a synonym for GROUPING.
  - EXTEND
```
public static final SqlInternalOperator EXTEND
```
    EXTEND operator.
  - CONCAT
```
public static final SqlBinaryOperator CONCAT
```
    String concatenation operator, '||'.
  - DIVIDE
```
public static final SqlBinaryOperator DIVIDE
```
    Arithmetic division operator, '/'.
  - PERCENT_REMAINDER
```
public static final SqlBinaryOperator PERCENT_REMAINDER
```
    Arithmetic remainder operator, '%', an alternative to MOD allowed if under certain conformance levels.
    
    See Also:
    
    SqlConformance.isPercentRemainderAllowed()
  - RAND_INTEGER
```
public static final SqlRandIntegerFunction RAND_INTEGER
```
    The RAND_INTEGER([seed, ] bound) function, which yields a random integer, optionally with seed.
  - RAND
```
public static final SqlRandFunction RAND
```
    The RAND([seed]) function, which yields a random double, optionally with seed.
  - DIVIDE_INTEGER
```
public static final SqlBinaryOperator DIVIDE_INTEGER
```
    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.
  - DOT
```
public static final SqlOperator DOT
```
    Dot operator, '.', used for referencing fields of records.
  - EQUALS
```
public static final SqlBinaryOperator EQUALS
```
    Logical equals operator, '='.
  - GREATER_THAN
```
public static final SqlBinaryOperator GREATER_THAN
```
    Logical greater-than operator, '>'.
  - IS_DISTINCT_FROM
```
public static final SqlBinaryOperator IS_DISTINCT_FROM
```
    IS DISTINCT FROM operator.
  - IS_NOT_DISTINCT_FROM
```
public static final SqlBinaryOperator IS_NOT_DISTINCT_FROM
```
    IS NOT DISTINCT FROM operator. Is equivalent to NOT(x IS DISTINCT FROM y)
  - IS_DIFFERENT_FROM
```
public static final SqlBinaryOperator IS_DIFFERENT_FROM
```
    The internal $IS_DIFFERENT_FROM operator is the same as the user-level IS_DISTINCT_FROM in all respects except that the test for equality on character datatypes treats trailing spaces as significant.
  - GREATER_THAN_OR_EQUAL
```
public static final SqlBinaryOperator GREATER_THAN_OR_EQUAL
```
    Logical greater-than-or-equal operator, '>='.
  - IN
```
public static final SqlBinaryOperator IN
```
    IN operator tests for a value's membership in a sub-query or a list of values.
  - NOT_IN
```
public static final SqlBinaryOperator NOT_IN
```
    NOT IN operator tests for a value's membership in a sub-query or a list of values.
  - SOME_LT
```
public static final SqlQuantifyOperator SOME_LT
```
    The < SOME operator (synonymous with < ANY).
  - SOME_LE
```
public static final SqlQuantifyOperator SOME_LE
```
  - SOME_GT
```
public static final SqlQuantifyOperator SOME_GT
```
  - SOME_GE
```
public static final SqlQuantifyOperator SOME_GE
```
  - SOME_EQ
```
public static final SqlQuantifyOperator SOME_EQ
```
  - SOME_NE
```
public static final SqlQuantifyOperator SOME_NE
```
  - ALL_LT
```
public static final SqlQuantifyOperator ALL_LT
```
    The < ALL operator.
  - ALL_LE
```
public static final SqlQuantifyOperator ALL_LE
```
  - ALL_GT
```
public static final SqlQuantifyOperator ALL_GT
```
  - ALL_GE
```
public static final SqlQuantifyOperator ALL_GE
```
  - ALL_EQ
```
public static final SqlQuantifyOperator ALL_EQ
```
  - ALL_NE
```
public static final SqlQuantifyOperator ALL_NE
```
  - LESS_THAN
```
public static final SqlBinaryOperator LESS_THAN
```
    Logical less-than operator, '<'.
  - LESS_THAN_OR_EQUAL
```
public static final SqlBinaryOperator LESS_THAN_OR_EQUAL
```
    Logical less-than-or-equal operator, '<='.
  - MINUS
```
public static final SqlBinaryOperator MINUS
```
    Infix arithmetic minus operator, '-'.
    Its precedence is less than the prefix + and - operators.
  - MULTIPLY
```
public static final SqlBinaryOperator MULTIPLY
```
    Arithmetic multiplication operator, '*'.
  - NOT_EQUALS
```
public static final SqlBinaryOperator NOT_EQUALS
```
    Logical not-equals operator, '<>'.
  - OR
```
public static final SqlBinaryOperator OR
```
    Logical OR operator.
  - PLUS
```
public static final SqlBinaryOperator PLUS
```
    Infix arithmetic plus operator, '+'.
  - DATETIME_PLUS
```
public static final SqlSpecialOperator DATETIME_PLUS
```
    Infix datetime plus operator, 'DATETIME + INTERVAL'.
  - MEMBER_OF
```
public static final SqlBinaryOperator MEMBER_OF
```
    Multiset 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']
  - SUBMULTISET_OF
```
public static final SqlBinaryOperator SUBMULTISET_OF
```
    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']
  - NOT_SUBMULTISET_OF
```
public static final SqlBinaryOperator NOT_SUBMULTISET_OF
```
  - DESC
```
public static final SqlPostfixOperator DESC
```
  - NULLS_FIRST
```
public static final SqlPostfixOperator NULLS_FIRST
```
  - NULLS_LAST
```
public static final SqlPostfixOperator NULLS_LAST
```
  - IS_NOT_NULL
```
public static final SqlPostfixOperator IS_NOT_NULL
```
  - IS_NULL
```
public static final SqlPostfixOperator IS_NULL
```
  - IS_NOT_TRUE
```
public static final SqlPostfixOperator IS_NOT_TRUE
```
  - IS_TRUE
```
public static final SqlPostfixOperator IS_TRUE
```
  - IS_NOT_FALSE
```
public static final SqlPostfixOperator IS_NOT_FALSE
```
  - IS_FALSE
```
public static final SqlPostfixOperator IS_FALSE
```
  - IS_NOT_UNKNOWN
```
public static final SqlPostfixOperator IS_NOT_UNKNOWN
```
  - IS_UNKNOWN
```
public static final SqlPostfixOperator IS_UNKNOWN
```
  - IS_A_SET
```
public static final SqlPostfixOperator IS_A_SET
```
  - IS_NOT_A_SET
```
public static final SqlPostfixOperator IS_NOT_A_SET
```
  - IS_EMPTY
```
public static final SqlPostfixOperator IS_EMPTY
```
  - IS_NOT_EMPTY
```
public static final SqlPostfixOperator IS_NOT_EMPTY
```
  - IS_JSON_VALUE
```
public static final SqlPostfixOperator IS_JSON_VALUE
```
  - IS_NOT_JSON_VALUE
```
public static final SqlPostfixOperator IS_NOT_JSON_VALUE
```
  - IS_JSON_OBJECT
```
public static final SqlPostfixOperator IS_JSON_OBJECT
```
  - IS_NOT_JSON_OBJECT
```
public static final SqlPostfixOperator IS_NOT_JSON_OBJECT
```
  - IS_JSON_ARRAY
```
public static final SqlPostfixOperator IS_JSON_ARRAY
```
  - IS_NOT_JSON_ARRAY
```
public static final SqlPostfixOperator IS_NOT_JSON_ARRAY
```
  - IS_JSON_SCALAR
```
public static final SqlPostfixOperator IS_JSON_SCALAR
```
  - IS_NOT_JSON_SCALAR
```
public static final SqlPostfixOperator IS_NOT_JSON_SCALAR
```
  - EXISTS
```
public static final SqlPrefixOperator EXISTS
```
  - NOT
```
public static final SqlPrefixOperator NOT
```
  - UNARY_MINUS
```
public static final SqlPrefixOperator UNARY_MINUS
```
    Prefix arithmetic minus operator, '-'.
    Its precedence is greater than the infix '+' and '-' operators.
  - UNARY_PLUS
```
public static final SqlPrefixOperator UNARY_PLUS
```
    Prefix arithmetic plus operator, '+'.
    Its precedence is greater than the infix '+' and '-' operators.
  - EXPLICIT_TABLE
```
public static final SqlPrefixOperator EXPLICIT_TABLE
```
    Keyword which allows an identifier to be explicitly flagged as a table. For example, select * from (TABLE t) or TABLE t. See also COLLECTION_TABLE.
  - FINAL
```
public static final SqlPrefixOperator FINAL
```
    FINAL function to be used within MATCH_RECOGNIZE.
  - RUNNING
```
public static final SqlPrefixOperator RUNNING
```
    RUNNING function to be used within MATCH_RECOGNIZE.
  - SUM
```
public static final SqlAggFunction SUM
```
    SUM aggregate function.
  - COUNT
```
public static final SqlAggFunction COUNT
```
    COUNT aggregate function.
  - APPROX_COUNT_DISTINCT
```
public static final SqlAggFunction APPROX_COUNT_DISTINCT
```
    APPROX_COUNT_DISTINCT aggregate function.
  - MIN
```
public static final SqlAggFunction MIN
```
    MIN aggregate function.
  - MAX
```
public static final SqlAggFunction MAX
```
    MAX aggregate function.
  - LAST_VALUE
```
public static final SqlAggFunction LAST_VALUE
```
    LAST_VALUE aggregate function.
  - ANY_VALUE
```
public static final SqlAggFunction ANY_VALUE
```
    ANY_VALUE aggregate function.
  - FIRST_VALUE
```
public static final SqlAggFunction FIRST_VALUE
```
    FIRST_VALUE aggregate function.
  - NTH_VALUE
```
public static final SqlAggFunction NTH_VALUE
```
    NTH_VALUE aggregate function.
  - LEAD
```
public static final SqlAggFunction LEAD
```
    LEAD aggregate function.
  - LAG
```
public static final SqlAggFunction LAG
```
    LAG aggregate function.
  - NTILE
```
public static final SqlAggFunction NTILE
```
    NTILE aggregate function.
  - SINGLE_VALUE
```
public static final SqlAggFunction SINGLE_VALUE
```
    SINGLE_VALUE aggregate function.
  - AVG
```
public static final SqlAggFunction AVG
```
    AVG aggregate function.
  - STDDEV_POP
```
public static final SqlAggFunction STDDEV_POP
```
    STDDEV_POP aggregate function.
  - REGR_COUNT
```
public static final SqlAggFunction REGR_COUNT
```
    REGR_COUNT aggregate function.
  - REGR_SXX
```
public static final SqlAggFunction REGR_SXX
```
    REGR_SXX aggregate function.
  - REGR_SYY
```
public static final SqlAggFunction REGR_SYY
```
    REGR_SYY aggregate function.
  - COVAR_POP
```
public static final SqlAggFunction COVAR_POP
```
    COVAR_POP aggregate function.
  - COVAR_SAMP
```
public static final SqlAggFunction COVAR_SAMP
```
    COVAR_SAMP aggregate function.
  - STDDEV_SAMP
```
public static final SqlAggFunction STDDEV_SAMP
```
    STDDEV_SAMP aggregate function.
  - STDDEV
```
public static final SqlAggFunction STDDEV
```
    STDDEV aggregate function.
  - VAR_POP
```
public static final SqlAggFunction VAR_POP
```
    VAR_POP aggregate function.
  - VAR_SAMP
```
public static final SqlAggFunction VAR_SAMP
```
    VAR_SAMP aggregate function.
  - VARIANCE
```
public static final SqlAggFunction VARIANCE
```
    VARIANCE aggregate function.
  - HISTOGRAM_AGG
```
public static final SqlAggFunction HISTOGRAM_AGG
```
    HISTOGRAM aggregate function support. Used by window aggregate versions of MIN/MAX
  - HISTOGRAM_MIN
```
public static final SqlFunction HISTOGRAM_MIN
```
    HISTOGRAM_MIN window aggregate function.
  - HISTOGRAM_MAX
```
public static final SqlFunction HISTOGRAM_MAX
```
    HISTOGRAM_MAX window aggregate function.
  - HISTOGRAM_FIRST_VALUE
```
public static final SqlFunction HISTOGRAM_FIRST_VALUE
```
    HISTOGRAM_FIRST_VALUE window aggregate function.
  - HISTOGRAM_LAST_VALUE
```
public static final SqlFunction HISTOGRAM_LAST_VALUE
```
    HISTOGRAM_LAST_VALUE window aggregate function.
  - SUM0
```
public static final SqlAggFunction SUM0
```
    SUM0 aggregate function.
  - CUME_DIST
```
public static final SqlRankFunction CUME_DIST
```
    CUME_DIST window function.
  - DENSE_RANK
```
public static final SqlRankFunction DENSE_RANK
```
    DENSE_RANK window function.
  - PERCENT_RANK
```
public static final SqlRankFunction PERCENT_RANK
```
    PERCENT_RANK window function.
  - RANK
```
public static final SqlRankFunction RANK
```
    RANK window function.
  - ROW_NUMBER
```
public static final SqlRankFunction ROW_NUMBER
```
    ROW_NUMBER window function.
  - ROW
```
public static final SqlRowOperator ROW
```
  - MINUS_DATE
```
public static final SqlDatetimeSubtractionOperator MINUS_DATE
```
    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.
  - MULTISET_VALUE
```
public static final SqlMultisetValueConstructor MULTISET_VALUE
```
    The MULTISET Value Constructor. e.g. "MULTISET[1,2,3]".
  - MULTISET_QUERY
```
public static final SqlMultisetQueryConstructor MULTISET_QUERY
```
    The MULTISET Query Constructor. e.g. "SELECT dname, MULTISET(SELECT FROM emp WHERE deptno = dept.deptno) FROM dept".
  - ARRAY_QUERY
```
public static final SqlMultisetQueryConstructor ARRAY_QUERY
```
    The ARRAY Query Constructor. e.g. "SELECT dname, ARRAY(SELECT FROM emp WHERE deptno = dept.deptno) FROM dept".
  - MAP_QUERY
```
public static final SqlMultisetQueryConstructor MAP_QUERY
```
    The MAP Query Constructor. e.g. "MAP(SELECT empno, deptno FROM emp)".
  - CURSOR
```
public static final SqlCursorConstructor CURSOR
```
    The CURSOR constructor. e.g. "SELECT * FROM TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), 'name'))".
  - COLUMN_LIST
```
public static final SqlColumnListConstructor COLUMN_LIST
```
    The COLUMN_LIST constructor. e.g. the ROW() call in "SELECT * FROM TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), ROW(name, empno)))".
  - UNNEST
```
public static final SqlUnnestOperator UNNEST
```
    The UNNEST operator.
  - UNNEST_WITH_ORDINALITY
```
public static final SqlUnnestOperator UNNEST_WITH_ORDINALITY
```
    The UNNEST WITH ORDINALITY operator.
  - LATERAL
```
public static final SqlSpecialOperator LATERAL
```
    The LATERAL operator.
  - COLLECTION_TABLE
```
public static final SqlSpecialOperator COLLECTION_TABLE
```
    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 EXPLICIT_TABLE is a prefix operator.
  - OVERLAPS
```
public static final SqlOverlapsOperator OVERLAPS
```
  - CONTAINS
```
public static final SqlOverlapsOperator CONTAINS
```
  - PRECEDES
```
public static final SqlOverlapsOperator PRECEDES
```
  - IMMEDIATELY_PRECEDES
```
public static final SqlOverlapsOperator IMMEDIATELY_PRECEDES
```
  - SUCCEEDS
```
public static final SqlOverlapsOperator SUCCEEDS
```
  - IMMEDIATELY_SUCCEEDS
```
public static final SqlOverlapsOperator IMMEDIATELY_SUCCEEDS
```
  - PERIOD_EQUALS
```
public static final SqlOverlapsOperator PERIOD_EQUALS
```
  - VALUES
```
public static final SqlSpecialOperator VALUES
```
  - LITERAL_CHAIN
```
public static final SqlLiteralChainOperator LITERAL_CHAIN
```
  - THROW
```
public static final SqlThrowOperator THROW
```
  - JSON_VALUE_EXPRESSION
```
public static final SqlJsonValueExpressionOperator JSON_VALUE_EXPRESSION
```
  - JSON_STRUCTURED_VALUE_EXPRESSION
```
public static final SqlJsonValueExpressionOperator JSON_STRUCTURED_VALUE_EXPRESSION
```
  - JSON_API_COMMON_SYNTAX
```
public static final SqlJsonApiCommonSyntaxOperator JSON_API_COMMON_SYNTAX
```
  - JSON_EXISTS
```
public static final SqlFunction JSON_EXISTS
```
  - JSON_VALUE
```
public static final SqlFunction JSON_VALUE
```
  - JSON_VALUE_ANY
```
public static final SqlFunction JSON_VALUE_ANY
```
  - JSON_QUERY
```
public static final SqlFunction JSON_QUERY
```
  - JSON_OBJECT
```
public static final SqlFunction JSON_OBJECT
```
  - JSON_OBJECTAGG
```
public static final SqlJsonObjectAggAggFunction JSON_OBJECTAGG
```
  - JSON_ARRAY
```
public static final SqlFunction JSON_ARRAY
```
  - JSON_ARRAYAGG
```
public static final SqlJsonArrayAggAggFunction JSON_ARRAYAGG
```
  - BETWEEN
```
public static final SqlBetweenOperator BETWEEN
```
  - SYMMETRIC_BETWEEN
```
public static final SqlBetweenOperator SYMMETRIC_BETWEEN
```
  - NOT_BETWEEN
```
public static final SqlBetweenOperator NOT_BETWEEN
```
  - SYMMETRIC_NOT_BETWEEN
```
public static final SqlBetweenOperator SYMMETRIC_NOT_BETWEEN
```
  - NOT_LIKE
```
public static final SqlSpecialOperator NOT_LIKE
```
  - LIKE
```
public static final SqlSpecialOperator LIKE
```
  - NOT_SIMILAR_TO
```
public static final SqlSpecialOperator NOT_SIMILAR_TO
```
  - SIMILAR_TO
```
public static final SqlSpecialOperator SIMILAR_TO
```
  - ESCAPE
```
public static final SqlSpecialOperator ESCAPE
```
    Internal operator used to represent the ESCAPE clause of a LIKE or SIMILAR TO expression.
  - CASE
```
public static final SqlCaseOperator CASE
```
  - PROCEDURE_CALL
```
public static final SqlOperator PROCEDURE_CALL
```
  - NEW
```
public static final SqlOperator NEW
```
  - OVER
```
public static final SqlBinaryOperator OVER
```
    The OVER operator, which applies an aggregate functions to a window.
    Operands are as follows:
    
    name of window function (SqlCall)
    
    window name (SqlLiteral) or window in-line specification (@link SqlWindowOperator})
  - REINTERPRET
```
public static final SqlSpecialOperator REINTERPRET
```
    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.
  - SUBSTRING
```
public static final SqlFunction SUBSTRING
```
    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.
  - REPLACE
```
public static final SqlFunction REPLACE
```
    The REPLACE(string, search, replace) function. Not standard SQL, but in Oracle and Postgres.
  - CONVERT
```
public static final SqlFunction CONVERT
```
  - TRANSLATE
```
public static final SqlFunction TRANSLATE
```
    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 non-standard OracleSqlOperatorTable.TRANSLATE3.
  - OVERLAY
```
public static final SqlFunction OVERLAY
```
  - TRIM
```
public static final SqlFunction TRIM
```
    The "TRIM" function.
  - POSITION
```
public static final SqlFunction POSITION
```
  - CHAR_LENGTH
```
public static final SqlFunction CHAR_LENGTH
```
  - CHARACTER_LENGTH
```
public static final SqlFunction CHARACTER_LENGTH
```
  - UPPER
```
public static final SqlFunction UPPER
```
  - LOWER
```
public static final SqlFunction LOWER
```
  - INITCAP
```
public static final SqlFunction INITCAP
```
  - POWER
```
public static final SqlFunction POWER
```
    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.
  - SQRT
```
public static final SqlFunction SQRT
```
  - MOD
```
public static final SqlFunction MOD
```
    Arithmetic remainder function MOD.
    
    See Also:
    
    PERCENT_REMAINDER
  - LN
```
public static final SqlFunction LN
```
  - LOG10
```
public static final SqlFunction LOG10
```
  - ABS
```
public static final SqlFunction ABS
```
  - ACOS
```
public static final SqlFunction ACOS
```
  - ASIN
```
public static final SqlFunction ASIN
```
  - ATAN
```
public static final SqlFunction ATAN
```
  - ATAN2
```
public static final SqlFunction ATAN2
```
  - COS
```
public static final SqlFunction COS
```
  - COT
```
public static final SqlFunction COT
```
  - DEGREES
```
public static final SqlFunction DEGREES
```
  - EXP
```
public static final SqlFunction EXP
```
  - RADIANS
```
public static final SqlFunction RADIANS
```
  - ROUND
```
public static final SqlFunction ROUND
```
  - SIGN
```
public static final SqlFunction SIGN
```
  - SIN
```
public static final SqlFunction SIN
```
  - TAN
```
public static final SqlFunction TAN
```
  - TRUNCATE
```
public static final SqlFunction TRUNCATE
```
  - PI
```
public static final SqlFunction PI
```
  - FIRST
```
public static final SqlFunction FIRST
```
    FIRST function to be used within MATCH_RECOGNIZE.
  - LAST
```
public static final SqlFunction LAST
```
    LAST function to be used within MATCH_RECOGNIZE.
  - PREV
```
public static final SqlFunction PREV
```
    PREV function to be used within MATCH_RECOGNIZE.
  - NEXT
```
public static final SqlFunction NEXT
```
    NEXT function to be used within MATCH_RECOGNIZE.
  - CLASSIFIER
```
public static final SqlFunction CLASSIFIER
```
    CLASSIFIER function to be used within MATCH_RECOGNIZE.
  - MATCH_NUMBER
```
public static final SqlFunction MATCH_NUMBER
```
    MATCH_NUMBER function to be used within MATCH_RECOGNIZE.
  - NULLIF
```
public static final SqlFunction NULLIF
```
  - COALESCE
```
public static final SqlFunction COALESCE
```
    The COALESCE builtin function.
  - FLOOR
```
public static final SqlFunction FLOOR
```
    The FLOOR function.
  - CEIL
```
public static final SqlFunction CEIL
```
    The CEIL function.
  - USER
```
public static final SqlFunction USER
```
    The USER function.
  - CURRENT_USER
```
public static final SqlFunction CURRENT_USER
```
    The CURRENT_USER function.
  - SESSION_USER
```
public static final SqlFunction SESSION_USER
```
    The SESSION_USER function.
  - SYSTEM_USER
```
public static final SqlFunction SYSTEM_USER
```
    The SYSTEM_USER function.
  - CURRENT_PATH
```
public static final SqlFunction CURRENT_PATH
```
    The CURRENT_PATH function.
  - CURRENT_ROLE
```
public static final SqlFunction CURRENT_ROLE
```
    The CURRENT_ROLE function.
  - CURRENT_CATALOG
```
public static final SqlFunction CURRENT_CATALOG
```
    The CURRENT_CATALOG function.
  - CURRENT_SCHEMA
```
public static final SqlFunction CURRENT_SCHEMA
```
    The CURRENT_SCHEMA function.
  - LOCALTIME
```
public static final SqlFunction LOCALTIME
```
    The LOCALTIME [(precision)] function.
  - LOCALTIMESTAMP
```
public static final SqlFunction LOCALTIMESTAMP
```
    The LOCALTIMESTAMP [(precision)] function.
  - CURRENT_TIME
```
public static final SqlFunction CURRENT_TIME
```
    The CURRENT_TIME [(precision)] function.
  - CURRENT_TIMESTAMP
```
public static final SqlFunction CURRENT_TIMESTAMP
```
    The CURRENT_TIMESTAMP [(precision)] function.
  - CURRENT_DATE
```
public static final SqlFunction CURRENT_DATE
```
    The CURRENT_DATE function.
  - TIMESTAMP_ADD
```
public static final SqlFunction TIMESTAMP_ADD
```
    The TIMESTAMPADD function.
  - TIMESTAMP_DIFF
```
public static final SqlFunction TIMESTAMP_DIFF
```
    The TIMESTAMPDIFF function.
  - IN_FENNEL
```
public static final SqlFunction IN_FENNEL
```
    Use of the IN_FENNEL operator forces the argument to be evaluated in Fennel. Otherwise acts as identity function.
  - CAST
```
public static final SqlFunction CAST
```
    The SQL CAST operator.
    The SQL syntax is
    CAST(expression AS type)
    
    When the CAST operator is applies as a 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.
  - EXTRACT
```
public static final SqlFunction EXTRACT
```
    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
  - YEAR
```
public static final SqlDatePartFunction YEAR
```
    The SQL YEAR operator. Returns the Year from a DATETIME E.g.
    YEAR(date '2008-9-23') returns 2008
  - QUARTER
```
public static final SqlDatePartFunction QUARTER
```
    The SQL QUARTER operator. Returns the Quarter from a DATETIME E.g.
    QUARTER(date '2008-9-23') returns 3
  - MONTH
```
public static final SqlDatePartFunction MONTH
```
    The SQL MONTH operator. Returns the Month from a DATETIME E.g.
    MONTH(date '2008-9-23') returns 9
  - WEEK
```
public static final SqlDatePartFunction WEEK
```
    The SQL WEEK operator. Returns the Week from a DATETIME E.g.
    WEEK(date '2008-9-23') returns 39
  - DAYOFYEAR
```
public static final SqlDatePartFunction DAYOFYEAR
```
    The SQL DAYOFYEAR operator. Returns the DOY from a DATETIME E.g.
    DAYOFYEAR(date '2008-9-23') returns 267
  - DAYOFMONTH
```
public static final SqlDatePartFunction DAYOFMONTH
```
    The SQL DAYOFMONTH operator. Returns the Day from a DATETIME E.g.
    DAYOFMONTH(date '2008-9-23') returns 23
  - DAYOFWEEK
```
public static final SqlDatePartFunction DAYOFWEEK
```
    The SQL DAYOFWEEK operator. Returns the DOW from a DATETIME E.g.
    DAYOFWEEK(date '2008-9-23') returns 2
  - HOUR
```
public static final SqlDatePartFunction HOUR
```
    The SQL HOUR operator. Returns the Hour from a DATETIME E.g.
    HOUR(timestamp '2008-9-23 01:23:45') returns 1
  - MINUTE
```
public static final SqlDatePartFunction MINUTE
```
    The SQL MINUTE operator. Returns the Minute from a DATETIME E.g.
    MINUTE(timestamp '2008-9-23 01:23:45') returns 23
  - SECOND
```
public static final SqlDatePartFunction SECOND
```
    The SQL SECOND operator. Returns the Second from a DATETIME E.g.
    SECOND(timestamp '2008-9-23 01:23:45') returns 45
  - ELEMENT
```
public static final SqlFunction ELEMENT
```
    The ELEMENT operator, used to convert a multiset with only one item to a "regular" type. Example ... log(ELEMENT(MULTISET[1])) ...
  - ITEM
```
public static final SqlOperator ITEM
```
    The item operator [ ... ], used to access a given element of an array or map. For example, myArray[3] or "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.
  - ARRAY_VALUE_CONSTRUCTOR
```
public static final SqlArrayValueConstructor ARRAY_VALUE_CONSTRUCTOR
```
    The ARRAY Value Constructor. e.g. "ARRAY[1, 2, 3]".
  - MAP_VALUE_CONSTRUCTOR
```
public static final SqlMapValueConstructor MAP_VALUE_CONSTRUCTOR
```
    The MAP Value Constructor, e.g. "MAP['washington', 1, 'obama', 44]".
  - SLICE
```
public static final SqlInternalOperator SLICE
```
    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.
  - ELEMENT_SLICE
```
public static final SqlInternalOperator ELEMENT_SLICE
```
    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!
  - SCALAR_QUERY
```
public static final SqlInternalOperator SCALAR_QUERY
```
    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.
  - STRUCT_ACCESS
```
public static final SqlInternalOperator STRUCT_ACCESS
```
    The internal $STRUCT_ACCESS operator is used to access a field of a record.
    In contrast with DOT operator, it never appears in an SqlNode tree and allows to access fields by position and not by name.
  - CARDINALITY
```
public static final SqlFunction CARDINALITY
```
    The CARDINALITY operator, used to retrieve the number of elements in a MULTISET, ARRAY or MAP.
  - COLLECT
```
public static final SqlAggFunction COLLECT
```
    The COLLECT operator. Multiset aggregator function.
  - FUSION
```
public static final SqlAggFunction FUSION
```
    The FUSION operator. Multiset aggregator function.
  - NEXT_VALUE
```
public static final SqlOperator NEXT_VALUE
```
    The sequence next value function: NEXT VALUE FOR sequence
  - CURRENT_VALUE
```
public static final SqlOperator CURRENT_VALUE
```
    The sequence current value function: CURRENT VALUE FOR sequence
  - TABLESAMPLE
```
public static final SqlSpecialOperator TABLESAMPLE
```
    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 SqlSampleSpec wrapped in a SqlLiteral.
  - TUMBLE
```
public static final SqlGroupedWindowFunction TUMBLE
```
    The TUMBLE group function.
  - TUMBLE_START
```
public static final SqlGroupedWindowFunction TUMBLE_START
```
    The TUMBLE_START auxiliary function of the TUMBLE group function.
  - TUMBLE_END
```
public static final SqlGroupedWindowFunction TUMBLE_END
```
    The TUMBLE_END auxiliary function of the TUMBLE group function.
  - HOP
```
public static final SqlGroupedWindowFunction HOP
```
    The HOP group function.
  - HOP_START
```
public static final SqlGroupedWindowFunction HOP_START
```
    The HOP_START auxiliary function of the HOP group function.
  - HOP_END
```
public static final SqlGroupedWindowFunction HOP_END
```
    The HOP_END auxiliary function of the HOP group function.
  - SESSION
```
public static final SqlGroupedWindowFunction SESSION
```
    The SESSION group function.
  - SESSION_START
```
public static final SqlGroupedWindowFunction SESSION_START
```
    The SESSION_START auxiliary function of the SESSION group function.
  - SESSION_END
```
public static final SqlGroupedWindowFunction SESSION_END
```
    The SESSION_END auxiliary function of the SESSION group function.
  - PATTERN_ALTER
```
public static final SqlBinaryOperator PATTERN_ALTER
```
    | operator to create alternate patterns within MATCH_RECOGNIZE.
    If p1 and p2 are patterns then p1 | p2 is a pattern that matches p1 or p2.
  - PATTERN_CONCAT
```
public static final SqlBinaryOperator PATTERN_CONCAT
```
    Operator to concatenate patterns within MATCH_RECOGNIZE.
    If p1 and p2 are patterns then p1 p2 is a pattern that matches p1 followed by p2.
  - PATTERN_QUANTIFIER
```
public static final SqlSpecialOperator PATTERN_QUANTIFIER
```
    Operator to quantify patterns within MATCH_RECOGNIZE.
    If p is a pattern then p{3, 5} is a pattern that matches between 3 and 5 occurrences of p.
  - PATTERN_PERMUTE
```
public static final SqlSpecialOperator PATTERN_PERMUTE
```
    PERMUTE operator to combine patterns within MATCH_RECOGNIZE.
    If p1 and p2 are patterns then PERMUTE (p1, p2) is a pattern that matches all permutations of p1 and p2.
  - PATTERN_EXCLUDE
```
public static final SqlSpecialOperator PATTERN_EXCLUDE
```
    EXCLUDE operator within MATCH_RECOGNIZE.
    If p is a pattern then {- p -} } is a pattern that excludes p from the output.
- Constructor Detail
  - SqlStdOperatorTable
```
public SqlStdOperatorTable()
```
- Method Detail
  - instance
```
public static SqlStdOperatorTable instance()
```
    Returns the standard operator table, creating it if necessary.
  - auxiliaryToGroup
```
public static SqlGroupedWindowFunction auxiliaryToGroup(SqlKind kind)
```
    Returns the group function for which a given kind is an auxiliary function, or null if it is not an auxiliary function.
  - convertAuxiliaryToGroupCall
```
public static SqlCall convertAuxiliaryToGroupCall(SqlCall call)
```
    Converts a call to a grouped auxiliary function to a call to the grouped window function. For other calls returns null.
    For example, converts TUMBLE_START(rowtime, INTERVAL '1' HOUR)) to TUMBLE(rowtime, INTERVAL '1' HOUR)).
  - convertGroupToAuxiliaryCalls
```
public static java.util.List<Pair<SqlNode,AuxiliaryConverter>> convertGroupToAuxiliaryCalls(SqlCall call)
```
    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 TUMBLE_START(rowtime, INTERVAL '1' HOUR)) to TUMBLE(rowtime, INTERVAL '1' HOUR)).
  - copy
```
private static SqlCall copy(SqlCall call,
                            SqlOperator operator)
```
    Creates a copy of a call with a new operator.
  - some
```
public static SqlQuantifyOperator some(SqlKind comparisonKind)
```
    Returns the operator for SOME comparisonKind.
  - all
```
public static SqlQuantifyOperator all(SqlKind comparisonKind)
```
    Returns the operator for ALL comparisonKind.

Class SqlStdOperatorTable

Field Summary

Fields inherited from class org.apache.calcite.sql.util.ReflectiveSqlOperatorTable

Constructor Summary

Method Summary

Methods inherited from class org.apache.calcite.sql.util.ReflectiveSqlOperatorTable

Methods inherited from class java.lang.Object

Field Detail

instance

UNION

UNION_ALL

EXCEPT

EXCEPT_ALL

INTERSECT

INTERSECT_ALL

MULTISET_UNION_DISTINCT

MULTISET_UNION

MULTISET_EXCEPT_DISTINCT

MULTISET_EXCEPT

MULTISET_INTERSECT_DISTINCT

MULTISET_INTERSECT

AND

AS

ARGUMENT_ASSIGNMENT

DEFAULT

FILTER

WITHIN_GROUP

CUBE

ROLLUP

GROUPING_SETS

GROUPING

GROUP_ID

GROUPING_ID

EXTEND

CONCAT

DIVIDE

PERCENT_REMAINDER

RAND_INTEGER

RAND

DIVIDE_INTEGER

DOT

EQUALS

GREATER_THAN

IS_DISTINCT_FROM

IS_NOT_DISTINCT_FROM

IS_DIFFERENT_FROM

GREATER_THAN_OR_EQUAL

IN

NOT_IN

SOME_LT

SOME_LE

SOME_GT

SOME_GE

SOME_EQ

SOME_NE

ALL_LT

ALL_LE

ALL_GT

ALL_GE

ALL_EQ

ALL_NE

LESS_THAN

LESS_THAN_OR_EQUAL

MINUS

MULTIPLY

NOT_EQUALS

OR

PLUS

DATETIME_PLUS

MEMBER_OF

SUBMULTISET_OF

NOT_SUBMULTISET_OF

DESC

NULLS_FIRST

NULLS_LAST

IS_NOT_NULL

IS_NULL

IS_NOT_TRUE

IS_TRUE

IS_NOT_FALSE