<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlStdOperatorTable (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.sql.fun, class: SqlStdOperatorTable">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql.fun</a></div>
<h1 title="Class SqlStdOperatorTable" class="title">Class SqlStdOperatorTable</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance"><a href="../util/ReflectiveSqlOperatorTable.html" title="class in org.apache.calcite.sql.util">org.apache.calcite.sql.util.ReflectiveSqlOperatorTable</a>
<div class="inheritance">org.apache.calcite.sql.fun.SqlStdOperatorTable</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">SqlStdOperatorTable</span>
<span class="extends-implements">extends <a href="../util/ReflectiveSqlOperatorTable.html" title="class in org.apache.calcite.sql.util">ReflectiveSqlOperatorTable</a></span></div>
<div class="block">Implementation of <a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql"><code>SqlOperatorTable</code></a> containing
 the standard operators and functions.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ABS" class="member-name-link">ABS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ACOS" class="member-name-link">ACOS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#ALL_EQ" class="member-name-link">ALL_EQ</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ALL_GE" class="member-name-link">ALL_GE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#ALL_GT" class="member-name-link">ALL_GT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ALL_LE" class="member-name-link">ALL_LE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#ALL_LT" class="member-name-link">ALL_LT</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>&lt; ALL</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ALL_NE" class="member-name-link">ALL_NE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#AND" class="member-name-link">AND</a></code></div>
<div class="col-last even-row-color">
<div class="block">Logical <code>AND</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ANY_VALUE" class="member-name-link">ANY_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>ANY_VALUE</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#APPROX_COUNT_DISTINCT" class="member-name-link">APPROX_COUNT_DISTINCT</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>APPROX_COUNT_DISTINCT</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARGUMENT_ASSIGNMENT" class="member-name-link">ARGUMENT_ASSIGNMENT</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>ARGUMENT_ASSIGNMENT</code> operator (<code>=&lt;</code>)
 assigns an argument to a function call to a particular named parameter.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARRAY_QUERY" class="member-name-link">ARRAY_QUERY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The ARRAY Query Constructor.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlArrayValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlArrayValueConstructor</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARRAY_VALUE_CONSTRUCTOR" class="member-name-link">ARRAY_VALUE_CONSTRUCTOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The ARRAY Value Constructor.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAsOperator.html" title="class in org.apache.calcite.sql">SqlAsOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#AS" class="member-name-link">AS</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>AS</code> operator associates an expression in the SELECT clause
 with an alias.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ASCII" class="member-name-link">ASCII</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ASIN" class="member-name-link">ASIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ATAN" class="member-name-link">ATAN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ATAN2" class="member-name-link">ATAN2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#AVG" class="member-name-link">AVG</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>AVG</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#BETWEEN" class="member-name-link">BETWEEN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BIT_AND" class="member-name-link">BIT_AND</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>BIT_AND</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#BIT_OR" class="member-name-link">BIT_OR</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>BIT_OR</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BIT_XOR" class="member-name-link">BIT_XOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>BIT_XOR</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CARDINALITY" class="member-name-link">CARDINALITY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The CARDINALITY operator, used to retrieve the number of elements in a
 MULTISET, ARRAY or MAP.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlCaseOperator.html" title="class in org.apache.calcite.sql.fun">SqlCaseOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CASE" class="member-name-link">CASE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CAST" class="member-name-link">CAST</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>CAST</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CBRT" class="member-name-link">CBRT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CEIL" class="member-name-link">CEIL</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>CEIL</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CHAR_LENGTH" class="member-name-link">CHAR_LENGTH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CHARACTER_LENGTH" class="member-name-link">CHARACTER_LENGTH</a></code></div>
<div class="col-last even-row-color">
<div class="block">Alias for <a href="#CHAR_LENGTH"><code>CHAR_LENGTH</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CLASSIFIER" class="member-name-link">CLASSIFIER</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>CLASSIFIER</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#COALESCE" class="member-name-link">COALESCE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The COALESCE builtin function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COLLECT" class="member-name-link">COLLECT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The COLLECT operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#COLLECTION_TABLE" class="member-name-link">COLLECTION_TABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "table function derived table" operator, which a table-valued
 function into a relation, e.g.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlColumnListConstructor.html" title="class in org.apache.calcite.sql.fun">SqlColumnListConstructor</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COLUMN_LIST" class="member-name-link">COLUMN_LIST</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The COLUMN_LIST constructor.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#CONCAT" class="member-name-link">CONCAT</a></code></div>
<div class="col-last even-row-color">
<div class="block">String and array-to-array concatenation operator, '<code>||</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CONTAINS" class="member-name-link">CONTAINS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CONVERT" class="member-name-link">CONVERT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COS" class="member-name-link">COS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#COT" class="member-name-link">COT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COUNT" class="member-name-link">COUNT</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>COUNT</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#COVAR_POP" class="member-name-link">COVAR_POP</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>COVAR_POP</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COVAR_SAMP" class="member-name-link">COVAR_SAMP</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>COVAR_SAMP</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#CUBE" class="member-name-link">CUBE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>CUBE</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CUME_DIST" class="member-name-link">CUME_DIST</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>CUME_DIST</code> window function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_CATALOG" class="member-name-link">CURRENT_CATALOG</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>CURRENT_CATALOG</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURRENT_DATE" class="member-name-link">CURRENT_DATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>CURRENT_DATE</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_PATH" class="member-name-link">CURRENT_PATH</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>CURRENT_PATH</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURRENT_ROLE" class="member-name-link">CURRENT_ROLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>CURRENT_ROLE</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_SCHEMA" class="member-name-link">CURRENT_SCHEMA</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>CURRENT_SCHEMA</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURRENT_TIME" class="member-name-link">CURRENT_TIME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>CURRENT_TIME [(<i>precision</i>)]</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_TIMESTAMP" class="member-name-link">CURRENT_TIMESTAMP</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>CURRENT_TIMESTAMP [(<i>precision</i>)]</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURRENT_USER" class="member-name-link">CURRENT_USER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>CURRENT_USER</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_VALUE" class="member-name-link">CURRENT_VALUE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The sequence current value function: <code>CURRENT VALUE FOR
 sequence</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlCursorConstructor.html" title="class in org.apache.calcite.sql.fun">SqlCursorConstructor</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURSOR" class="member-name-link">CURSOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The CURSOR constructor.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATETIME_PLUS" class="member-name-link">DATETIME_PLUS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Infix datetime plus operator, '<code>DATETIME + INTERVAL</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DAYOFMONTH" class="member-name-link">DAYOFMONTH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>DAYOFMONTH</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DAYOFWEEK" class="member-name-link">DAYOFWEEK</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>DAYOFWEEK</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DAYOFYEAR" class="member-name-link">DAYOFYEAR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>DAYOFYEAR</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT" class="member-name-link">DEFAULT</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>DEFAULT</code> operator indicates that an argument to a function call
 is to take its default value..</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DEGREES" class="member-name-link">DEGREES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DENSE_RANK" class="member-name-link">DENSE_RANK</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>DENSE_RANK</code> window function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DESC" class="member-name-link">DESC</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#DESCRIPTOR" class="member-name-link">DESCRIPTOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">DESCRIPTOR(column_name, ...).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DIVIDE" class="member-name-link">DIVIDE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Arithmetic division operator, '<code>/</code>'.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#DIVIDE_INTEGER" class="member-name-link">DIVIDE_INTEGER</a></code></div>
<div class="col-last even-row-color">
<div class="block">Internal integer arithmetic division operator, '<code>/INT</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DOT" class="member-name-link">DOT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Dot operator, '<code>.</code>', used for referencing fields of records.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ELEMENT" class="member-name-link">ELEMENT</a></code></div>
<div class="col-last even-row-color">
<div class="block">The ELEMENT operator, used to convert a multiset with only one item to a
 "regular" type.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ELEMENT_SLICE" class="member-name-link">ELEMENT_SLICE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The internal "$ELEMENT_SLICE" operator returns the first field of the
 only element of a multiset.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#EQUALS" class="member-name-link">EQUALS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Logical equals operator, '<code>=</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ESCAPE" class="member-name-link">ESCAPE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Internal operator used to represent the ESCAPE clause of a LIKE or
 SIMILAR TO expression.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#EVERY" class="member-name-link">EVERY</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>EVERY</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXCEPT" class="member-name-link">EXCEPT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#EXCEPT_ALL" class="member-name-link">EXCEPT_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXISTS" class="member-name-link">EXISTS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#EXP" class="member-name-link">EXP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXPLICIT_TABLE" class="member-name-link">EXPLICIT_TABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Keyword which allows an identifier to be explicitly flagged as a table.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#EXTEND" class="member-name-link">EXTEND</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>EXTEND</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXTRACT" class="member-name-link">EXTRACT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>EXTRACT</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFilterOperator.html" title="class in org.apache.calcite.sql">SqlFilterOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#FILTER" class="member-name-link">FILTER</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>FILTER</code> operator filters which rows are included in an
  aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#FINAL" class="member-name-link">FINAL</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>FINAL</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#FIRST" class="member-name-link">FIRST</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>FIRST</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#FIRST_VALUE" class="member-name-link">FIRST_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>FIRST_VALUE</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#FLOOR" class="member-name-link">FLOOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>FLOOR</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#FUSION" class="member-name-link">FUSION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The FUSION operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#GREATER_THAN" class="member-name-link">GREATER_THAN</a></code></div>
<div class="col-last even-row-color">
<div class="block">Logical greater-than operator, '<code>&gt;</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#GREATER_THAN_OR_EQUAL" class="member-name-link">GREATER_THAN_OR_EQUAL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Logical greater-than-or-equal operator, '<code>&gt;=</code>'.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#GROUP_ID" class="member-name-link">GROUP_ID</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>GROUP_ID()</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#GROUPING" class="member-name-link">GROUPING</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>GROUPING(c1 [, c2, ...])</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#GROUPING_ID" class="member-name-link">GROUPING_ID</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>GROUPING_ID</code> function is a synonym for <code>GROUPING</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#GROUPING_SETS" class="member-name-link">GROUPING_SETS</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>GROUPING SETS</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#HISTOGRAM_AGG" class="member-name-link">HISTOGRAM_AGG</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>HISTOGRAM</code> aggregate function support.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HISTOGRAM_FIRST_VALUE" class="member-name-link">HISTOGRAM_FIRST_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>HISTOGRAM_FIRST_VALUE</code> window aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#HISTOGRAM_LAST_VALUE" class="member-name-link">HISTOGRAM_LAST_VALUE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>HISTOGRAM_LAST_VALUE</code> window aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HISTOGRAM_MAX" class="member-name-link">HISTOGRAM_MAX</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>HISTOGRAM_MAX</code> window aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#HISTOGRAM_MIN" class="member-name-link">HISTOGRAM_MIN</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>HISTOGRAM_MIN</code> window aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HOP" class="member-name-link">HOP</a></code></div>
<div class="col-last odd-row-color">
<div class="block">HOP as a table function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#HOP_END" class="member-name-link">HOP_END</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>HOP_END</code> auxiliary function of
 the <code>HOP</code> group function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HOP_OLD" class="member-name-link">HOP_OLD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>HOP</code> group function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#HOP_START" class="member-name-link">HOP_START</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>HOP_START</code> auxiliary function of
 the <code>HOP</code> group function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HOUR" class="member-name-link">HOUR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>HOUR</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlNullTreatmentOperator.html" title="class in org.apache.calcite.sql">SqlNullTreatmentOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IGNORE_NULLS" class="member-name-link">IGNORE_NULLS</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>IGNORE NULLS</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IMMEDIATELY_PRECEDES" class="member-name-link">IMMEDIATELY_PRECEDES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IMMEDIATELY_SUCCEEDS" class="member-name-link">IMMEDIATELY_SUCCEEDS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IN" class="member-name-link">IN</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>IN</code> operator tests for a value's membership in a sub-query or
 a list of values.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#IN_FENNEL" class="member-name-link">IN_FENNEL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Use of the <code>IN_FENNEL</code> operator forces the argument to be
 evaluated in Fennel.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INITCAP" class="member-name-link">INITCAP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTERSECT" class="member-name-link">INTERSECT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTERSECT_ALL" class="member-name-link">INTERSECT_ALL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTERSECTION" class="member-name-link">INTERSECTION</a></code></div>
<div class="col-last even-row-color">
<div class="block">The INTERSECTION operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTERVAL" class="member-name-link">INTERVAL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Interval expression, '<code>INTERVAL n timeUnit</code>'.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_A_SET" class="member-name-link">IS_A_SET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_DIFFERENT_FROM" class="member-name-link">IS_DIFFERENT_FROM</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The internal <code>$IS_DIFFERENT_FROM</code> operator is the same as the
 user-level <a href="#IS_DISTINCT_FROM"><code>IS_DISTINCT_FROM</code></a> in all respects except that
 the test for equality on character datatypes treats trailing spaces as
 significant.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_DISTINCT_FROM" class="member-name-link">IS_DISTINCT_FROM</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>IS DISTINCT FROM</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_EMPTY" class="member-name-link">IS_EMPTY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_FALSE" class="member-name-link">IS_FALSE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_JSON_ARRAY" class="member-name-link">IS_JSON_ARRAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_JSON_OBJECT" class="member-name-link">IS_JSON_OBJECT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_JSON_SCALAR" class="member-name-link">IS_JSON_SCALAR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_JSON_VALUE" class="member-name-link">IS_JSON_VALUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_A_SET" class="member-name-link">IS_NOT_A_SET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NOT_DISTINCT_FROM" class="member-name-link">IS_NOT_DISTINCT_FROM</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>IS NOT DISTINCT FROM</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_EMPTY" class="member-name-link">IS_NOT_EMPTY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NOT_FALSE" class="member-name-link">IS_NOT_FALSE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_JSON_ARRAY" class="member-name-link">IS_NOT_JSON_ARRAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NOT_JSON_OBJECT" class="member-name-link">IS_NOT_JSON_OBJECT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_JSON_SCALAR" class="member-name-link">IS_NOT_JSON_SCALAR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NOT_JSON_VALUE" class="member-name-link">IS_NOT_JSON_VALUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_NULL" class="member-name-link">IS_NOT_NULL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NOT_TRUE" class="member-name-link">IS_NOT_TRUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_NOT_UNKNOWN" class="member-name-link">IS_NOT_UNKNOWN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_NULL" class="member-name-link">IS_NULL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IS_TRUE" class="member-name-link">IS_TRUE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#IS_UNKNOWN" class="member-name-link">IS_UNKNOWN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ITEM" class="member-name-link">ITEM</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The item operator <code>[ ... ]</code>, used to access a given element of an
 array, map or struct.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_ARRAY" class="member-name-link">JSON_ARRAY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlJsonArrayAggAggFunction.html" title="class in org.apache.calcite.sql.fun">SqlJsonArrayAggAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_ARRAYAGG" class="member-name-link">JSON_ARRAYAGG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_DEPTH" class="member-name-link">JSON_DEPTH</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_EXISTS" class="member-name-link">JSON_EXISTS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_KEYS" class="member-name-link">JSON_KEYS</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_LENGTH" class="member-name-link">JSON_LENGTH</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_OBJECT" class="member-name-link">JSON_OBJECT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlJsonObjectAggAggFunction.html" title="class in org.apache.calcite.sql.fun">SqlJsonObjectAggAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_OBJECTAGG" class="member-name-link">JSON_OBJECTAGG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_PRETTY" class="member-name-link">JSON_PRETTY</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_QUERY" class="member-name-link">JSON_QUERY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_REMOVE" class="member-name-link">JSON_REMOVE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_STORAGE_SIZE" class="member-name-link">JSON_STORAGE_SIZE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_TYPE" class="member-name-link">JSON_TYPE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final org.apache.calcite.sql.fun.SqlJsonTypeOperator</code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_TYPE_OPERATOR" class="member-name-link">JSON_TYPE_OPERATOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_VALUE" class="member-name-link">JSON_VALUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_VALUE_EXPRESSION" class="member-name-link">JSON_VALUE_EXPRESSION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LAG" class="member-name-link">LAG</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>LAG</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LAST" class="member-name-link">LAST</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>LAST</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LAST_DAY" class="member-name-link">LAST_DAY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LAST_VALUE" class="member-name-link">LAST_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>LAST_VALUE</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#LATERAL" class="member-name-link">LATERAL</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>LATERAL</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LEAD" class="member-name-link">LEAD</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>LEAD</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#LESS_THAN" class="member-name-link">LESS_THAN</a></code></div>
<div class="col-last even-row-color">
<div class="block">Logical less-than operator, '<code>&lt;</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LESS_THAN_OR_EQUAL" class="member-name-link">LESS_THAN_OR_EQUAL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Logical less-than-or-equal operator, '<code>&lt;=</code>'.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#LIKE" class="member-name-link">LIKE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LISTAGG" class="member-name-link">LISTAGG</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The LISTAGG operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlLiteralChainOperator.html" title="class in org.apache.calcite.sql.fun">SqlLiteralChainOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#LITERAL_CHAIN" class="member-name-link">LITERAL_CHAIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LN" class="member-name-link">LN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LOCALTIME" class="member-name-link">LOCALTIME</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>LOCALTIME [(<i>precision</i>)]</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LOCALTIMESTAMP" class="member-name-link">LOCALTIMESTAMP</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>LOCALTIMESTAMP [(<i>precision</i>)]</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LOG10" class="member-name-link">LOG10</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LOWER" class="member-name-link">LOWER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></code></div>
<div class="col-second even-row-color"><code><a href="#MAP_QUERY" class="member-name-link">MAP_QUERY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The MAP Query Constructor.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlMapValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMapValueConstructor</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MAP_VALUE_CONSTRUCTOR" class="member-name-link">MAP_VALUE_CONSTRUCTOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The MAP Value Constructor,
 e.g.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#MATCH_NUMBER" class="member-name-link">MATCH_NUMBER</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>MATCH_NUMBER</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MAX" class="member-name-link">MAX</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>MAX</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MEMBER_OF" class="member-name-link">MEMBER_OF</a></code></div>
<div class="col-last even-row-color">
<div class="block">Multiset <code>MEMBER OF</code>, which returns whether a element belongs to a
 multiset.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MIN" class="member-name-link">MIN</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>MIN</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MINUS" class="member-name-link">MINUS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Infix arithmetic minus operator, '<code>-</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatetimeSubtractionOperator.html" title="class in org.apache.calcite.sql.fun">SqlDatetimeSubtractionOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MINUS_DATE" class="member-name-link">MINUS_DATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">A special operator for the subtraction of two DATETIMEs.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#MINUTE" class="member-name-link">MINUTE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>MINUTE</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MOD" class="member-name-link">MOD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Arithmetic remainder function <code>MOD</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#MODE" class="member-name-link">MODE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>MODE</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MONTH" class="member-name-link">MONTH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>MONTH</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTIPLY" class="member-name-link">MULTIPLY</a></code></div>
<div class="col-last even-row-color">
<div class="block">Arithmetic multiplication operator, '<code>*</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_EXCEPT" class="member-name-link">MULTISET_EXCEPT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>MULTISET EXCEPT [ALL]</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_EXCEPT_DISTINCT" class="member-name-link">MULTISET_EXCEPT_DISTINCT</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>MULTISET EXCEPT DISTINCT</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_INTERSECT" class="member-name-link">MULTISET_INTERSECT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>MULTISET INTERSECT [ALL]</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_INTERSECT_DISTINCT" class="member-name-link">MULTISET_INTERSECT_DISTINCT</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>MULTISET INTERSECT DISTINCT</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_QUERY" class="member-name-link">MULTISET_QUERY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The MULTISET Query Constructor.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_UNION" class="member-name-link">MULTISET_UNION</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>MULTISET UNION [ALL]</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_UNION_DISTINCT" class="member-name-link">MULTISET_UNION_DISTINCT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>MULTISET UNION DISTINCT</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlMultisetValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetValueConstructor</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_VALUE" class="member-name-link">MULTISET_VALUE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The MULTISET Value Constructor.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NEGATED_POSIX_REGEX_CASE_INSENSITIVE" class="member-name-link">NEGATED_POSIX_REGEX_CASE_INSENSITIVE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NEGATED_POSIX_REGEX_CASE_SENSITIVE" class="member-name-link">NEGATED_POSIX_REGEX_CASE_SENSITIVE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NEW" class="member-name-link">NEW</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#NEXT" class="member-name-link">NEXT</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>NEXT</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NEXT_VALUE" class="member-name-link">NEXT_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The sequence next value function: <code>NEXT VALUE FOR sequence</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NOT" class="member-name-link">NOT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NOT_BETWEEN" class="member-name-link">NOT_BETWEEN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NOT_EQUALS" class="member-name-link">NOT_EQUALS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Logical not-equals operator, '<code>&lt;&gt;</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NOT_IN" class="member-name-link">NOT_IN</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>NOT IN</code> operator tests for a value's membership in a sub-query
 or a list of values.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NOT_LIKE" class="member-name-link">NOT_LIKE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NOT_SIMILAR_TO" class="member-name-link">NOT_SIMILAR_TO</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NOT_SUBMULTISET_OF" class="member-name-link">NOT_SUBMULTISET_OF</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NTH_VALUE" class="member-name-link">NTH_VALUE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>NTH_VALUE</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#NTILE" class="member-name-link">NTILE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>NTILE</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NULLIF" class="member-name-link">NULLIF</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NULLS_FIRST" class="member-name-link">NULLS_FIRST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NULLS_LAST" class="member-name-link">NULLS_LAST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#OCTET_LENGTH" class="member-name-link">OCTET_LENGTH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#OR" class="member-name-link">OR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Logical <code>OR</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#OVER" class="member-name-link">OVER</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>OVER</code> operator, which applies an aggregate functions to a
 <a href="../SqlWindow.html" title="class in org.apache.calcite.sql"><code>window</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#OVERLAPS" class="member-name-link">OVERLAPS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#OVERLAY" class="member-name-link">OVERLAY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PATTERN_ALTER" class="member-name-link">PATTERN_ALTER</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>|</code> operator to create alternate patterns
 within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#PATTERN_CONCAT" class="member-name-link">PATTERN_CONCAT</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operator to concatenate patterns within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PATTERN_EXCLUDE" class="member-name-link">PATTERN_EXCLUDE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>EXCLUDE</code> operator within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#PATTERN_PERMUTE" class="member-name-link">PATTERN_PERMUTE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>PERMUTE</code> operator to combine patterns within
 <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PATTERN_QUANTIFIER" class="member-name-link">PATTERN_QUANTIFIER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operator to quantify patterns within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#PERCENT_RANK" class="member-name-link">PERCENT_RANK</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>PERCENT_RANK</code> window function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PERCENT_REMAINDER" class="member-name-link">PERCENT_REMAINDER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Arithmetic remainder operator, '<code>%</code>',
 an alternative to <a href="#MOD"><code>MOD</code></a> allowed if under certain conformance levels.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#PERCENTILE_CONT" class="member-name-link">PERCENTILE_CONT</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>PERCENTILE_CONT</code> inverse distribution aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PERCENTILE_DISC" class="member-name-link">PERCENTILE_DISC</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>PERCENTILE_DISC</code> inverse distribution aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#PERIOD_EQUALS" class="member-name-link">PERIOD_EQUALS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PI" class="member-name-link">PI</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#PLUS" class="member-name-link">PLUS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Infix arithmetic plus operator, '<code>+</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#POSITION" class="member-name-link">POSITION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#POSIX_REGEX_CASE_INSENSITIVE" class="member-name-link">POSIX_REGEX_CASE_INSENSITIVE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#POSIX_REGEX_CASE_SENSITIVE" class="member-name-link">POSIX_REGEX_CASE_SENSITIVE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#POWER" class="member-name-link">POWER</a></code></div>
<div class="col-last even-row-color">
<div class="block">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.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PRECEDES" class="member-name-link">PRECEDES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#PREV" class="member-name-link">PREV</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>PREV</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PROCEDURE_CALL" class="member-name-link">PROCEDURE_CALL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#QUARTER" class="member-name-link">QUARTER</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>QUARTER</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RADIANS" class="member-name-link">RADIANS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlRandFunction.html" title="class in org.apache.calcite.sql.fun">SqlRandFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#RAND" class="member-name-link">RAND</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>RAND([seed])</code> function, which yields a random double,
 optionally with seed.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlRandIntegerFunction.html" title="class in org.apache.calcite.sql.fun">SqlRandIntegerFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RAND_INTEGER" class="member-name-link">RAND_INTEGER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>RAND_INTEGER([seed, ] bound)</code> function, which yields a random
 integer, optionally with seed.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#RANK" class="member-name-link">RANK</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>RANK</code> window function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#REGR_COUNT" class="member-name-link">REGR_COUNT</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>REGR_COUNT</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#REGR_SXX" class="member-name-link">REGR_SXX</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>REGR_SXX</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#REGR_SYY" class="member-name-link">REGR_SYY</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>REGR_SYY</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#REINTERPRET" class="member-name-link">REINTERPRET</a></code></div>
<div class="col-last even-row-color">
<div class="block">An <code>REINTERPRET</code> operator is internal to the planner.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#REPLACE" class="member-name-link">REPLACE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>REPLACE(string, search, replace)</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlNullTreatmentOperator.html" title="class in org.apache.calcite.sql">SqlNullTreatmentOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#RESPECT_NULLS" class="member-name-link">RESPECT_NULLS</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>RESPECT NULLS</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ROLLUP" class="member-name-link">ROLLUP</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>ROLLUP</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ROUND" class="member-name-link">ROUND</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlRowOperator.html" title="class in org.apache.calcite.sql.fun">SqlRowOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ROW" class="member-name-link">ROW</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ROW_NUMBER" class="member-name-link">ROW_NUMBER</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>ROW_NUMBER</code> window function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RUNNING" class="member-name-link">RUNNING</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>RUNNING</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SCALAR_QUERY" class="member-name-link">SCALAR_QUERY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The internal "$SCALAR_QUERY" operator returns a scalar value from a
 record type.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SEARCH" class="member-name-link">SEARCH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operator that tests whether its left operand is included in the range of
 values covered by search arguments.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SECOND" class="member-name-link">SECOND</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>SECOND</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SESSION" class="member-name-link">SESSION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">SESSION as a table function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SESSION_END" class="member-name-link">SESSION_END</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>SESSION_END</code> auxiliary function of
 the <code>SESSION</code> group function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SESSION_OLD" class="member-name-link">SESSION_OLD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>SESSION</code> group function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SESSION_START" class="member-name-link">SESSION_START</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>SESSION_START</code> auxiliary function of
 the <code>SESSION</code> group function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SESSION_USER" class="member-name-link">SESSION_USER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>SESSION_USER</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SET_SEMANTICS_TABLE" class="member-name-link">SET_SEMANTICS_TABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">SetSemanticsTable represents as an input table with set semantics.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SIGN" class="member-name-link">SIGN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SIMILAR_TO" class="member-name-link">SIMILAR_TO</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SIN" class="member-name-link">SIN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SINGLE_VALUE" class="member-name-link">SINGLE_VALUE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>SINGLE_VALUE</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SLICE" class="member-name-link">SLICE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The internal "$SLICE" operator takes a multiset of records and returns a
 multiset of the first column of those records.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SOME" class="member-name-link">SOME</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>SOME</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SOME_EQ" class="member-name-link">SOME_EQ</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SOME_GE" class="member-name-link">SOME_GE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SOME_GT" class="member-name-link">SOME_GT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SOME_LE" class="member-name-link">SOME_LE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SOME_LT" class="member-name-link">SOME_LT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>&lt; SOME</code> operator (synonymous with
 <code>&lt; ANY</code>).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SOME_NE" class="member-name-link">SOME_NE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SQRT" class="member-name-link">SQRT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#STDDEV" class="member-name-link">STDDEV</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>STDDEV</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STDDEV_POP" class="member-name-link">STDDEV_POP</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>STDDEV_POP</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#STDDEV_SAMP" class="member-name-link">STDDEV_SAMP</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>STDDEV_SAMP</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRUCT_ACCESS" class="member-name-link">STRUCT_ACCESS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The internal <code>$STRUCT_ACCESS</code> operator is used to access a
 field of a record.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SUBMULTISET_OF" class="member-name-link">SUBMULTISET_OF</a></code></div>
<div class="col-last even-row-color">
<div class="block">Submultiset.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SUBSTRING" class="member-name-link">SUBSTRING</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The character substring function: <code>SUBSTRING(string FROM start [FOR
 length])</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SUCCEEDS" class="member-name-link">SUCCEEDS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SUM" class="member-name-link">SUM</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>SUM</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SUM0" class="member-name-link">SUM0</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>SUM0</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SYMMETRIC_BETWEEN" class="member-name-link">SYMMETRIC_BETWEEN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#SYMMETRIC_NOT_BETWEEN" class="member-name-link">SYMMETRIC_NOT_BETWEEN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SYSTEM_USER" class="member-name-link">SYSTEM_USER</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>SYSTEM_USER</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#TABLESAMPLE" class="member-name-link">TABLESAMPLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>TABLESAMPLE</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TAN" class="member-name-link">TAN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlThrowOperator.html" title="class in org.apache.calcite.sql.fun">SqlThrowOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#THROW" class="member-name-link">THROW</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_ADD" class="member-name-link">TIMESTAMP_ADD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>TIMESTAMPADD</code> function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_DIFF" class="member-name-link">TIMESTAMP_DIFF</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>TIMESTAMPDIFF</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TRANSLATE" class="member-name-link">TRANSLATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>TRANSLATE(<i>char_value</i> USING <i>translation_name</i>)</code> function
 alters the character set of a string value from one base character set to another.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TRIM" class="member-name-link">TRIM</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TRIM" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TRUNCATE" class="member-name-link">TRUNCATE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TUMBLE" class="member-name-link">TUMBLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">TUMBLE as a table function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TUMBLE_END" class="member-name-link">TUMBLE_END</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>TUMBLE_END</code> auxiliary function of
 the <code>TUMBLE</code> group function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TUMBLE_OLD" class="member-name-link">TUMBLE_OLD</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>TUMBLE</code> group function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TUMBLE_START" class="member-name-link">TUMBLE_START</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>TUMBLE_START</code> auxiliary function of
 the <code>TUMBLE</code> group function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNARY_MINUS" class="member-name-link">UNARY_MINUS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Prefix arithmetic minus operator, '<code>-</code>'.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UNARY_PLUS" class="member-name-link">UNARY_PLUS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Prefix arithmetic plus operator, '<code>+</code>'.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNION" class="member-name-link">UNION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UNION_ALL" class="member-name-link">UNION_ALL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNIQUE" class="member-name-link">UNIQUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlUnnestOperator.html" title="class in org.apache.calcite.sql">SqlUnnestOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UNNEST" class="member-name-link">UNNEST</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>UNNEST</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlUnnestOperator.html" title="class in org.apache.calcite.sql">SqlUnnestOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNNEST_WITH_ORDINALITY" class="member-name-link">UNNEST_WITH_ORDINALITY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>UNNEST WITH ORDINALITY</code> operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UPPER" class="member-name-link">UPPER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#USER" class="member-name-link">USER</a></code></div>
<div class="col-last even-row-color">
<div class="block">The <code>USER</code> function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#VALUES" class="member-name-link">VALUES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#VAR_POP" class="member-name-link">VAR_POP</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>VAR_POP</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#VAR_SAMP" class="member-name-link">VAR_SAMP</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>VAR_SAMP</code> aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#VARIANCE" class="member-name-link">VARIANCE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>VARIANCE</code> aggregate function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#WEEK" class="member-name-link">WEEK</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The SQL <code>WEEK</code> operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlWithinDistinctOperator.html" title="class in org.apache.calcite.sql">SqlWithinDistinctOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#WITHIN_DISTINCT" class="member-name-link">WITHIN_DISTINCT</a></code></div>
<div class="col-last even-row-color">
<div class="block"><code>WITHIN_DISTINCT</code> operator performs aggregations on distinct
 data input.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlWithinGroupOperator.html" title="class in org.apache.calcite.sql">SqlWithinGroupOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#WITHIN_GROUP" class="member-name-link">WITHIN_GROUP</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><code>WITHIN_GROUP</code> operator performs aggregations on ordered data input.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#YEAR" class="member-name-link">YEAR</a></code></div>
<div class="col-last even-row-color">
<div class="block">The SQL <code>YEAR</code> operator.</div>
</div>
</div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.calcite.sql.util.ReflectiveSqlOperatorTable">Fields inherited from class&nbsp;org.apache.calcite.sql.util.<a href="../util/ReflectiveSqlOperatorTable.html" title="class in org.apache.calcite.sql.util">ReflectiveSqlOperatorTable</a></h3>
<code><a href="../util/ReflectiveSqlOperatorTable.html#IS_NAME">IS_NAME</a></code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">SqlStdOperatorTable</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#all(org.apache.calcite.sql.SqlKind)" class="member-name-link">all</a><wbr>(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;comparisonKind)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the operator for <code>ALL comparisonKind</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#auxiliaryToGroup(org.apache.calcite.sql.SqlKind)" class="member-name-link">auxiliaryToGroup</a><wbr>(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the group function for which a given kind is an auxiliary
 function, or null if it is not an auxiliary function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convertAuxiliaryToGroupCall(org.apache.calcite.sql.SqlCall)" class="member-name-link">convertAuxiliaryToGroupCall</a><wbr>(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a call to a grouped auxiliary function
 to a call to the grouped window function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../../sql2rel/AuxiliaryConverter.html" title="interface in org.apache.calcite.sql2rel">AuxiliaryConverter</a>&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convertGroupToAuxiliaryCalls(org.apache.calcite.sql.SqlCall)" class="member-name-link">convertGroupToAuxiliaryCalls</a><wbr>(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a call to a grouped window function to a call to its auxiliary
 window function(s).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlStdOperatorTable.html" title="class in org.apache.calcite.sql.fun">SqlStdOperatorTable</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#instance()" class="member-name-link">instance</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the standard operator table, creating it if necessary.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#like(boolean,boolean)" class="member-name-link">like</a><wbr>(boolean&nbsp;negated,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the operator for <code>LIKE</code> with given case-sensitivity,
 optionally negated.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#reverse(org.apache.calcite.sql.SqlOperator)" class="member-name-link">reverse</a><wbr>(<a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../SqlOperator.html#reverse()"><code>SqlOperator.reverse()</code></a>, but beware that it has
 slightly different semantics</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#some(org.apache.calcite.sql.SqlKind)" class="member-name-link">some</a><wbr>(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;comparisonKind)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the operator for <code>SOME comparisonKind</code>.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.calcite.sql.util.ReflectiveSqlOperatorTable">Methods inherited from class&nbsp;org.apache.calcite.sql.util.<a href="../util/ReflectiveSqlOperatorTable.html" title="class in org.apache.calcite.sql.util">ReflectiveSqlOperatorTable</a></h3>
<code><a href="../util/ReflectiveSqlOperatorTable.html#getOperatorList()">getOperatorList</a>, <a href="../util/ReflectiveSqlOperatorTable.html#init()">init</a>, <a href="../util/ReflectiveSqlOperatorTable.html#lookupOperatorOverloads(org.apache.calcite.sql.SqlIdentifier,org.apache.calcite.sql.SqlFunctionCategory,org.apache.calcite.sql.SqlSyntax,java.util.List,org.apache.calcite.sql.validate.SqlNameMatcher)">lookupOperatorOverloads</a>, <a href="../util/ReflectiveSqlOperatorTable.html#register(org.apache.calcite.sql.SqlOperator)">register</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="UNION">
<h3>UNION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">UNION</span></div>
</section>
</li>
<li>
<section class="detail" id="UNION_ALL">
<h3>UNION_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">UNION_ALL</span></div>
</section>
</li>
<li>
<section class="detail" id="EXCEPT">
<h3>EXCEPT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">EXCEPT</span></div>
</section>
</li>
<li>
<section class="detail" id="EXCEPT_ALL">
<h3>EXCEPT_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">EXCEPT_ALL</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERSECT">
<h3>INTERSECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">INTERSECT</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERSECT_ALL">
<h3>INTERSECT_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSetOperator.html" title="class in org.apache.calcite.sql">SqlSetOperator</a></span>&nbsp;<span class="element-name">INTERSECT_ALL</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_UNION_DISTINCT">
<h3>MULTISET_UNION_DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_UNION_DISTINCT</span></div>
<div class="block">The <code>MULTISET UNION DISTINCT</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_UNION">
<h3>MULTISET_UNION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_UNION</span></div>
<div class="block">The <code>MULTISET UNION [ALL]</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_EXCEPT_DISTINCT">
<h3>MULTISET_EXCEPT_DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_EXCEPT_DISTINCT</span></div>
<div class="block">The <code>MULTISET EXCEPT DISTINCT</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_EXCEPT">
<h3>MULTISET_EXCEPT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_EXCEPT</span></div>
<div class="block">The <code>MULTISET EXCEPT [ALL]</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_INTERSECT_DISTINCT">
<h3>MULTISET_INTERSECT_DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_INTERSECT_DISTINCT</span></div>
<div class="block">The <code>MULTISET INTERSECT DISTINCT</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_INTERSECT">
<h3>MULTISET_INTERSECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetSetOperator.html" title="class in org.apache.calcite.sql.fun">SqlMultisetSetOperator</a></span>&nbsp;<span class="element-name">MULTISET_INTERSECT</span></div>
<div class="block">The <code>MULTISET INTERSECT [ALL]</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="AND">
<h3>AND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">AND</span></div>
<div class="block">Logical <code>AND</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="AS">
<h3>AS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAsOperator.html" title="class in org.apache.calcite.sql">SqlAsOperator</a></span>&nbsp;<span class="element-name">AS</span></div>
<div class="block"><code>AS</code> operator associates an expression in the SELECT clause
 with an alias.</div>
</section>
</li>
<li>
<section class="detail" id="ARGUMENT_ASSIGNMENT">
<h3>ARGUMENT_ASSIGNMENT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">ARGUMENT_ASSIGNMENT</span></div>
<div class="block"><code>ARGUMENT_ASSIGNMENT</code> operator (<code>=&lt;</code>)
 assigns an argument to a function call to a particular named parameter.</div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT">
<h3>DEFAULT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">DEFAULT</span></div>
<div class="block"><code>DEFAULT</code> operator indicates that an argument to a function call
 is to take its default value..</div>
</section>
</li>
<li>
<section class="detail" id="FILTER">
<h3>FILTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFilterOperator.html" title="class in org.apache.calcite.sql">SqlFilterOperator</a></span>&nbsp;<span class="element-name">FILTER</span></div>
<div class="block"><code>FILTER</code> operator filters which rows are included in an
  aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="WITHIN_GROUP">
<h3>WITHIN_GROUP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlWithinGroupOperator.html" title="class in org.apache.calcite.sql">SqlWithinGroupOperator</a></span>&nbsp;<span class="element-name">WITHIN_GROUP</span></div>
<div class="block"><code>WITHIN_GROUP</code> operator performs aggregations on ordered data input.</div>
</section>
</li>
<li>
<section class="detail" id="WITHIN_DISTINCT">
<h3>WITHIN_DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlWithinDistinctOperator.html" title="class in org.apache.calcite.sql">SqlWithinDistinctOperator</a></span>&nbsp;<span class="element-name">WITHIN_DISTINCT</span></div>
<div class="block"><code>WITHIN_DISTINCT</code> operator performs aggregations on distinct
 data input.</div>
</section>
</li>
<li>
<section class="detail" id="CUBE">
<h3>CUBE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">CUBE</span></div>
<div class="block"><code>CUBE</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ROLLUP">
<h3>ROLLUP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">ROLLUP</span></div>
<div class="block"><code>ROLLUP</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</section>
</li>
<li>
<section class="detail" id="GROUPING_SETS">
<h3>GROUPING_SETS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">GROUPING_SETS</span></div>
<div class="block"><code>GROUPING SETS</code> operator, occurs within <code>GROUP BY</code> clause
 or nested within a <code>GROUPING SETS</code>.</div>
</section>
</li>
<li>
<section class="detail" id="GROUPING">
<h3>GROUPING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">GROUPING</span></div>
<div class="block"><code>GROUPING(c1 [, c2, ...])</code> function.

 <p>Occurs in similar places to an aggregate
 function (<code>SELECT</code>, <code>HAVING</code> clause, etc. of an aggregate
 query), but not technically an aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="GROUP_ID">
<h3>GROUP_ID</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">GROUP_ID</span></div>
<div class="block"><code>GROUP_ID()</code> function. (Oracle-specific.)</div>
</section>
</li>
<li>
<section class="detail" id="GROUPING_ID">
<h3>GROUPING_ID</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">GROUPING_ID</span></div>
<div class="block"><code>GROUPING_ID</code> function is a synonym for <code>GROUPING</code>.

 <p>Some history. The <code>GROUPING</code> function is in the SQL standard,
 and originally supported only one argument. <code>GROUPING_ID</code> is not
 standard (though supported in Oracle and SQL Server) and supports one or
 more arguments.

 <p>The SQL standard has changed to allow <code>GROUPING</code> to have multiple
 arguments. It is now equivalent to <code>GROUPING_ID</code>, so we made
 <code>GROUPING_ID</code> a synonym for <code>GROUPING</code>.</div>
</section>
</li>
<li>
<section class="detail" id="EXTEND">
<h3>EXTEND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">EXTEND</span></div>
<div class="block"><code>EXTEND</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="CONCAT">
<h3>CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">CONCAT</span></div>
<div class="block">String and array-to-array concatenation operator, '<code>||</code>'.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="SqlLibraryOperators.html#CONCAT_FUNCTION"><code>SqlLibraryOperators.CONCAT_FUNCTION</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DIVIDE">
<h3>DIVIDE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">DIVIDE</span></div>
<div class="block">Arithmetic division operator, '<code>/</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="PERCENT_REMAINDER">
<h3>PERCENT_REMAINDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">PERCENT_REMAINDER</span></div>
<div class="block">Arithmetic remainder operator, '<code>%</code>',
 an alternative to <a href="#MOD"><code>MOD</code></a> allowed if under certain conformance levels.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../validate/SqlConformance.html#isPercentRemainderAllowed()"><code>SqlConformance.isPercentRemainderAllowed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="RAND_INTEGER">
<h3>RAND_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlRandIntegerFunction.html" title="class in org.apache.calcite.sql.fun">SqlRandIntegerFunction</a></span>&nbsp;<span class="element-name">RAND_INTEGER</span></div>
<div class="block">The <code>RAND_INTEGER([seed, ] bound)</code> function, which yields a random
 integer, optionally with seed.</div>
</section>
</li>
<li>
<section class="detail" id="RAND">
<h3>RAND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlRandFunction.html" title="class in org.apache.calcite.sql.fun">SqlRandFunction</a></span>&nbsp;<span class="element-name">RAND</span></div>
<div class="block">The <code>RAND([seed])</code> function, which yields a random double,
 optionally with seed.</div>
</section>
</li>
<li>
<section class="detail" id="DIVIDE_INTEGER">
<h3>DIVIDE_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">DIVIDE_INTEGER</span></div>
<div class="block">Internal integer arithmetic division operator, '<code>/INT</code>'. 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.</div>
</section>
</li>
<li>
<section class="detail" id="DOT">
<h3>DOT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">DOT</span></div>
<div class="block">Dot operator, '<code>.</code>', used for referencing fields of records.</div>
</section>
</li>
<li>
<section class="detail" id="EQUALS">
<h3>EQUALS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">EQUALS</span></div>
<div class="block">Logical equals operator, '<code>=</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="GREATER_THAN">
<h3>GREATER_THAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">GREATER_THAN</span></div>
<div class="block">Logical greater-than operator, '<code>&gt;</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="IS_DISTINCT_FROM">
<h3>IS_DISTINCT_FROM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">IS_DISTINCT_FROM</span></div>
<div class="block"><code>IS DISTINCT FROM</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_DISTINCT_FROM">
<h3>IS_NOT_DISTINCT_FROM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">IS_NOT_DISTINCT_FROM</span></div>
<div class="block"><code>IS NOT DISTINCT FROM</code> operator. Is equivalent to <code>NOT(x
 IS DISTINCT FROM y)</code></div>
</section>
</li>
<li>
<section class="detail" id="IS_DIFFERENT_FROM">
<h3>IS_DIFFERENT_FROM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">IS_DIFFERENT_FROM</span></div>
<div class="block">The internal <code>$IS_DIFFERENT_FROM</code> operator is the same as the
 user-level <a href="#IS_DISTINCT_FROM"><code>IS_DISTINCT_FROM</code></a> in all respects except that
 the test for equality on character datatypes treats trailing spaces as
 significant.</div>
</section>
</li>
<li>
<section class="detail" id="GREATER_THAN_OR_EQUAL">
<h3>GREATER_THAN_OR_EQUAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">GREATER_THAN_OR_EQUAL</span></div>
<div class="block">Logical greater-than-or-equal operator, '<code>&gt;=</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="IN">
<h3>IN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">IN</span></div>
<div class="block"><code>IN</code> operator tests for a value's membership in a sub-query or
 a list of values.</div>
</section>
</li>
<li>
<section class="detail" id="NOT_IN">
<h3>NOT_IN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">NOT_IN</span></div>
<div class="block"><code>NOT IN</code> operator tests for a value's membership in a sub-query
 or a list of values.</div>
</section>
</li>
<li>
<section class="detail" id="SEARCH">
<h3>SEARCH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">SEARCH</span></div>
<div class="block">Operator that tests whether its left operand is included in the range of
 values covered by search arguments.</div>
</section>
</li>
<li>
<section class="detail" id="SOME_LT">
<h3>SOME_LT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_LT</span></div>
<div class="block">The <code>&lt; SOME</code> operator (synonymous with
 <code>&lt; ANY</code>).</div>
</section>
</li>
<li>
<section class="detail" id="SOME_LE">
<h3>SOME_LE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_LE</span></div>
</section>
</li>
<li>
<section class="detail" id="SOME_GT">
<h3>SOME_GT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_GT</span></div>
</section>
</li>
<li>
<section class="detail" id="SOME_GE">
<h3>SOME_GE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_GE</span></div>
</section>
</li>
<li>
<section class="detail" id="SOME_EQ">
<h3>SOME_EQ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_EQ</span></div>
</section>
</li>
<li>
<section class="detail" id="SOME_NE">
<h3>SOME_NE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">SOME_NE</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_LT">
<h3>ALL_LT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_LT</span></div>
<div class="block">The <code>&lt; ALL</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="ALL_LE">
<h3>ALL_LE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_LE</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_GT">
<h3>ALL_GT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_GT</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_GE">
<h3>ALL_GE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_GE</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_EQ">
<h3>ALL_EQ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_EQ</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_NE">
<h3>ALL_NE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">ALL_NE</span></div>
</section>
</li>
<li>
<section class="detail" id="LESS_THAN">
<h3>LESS_THAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">LESS_THAN</span></div>
<div class="block">Logical less-than operator, '<code>&lt;</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="LESS_THAN_OR_EQUAL">
<h3>LESS_THAN_OR_EQUAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">LESS_THAN_OR_EQUAL</span></div>
<div class="block">Logical less-than-or-equal operator, '<code>&lt;=</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="MINUS">
<h3>MINUS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">MINUS</span></div>
<div class="block">Infix arithmetic minus operator, '<code>-</code>'.

 <p>Its precedence is less than the prefix <a href="#UNARY_PLUS"><code>+</code></a>
 and <a href="#UNARY_MINUS"><code>-</code></a> operators.</div>
</section>
</li>
<li>
<section class="detail" id="MULTIPLY">
<h3>MULTIPLY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">MULTIPLY</span></div>
<div class="block">Arithmetic multiplication operator, '<code>*</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="NOT_EQUALS">
<h3>NOT_EQUALS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">NOT_EQUALS</span></div>
<div class="block">Logical not-equals operator, '<code>&lt;&gt;</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="OR">
<h3>OR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">OR</span></div>
<div class="block">Logical <code>OR</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="PLUS">
<h3>PLUS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">PLUS</span></div>
<div class="block">Infix arithmetic plus operator, '<code>+</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="DATETIME_PLUS">
<h3>DATETIME_PLUS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">DATETIME_PLUS</span></div>
<div class="block">Infix datetime plus operator, '<code>DATETIME + INTERVAL</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL">
<h3>INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">INTERVAL</span></div>
<div class="block">Interval expression, '<code>INTERVAL n timeUnit</code>'.</div>
</section>
</li>
<li>
<section class="detail" id="MEMBER_OF">
<h3>MEMBER_OF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">MEMBER_OF</span></div>
<div class="block">Multiset <code>MEMBER OF</code>, which returns whether a element belongs to a
 multiset.

 <p>For example, the following returns <code>false</code>:

 <blockquote>
 <code>'green' MEMBER OF MULTISET ['red','almost green','blue']</code>
 </blockquote></div>
</section>
</li>
<li>
<section class="detail" id="SUBMULTISET_OF">
<h3>SUBMULTISET_OF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">SUBMULTISET_OF</span></div>
<div class="block">Submultiset. Checks to see if an multiset is a sub-set of another
 multiset.

 <p>For example, the following returns <code>false</code>:

 <blockquote>
 <code>MULTISET ['green'] SUBMULTISET OF
 MULTISET['red', 'almost green', 'blue']</code>
 </blockquote>

 <p>The following returns <code>true</code>, in part because multisets are
 order-independent:

 <blockquote>
 <code>MULTISET ['blue', 'red'] SUBMULTISET OF
 MULTISET ['red', 'almost green', 'blue']</code>
 </blockquote></div>
</section>
</li>
<li>
<section class="detail" id="NOT_SUBMULTISET_OF">
<h3>NOT_SUBMULTISET_OF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">NOT_SUBMULTISET_OF</span></div>
</section>
</li>
<li>
<section class="detail" id="DESC">
<h3>DESC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">DESC</span></div>
</section>
</li>
<li>
<section class="detail" id="NULLS_FIRST">
<h3>NULLS_FIRST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">NULLS_FIRST</span></div>
</section>
</li>
<li>
<section class="detail" id="NULLS_LAST">
<h3>NULLS_LAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">NULLS_LAST</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_NULL">
<h3>IS_NOT_NULL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_NULL</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NULL">
<h3>IS_NULL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NULL</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_TRUE">
<h3>IS_NOT_TRUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_TRUE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_TRUE">
<h3>IS_TRUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_TRUE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_FALSE">
<h3>IS_NOT_FALSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_FALSE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_FALSE">
<h3>IS_FALSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_FALSE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_UNKNOWN">
<h3>IS_NOT_UNKNOWN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_UNKNOWN</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_UNKNOWN">
<h3>IS_UNKNOWN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_UNKNOWN</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_A_SET">
<h3>IS_A_SET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_A_SET</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_A_SET">
<h3>IS_NOT_A_SET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_A_SET</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_EMPTY">
<h3>IS_EMPTY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_EMPTY</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_EMPTY">
<h3>IS_NOT_EMPTY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_EMPTY</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_JSON_VALUE">
<h3>IS_JSON_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_JSON_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_JSON_VALUE">
<h3>IS_NOT_JSON_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_JSON_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_JSON_OBJECT">
<h3>IS_JSON_OBJECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_JSON_OBJECT</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_JSON_OBJECT">
<h3>IS_NOT_JSON_OBJECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_JSON_OBJECT</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_JSON_ARRAY">
<h3>IS_JSON_ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_JSON_ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_JSON_ARRAY">
<h3>IS_NOT_JSON_ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_JSON_ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_JSON_SCALAR">
<h3>IS_JSON_SCALAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_JSON_SCALAR</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_NOT_JSON_SCALAR">
<h3>IS_NOT_JSON_SCALAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">IS_NOT_JSON_SCALAR</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_VALUE_EXPRESSION">
<h3>JSON_VALUE_EXPRESSION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPostfixOperator.html" title="class in org.apache.calcite.sql">SqlPostfixOperator</a></span>&nbsp;<span class="element-name">JSON_VALUE_EXPRESSION</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_TYPE_OPERATOR">
<h3>JSON_TYPE_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">org.apache.calcite.sql.fun.SqlJsonTypeOperator</span>&nbsp;<span class="element-name">JSON_TYPE_OPERATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="EXISTS">
<h3>EXISTS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">EXISTS</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIQUE">
<h3>UNIQUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">UNIQUE</span></div>
</section>
</li>
<li>
<section class="detail" id="NOT">
<h3>NOT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">NOT</span></div>
</section>
</li>
<li>
<section class="detail" id="UNARY_MINUS">
<h3>UNARY_MINUS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">UNARY_MINUS</span></div>
<div class="block">Prefix arithmetic minus operator, '<code>-</code>'.

 <p>Its precedence is greater than the infix '<a href="#PLUS"><code>+</code></a>' and
 '<a href="#MINUS"><code>-</code></a>' operators.</div>
</section>
</li>
<li>
<section class="detail" id="UNARY_PLUS">
<h3>UNARY_PLUS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">UNARY_PLUS</span></div>
<div class="block">Prefix arithmetic plus operator, '<code>+</code>'.

 <p>Its precedence is greater than the infix '<a href="#PLUS"><code>+</code></a>' and
 '<a href="#MINUS"><code>-</code></a>' operators.</div>
</section>
</li>
<li>
<section class="detail" id="EXPLICIT_TABLE">
<h3>EXPLICIT_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">EXPLICIT_TABLE</span></div>
<div class="block">Keyword which allows an identifier to be explicitly flagged as a table.
 For example, <code>select * from (TABLE t)</code> or <code>TABLE
 t</code>. See also <a href="#COLLECTION_TABLE"><code>COLLECTION_TABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="FINAL">
<h3>FINAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">FINAL</span></div>
<div class="block"><code>FINAL</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="RUNNING">
<h3>RUNNING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlPrefixOperator.html" title="class in org.apache.calcite.sql">SqlPrefixOperator</a></span>&nbsp;<span class="element-name">RUNNING</span></div>
<div class="block"><code>RUNNING</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="SUM">
<h3>SUM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">SUM</span></div>
<div class="block"><code>SUM</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="COUNT">
<h3>COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">COUNT</span></div>
<div class="block"><code>COUNT</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="MODE">
<h3>MODE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">MODE</span></div>
<div class="block"><code>MODE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="APPROX_COUNT_DISTINCT">
<h3>APPROX_COUNT_DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">APPROX_COUNT_DISTINCT</span></div>
<div class="block"><code>APPROX_COUNT_DISTINCT</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="MIN">
<h3>MIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">MIN</span></div>
<div class="block"><code>MIN</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="MAX">
<h3>MAX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">MAX</span></div>
<div class="block"><code>MAX</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="EVERY">
<h3>EVERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">EVERY</span></div>
<div class="block"><code>EVERY</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="SOME">
<h3>SOME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">SOME</span></div>
<div class="block"><code>SOME</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="LAST_VALUE">
<h3>LAST_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LAST_VALUE</span></div>
<div class="block"><code>LAST_VALUE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="ANY_VALUE">
<h3>ANY_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">ANY_VALUE</span></div>
<div class="block"><code>ANY_VALUE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="FIRST_VALUE">
<h3>FIRST_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">FIRST_VALUE</span></div>
<div class="block"><code>FIRST_VALUE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="NTH_VALUE">
<h3>NTH_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">NTH_VALUE</span></div>
<div class="block"><code>NTH_VALUE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="LEAD">
<h3>LEAD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LEAD</span></div>
<div class="block"><code>LEAD</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="LAG">
<h3>LAG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LAG</span></div>
<div class="block"><code>LAG</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="NTILE">
<h3>NTILE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">NTILE</span></div>
<div class="block"><code>NTILE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="SINGLE_VALUE">
<h3>SINGLE_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">SINGLE_VALUE</span></div>
<div class="block"><code>SINGLE_VALUE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="AVG">
<h3>AVG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">AVG</span></div>
<div class="block"><code>AVG</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="STDDEV_POP">
<h3>STDDEV_POP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">STDDEV_POP</span></div>
<div class="block"><code>STDDEV_POP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="REGR_COUNT">
<h3>REGR_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">REGR_COUNT</span></div>
<div class="block"><code>REGR_COUNT</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="REGR_SXX">
<h3>REGR_SXX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">REGR_SXX</span></div>
<div class="block"><code>REGR_SXX</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="REGR_SYY">
<h3>REGR_SYY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">REGR_SYY</span></div>
<div class="block"><code>REGR_SYY</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="COVAR_POP">
<h3>COVAR_POP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">COVAR_POP</span></div>
<div class="block"><code>COVAR_POP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="COVAR_SAMP">
<h3>COVAR_SAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">COVAR_SAMP</span></div>
<div class="block"><code>COVAR_SAMP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="STDDEV_SAMP">
<h3>STDDEV_SAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">STDDEV_SAMP</span></div>
<div class="block"><code>STDDEV_SAMP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="STDDEV">
<h3>STDDEV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">STDDEV</span></div>
<div class="block"><code>STDDEV</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="VAR_POP">
<h3>VAR_POP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">VAR_POP</span></div>
<div class="block"><code>VAR_POP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="VAR_SAMP">
<h3>VAR_SAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">VAR_SAMP</span></div>
<div class="block"><code>VAR_SAMP</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="VARIANCE">
<h3>VARIANCE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">VARIANCE</span></div>
<div class="block"><code>VARIANCE</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="BIT_AND">
<h3>BIT_AND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">BIT_AND</span></div>
<div class="block"><code>BIT_AND</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="BIT_OR">
<h3>BIT_OR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">BIT_OR</span></div>
<div class="block"><code>BIT_OR</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="BIT_XOR">
<h3>BIT_XOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">BIT_XOR</span></div>
<div class="block"><code>BIT_XOR</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM_AGG">
<h3>HISTOGRAM_AGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">HISTOGRAM_AGG</span></div>
<div class="block"><code>HISTOGRAM</code> aggregate function support. Used by window
 aggregate versions of MIN/MAX</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM_MIN">
<h3>HISTOGRAM_MIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">HISTOGRAM_MIN</span></div>
<div class="block"><code>HISTOGRAM_MIN</code> window aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM_MAX">
<h3>HISTOGRAM_MAX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">HISTOGRAM_MAX</span></div>
<div class="block"><code>HISTOGRAM_MAX</code> window aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM_FIRST_VALUE">
<h3>HISTOGRAM_FIRST_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">HISTOGRAM_FIRST_VALUE</span></div>
<div class="block"><code>HISTOGRAM_FIRST_VALUE</code> window aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM_LAST_VALUE">
<h3>HISTOGRAM_LAST_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">HISTOGRAM_LAST_VALUE</span></div>
<div class="block"><code>HISTOGRAM_LAST_VALUE</code> window aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="SUM0">
<h3>SUM0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">SUM0</span></div>
<div class="block"><code>SUM0</code> aggregate function.</div>
</section>
</li>
<li>
<section class="detail" id="CUME_DIST">
<h3>CUME_DIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></span>&nbsp;<span class="element-name">CUME_DIST</span></div>
<div class="block"><code>CUME_DIST</code> window function.</div>
</section>
</li>
<li>
<section class="detail" id="DENSE_RANK">
<h3>DENSE_RANK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></span>&nbsp;<span class="element-name">DENSE_RANK</span></div>
<div class="block"><code>DENSE_RANK</code> window function.</div>
</section>
</li>
<li>
<section class="detail" id="PERCENT_RANK">
<h3>PERCENT_RANK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></span>&nbsp;<span class="element-name">PERCENT_RANK</span></div>
<div class="block"><code>PERCENT_RANK</code> window function.</div>
</section>
</li>
<li>
<section class="detail" id="RANK">
<h3>RANK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></span>&nbsp;<span class="element-name">RANK</span></div>
<div class="block"><code>RANK</code> window function.</div>
</section>
</li>
<li>
<section class="detail" id="ROW_NUMBER">
<h3>ROW_NUMBER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlRankFunction.html" title="class in org.apache.calcite.sql">SqlRankFunction</a></span>&nbsp;<span class="element-name">ROW_NUMBER</span></div>
<div class="block"><code>ROW_NUMBER</code> window function.</div>
</section>
</li>
<li>
<section class="detail" id="ROW">
<h3>ROW</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlRowOperator.html" title="class in org.apache.calcite.sql.fun">SqlRowOperator</a></span>&nbsp;<span class="element-name">ROW</span></div>
</section>
</li>
<li>
<section class="detail" id="IGNORE_NULLS">
<h3>IGNORE_NULLS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlNullTreatmentOperator.html" title="class in org.apache.calcite.sql">SqlNullTreatmentOperator</a></span>&nbsp;<span class="element-name">IGNORE_NULLS</span></div>
<div class="block"><code>IGNORE NULLS</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="RESPECT_NULLS">
<h3>RESPECT_NULLS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlNullTreatmentOperator.html" title="class in org.apache.calcite.sql">SqlNullTreatmentOperator</a></span>&nbsp;<span class="element-name">RESPECT_NULLS</span></div>
<div class="block"><code>RESPECT NULLS</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="MINUS_DATE">
<h3>MINUS_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatetimeSubtractionOperator.html" title="class in org.apache.calcite.sql.fun">SqlDatetimeSubtractionOperator</a></span>&nbsp;<span class="element-name">MINUS_DATE</span></div>
<div class="block">A special operator for the subtraction of two DATETIMEs. The format of
 DATETIME subtraction is:

 <blockquote><code>"(" &lt;datetime&gt; "-" &lt;datetime&gt; ")"
 &lt;interval qualifier&gt;</code></blockquote>

 <p>This operator is special since it needs to hold the
 additional interval qualifier specification.</p></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_VALUE">
<h3>MULTISET_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetValueConstructor</a></span>&nbsp;<span class="element-name">MULTISET_VALUE</span></div>
<div class="block">The MULTISET Value Constructor. e.g. "<code>MULTISET[1,2,3]</code>".</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_QUERY">
<h3>MULTISET_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></span>&nbsp;<span class="element-name">MULTISET_QUERY</span></div>
<div class="block">The MULTISET Query Constructor. e.g. "<code>SELECT dname, MULTISET(SELECT
 FROM emp WHERE deptno = dept.deptno) FROM dept</code>".</div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_QUERY">
<h3>ARRAY_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></span>&nbsp;<span class="element-name">ARRAY_QUERY</span></div>
<div class="block">The ARRAY Query Constructor. e.g. "<code>SELECT dname, ARRAY(SELECT
 FROM emp WHERE deptno = dept.deptno) FROM dept</code>".</div>
</section>
</li>
<li>
<section class="detail" id="MAP_QUERY">
<h3>MAP_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMultisetQueryConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMultisetQueryConstructor</a></span>&nbsp;<span class="element-name">MAP_QUERY</span></div>
<div class="block">The MAP Query Constructor. e.g. "<code>MAP(SELECT empno, deptno
 FROM emp)</code>".</div>
</section>
</li>
<li>
<section class="detail" id="CURSOR">
<h3>CURSOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlCursorConstructor.html" title="class in org.apache.calcite.sql.fun">SqlCursorConstructor</a></span>&nbsp;<span class="element-name">CURSOR</span></div>
<div class="block">The CURSOR constructor. e.g. "<code>SELECT * FROM
 TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), 'name'))</code>".</div>
</section>
</li>
<li>
<section class="detail" id="COLUMN_LIST">
<h3>COLUMN_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlColumnListConstructor.html" title="class in org.apache.calcite.sql.fun">SqlColumnListConstructor</a></span>&nbsp;<span class="element-name">COLUMN_LIST</span></div>
<div class="block">The COLUMN_LIST constructor. e.g. the ROW() call in "<code>SELECT * FROM
 TABLE(DEDUP(CURSOR(SELECT * FROM EMPS), ROW(name, empno)))</code>".</div>
</section>
</li>
<li>
<section class="detail" id="UNNEST">
<h3>UNNEST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlUnnestOperator.html" title="class in org.apache.calcite.sql">SqlUnnestOperator</a></span>&nbsp;<span class="element-name">UNNEST</span></div>
<div class="block">The <code>UNNEST</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="UNNEST_WITH_ORDINALITY">
<h3>UNNEST_WITH_ORDINALITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlUnnestOperator.html" title="class in org.apache.calcite.sql">SqlUnnestOperator</a></span>&nbsp;<span class="element-name">UNNEST_WITH_ORDINALITY</span></div>
<div class="block">The <code>UNNEST WITH ORDINALITY</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="LATERAL">
<h3>LATERAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">LATERAL</span></div>
<div class="block">The <code>LATERAL</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_TABLE">
<h3>COLLECTION_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">COLLECTION_TABLE</span></div>
<div class="block">The "table function derived table" operator, which a table-valued
 function into a relation, e.g. "<code>SELECT * FROM
 TABLE(ramp(5))</code>".

 <p>This operator has function syntax (with one argument), whereas
 <a href="#EXPLICIT_TABLE"><code>EXPLICIT_TABLE</code></a> is a prefix operator.</div>
</section>
</li>
<li>
<section class="detail" id="OVERLAPS">
<h3>OVERLAPS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">OVERLAPS</span></div>
</section>
</li>
<li>
<section class="detail" id="CONTAINS">
<h3>CONTAINS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">CONTAINS</span></div>
</section>
</li>
<li>
<section class="detail" id="PRECEDES">
<h3>PRECEDES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">PRECEDES</span></div>
</section>
</li>
<li>
<section class="detail" id="IMMEDIATELY_PRECEDES">
<h3>IMMEDIATELY_PRECEDES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">IMMEDIATELY_PRECEDES</span></div>
</section>
</li>
<li>
<section class="detail" id="SUCCEEDS">
<h3>SUCCEEDS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">SUCCEEDS</span></div>
</section>
</li>
<li>
<section class="detail" id="IMMEDIATELY_SUCCEEDS">
<h3>IMMEDIATELY_SUCCEEDS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">IMMEDIATELY_SUCCEEDS</span></div>
</section>
</li>
<li>
<section class="detail" id="PERIOD_EQUALS">
<h3>PERIOD_EQUALS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOverlapsOperator.html" title="class in org.apache.calcite.sql.fun">SqlOverlapsOperator</a></span>&nbsp;<span class="element-name">PERIOD_EQUALS</span></div>
</section>
</li>
<li>
<section class="detail" id="VALUES">
<h3>VALUES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">VALUES</span></div>
</section>
</li>
<li>
<section class="detail" id="LITERAL_CHAIN">
<h3>LITERAL_CHAIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlLiteralChainOperator.html" title="class in org.apache.calcite.sql.fun">SqlLiteralChainOperator</a></span>&nbsp;<span class="element-name">LITERAL_CHAIN</span></div>
</section>
</li>
<li>
<section class="detail" id="THROW">
<h3>THROW</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlThrowOperator.html" title="class in org.apache.calcite.sql.fun">SqlThrowOperator</a></span>&nbsp;<span class="element-name">THROW</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_EXISTS">
<h3>JSON_EXISTS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_EXISTS</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_VALUE">
<h3>JSON_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_QUERY">
<h3>JSON_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_QUERY</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_OBJECT">
<h3>JSON_OBJECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_OBJECT</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_OBJECTAGG">
<h3>JSON_OBJECTAGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlJsonObjectAggAggFunction.html" title="class in org.apache.calcite.sql.fun">SqlJsonObjectAggAggFunction</a></span>&nbsp;<span class="element-name">JSON_OBJECTAGG</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_ARRAY">
<h3>JSON_ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_TYPE">
<h3>JSON_TYPE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_TYPE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_DEPTH">
<h3>JSON_DEPTH</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_DEPTH</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_LENGTH">
<h3>JSON_LENGTH</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_LENGTH</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_KEYS">
<h3>JSON_KEYS</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_KEYS</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_PRETTY">
<h3>JSON_PRETTY</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_PRETTY</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_REMOVE">
<h3>JSON_REMOVE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_REMOVE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_STORAGE_SIZE">
<h3>JSON_STORAGE_SIZE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_STORAGE_SIZE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_ARRAYAGG">
<h3>JSON_ARRAYAGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlJsonArrayAggAggFunction.html" title="class in org.apache.calcite.sql.fun">SqlJsonArrayAggAggFunction</a></span>&nbsp;<span class="element-name">JSON_ARRAYAGG</span></div>
</section>
</li>
<li>
<section class="detail" id="BETWEEN">
<h3>BETWEEN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></span>&nbsp;<span class="element-name">BETWEEN</span></div>
</section>
</li>
<li>
<section class="detail" id="SYMMETRIC_BETWEEN">
<h3>SYMMETRIC_BETWEEN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></span>&nbsp;<span class="element-name">SYMMETRIC_BETWEEN</span></div>
</section>
</li>
<li>
<section class="detail" id="NOT_BETWEEN">
<h3>NOT_BETWEEN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></span>&nbsp;<span class="element-name">NOT_BETWEEN</span></div>
</section>
</li>
<li>
<section class="detail" id="SYMMETRIC_NOT_BETWEEN">
<h3>SYMMETRIC_NOT_BETWEEN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlBetweenOperator.html" title="class in org.apache.calcite.sql.fun">SqlBetweenOperator</a></span>&nbsp;<span class="element-name">SYMMETRIC_NOT_BETWEEN</span></div>
</section>
</li>
<li>
<section class="detail" id="NOT_LIKE">
<h3>NOT_LIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">NOT_LIKE</span></div>
</section>
</li>
<li>
<section class="detail" id="LIKE">
<h3>LIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">LIKE</span></div>
</section>
</li>
<li>
<section class="detail" id="NOT_SIMILAR_TO">
<h3>NOT_SIMILAR_TO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">NOT_SIMILAR_TO</span></div>
</section>
</li>
<li>
<section class="detail" id="SIMILAR_TO">
<h3>SIMILAR_TO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">SIMILAR_TO</span></div>
</section>
</li>
<li>
<section class="detail" id="POSIX_REGEX_CASE_SENSITIVE">
<h3>POSIX_REGEX_CASE_SENSITIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">POSIX_REGEX_CASE_SENSITIVE</span></div>
</section>
</li>
<li>
<section class="detail" id="POSIX_REGEX_CASE_INSENSITIVE">
<h3>POSIX_REGEX_CASE_INSENSITIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">POSIX_REGEX_CASE_INSENSITIVE</span></div>
</section>
</li>
<li>
<section class="detail" id="NEGATED_POSIX_REGEX_CASE_SENSITIVE">
<h3>NEGATED_POSIX_REGEX_CASE_SENSITIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">NEGATED_POSIX_REGEX_CASE_SENSITIVE</span></div>
</section>
</li>
<li>
<section class="detail" id="NEGATED_POSIX_REGEX_CASE_INSENSITIVE">
<h3>NEGATED_POSIX_REGEX_CASE_INSENSITIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">NEGATED_POSIX_REGEX_CASE_INSENSITIVE</span></div>
</section>
</li>
<li>
<section class="detail" id="ESCAPE">
<h3>ESCAPE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">ESCAPE</span></div>
<div class="block">Internal operator used to represent the ESCAPE clause of a LIKE or
 SIMILAR TO expression.</div>
</section>
</li>
<li>
<section class="detail" id="CASE">
<h3>CASE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlCaseOperator.html" title="class in org.apache.calcite.sql.fun">SqlCaseOperator</a></span>&nbsp;<span class="element-name">CASE</span></div>
</section>
</li>
<li>
<section class="detail" id="PROCEDURE_CALL">
<h3>PROCEDURE_CALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">PROCEDURE_CALL</span></div>
</section>
</li>
<li>
<section class="detail" id="NEW">
<h3>NEW</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">NEW</span></div>
</section>
</li>
<li>
<section class="detail" id="OVER">
<h3>OVER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">OVER</span></div>
<div class="block">The <code>OVER</code> operator, which applies an aggregate functions to a
 <a href="../SqlWindow.html" title="class in org.apache.calcite.sql"><code>window</code></a>.

 <p>Operands are as follows:

 <ol>
 <li>name of window function (<a href="../SqlCall.html" title="class in org.apache.calcite.sql"><code>SqlCall</code></a>)</li>
 <li>window name (<a href="../SqlLiteral.html" title="class in org.apache.calcite.sql"><code>SqlLiteral</code></a>) or window
 in-line specification (<code>org.apache.calcite.sql.SqlWindow.SqlWindowOperator</code>)</li>
 </ol></div>
</section>
</li>
<li>
<section class="detail" id="REINTERPRET">
<h3>REINTERPRET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">REINTERPRET</span></div>
<div class="block">An <code>REINTERPRET</code> 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 <i>any</i> second operand, whether
 true or not.</div>
</section>
</li>
<li>
<section class="detail" id="SUBSTRING">
<h3>SUBSTRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SUBSTRING</span></div>
<div class="block">The character substring function: <code>SUBSTRING(string FROM start [FOR
 length])</code>.

 <p>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.</div>
</section>
</li>
<li>
<section class="detail" id="REPLACE">
<h3>REPLACE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">REPLACE</span></div>
<div class="block">The <code>REPLACE(string, search, replace)</code> function. Not standard SQL,
 but in Oracle and Postgres.</div>
</section>
</li>
<li>
<section class="detail" id="CONVERT">
<h3>CONVERT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CONVERT</span></div>
</section>
</li>
<li>
<section class="detail" id="TRANSLATE">
<h3>TRANSLATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TRANSLATE</span></div>
<div class="block">The <code>TRANSLATE(<i>char_value</i> USING <i>translation_name</i>)</code> function
 alters the character set of a string value from one base character set to another.

 <p>It is defined in the SQL standard. See also the non-standard
 <a href="SqlLibraryOperators.html#TRANSLATE3"><code>SqlLibraryOperators.TRANSLATE3</code></a>, which has a different purpose.</div>
</section>
</li>
<li>
<section class="detail" id="OVERLAY">
<h3>OVERLAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">OVERLAY</span></div>
</section>
</li>
<li>
<section class="detail" id="TRIM">
<h3>TRIM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TRIM</span></div>
<div class="block">The "TRIM" function.</div>
</section>
</li>
<li>
<section class="detail" id="POSITION">
<h3>POSITION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">POSITION</span></div>
</section>
</li>
<li>
<section class="detail" id="CHAR_LENGTH">
<h3>CHAR_LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CHAR_LENGTH</span></div>
</section>
</li>
<li>
<section class="detail" id="CHARACTER_LENGTH">
<h3>CHARACTER_LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CHARACTER_LENGTH</span></div>
<div class="block">Alias for <a href="#CHAR_LENGTH"><code>CHAR_LENGTH</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="OCTET_LENGTH">
<h3>OCTET_LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">OCTET_LENGTH</span></div>
</section>
</li>
<li>
<section class="detail" id="UPPER">
<h3>UPPER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">UPPER</span></div>
</section>
</li>
<li>
<section class="detail" id="LOWER">
<h3>LOWER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LOWER</span></div>
</section>
</li>
<li>
<section class="detail" id="INITCAP">
<h3>INITCAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">INITCAP</span></div>
</section>
</li>
<li>
<section class="detail" id="ASCII">
<h3>ASCII</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ASCII</span></div>
</section>
</li>
<li>
<section class="detail" id="POWER">
<h3>POWER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">POWER</span></div>
<div class="block">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.</div>
</section>
</li>
<li>
<section class="detail" id="SQRT">
<h3>SQRT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SQRT</span></div>
</section>
</li>
<li>
<section class="detail" id="MOD">
<h3>MOD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">MOD</span></div>
<div class="block">Arithmetic remainder function <code>MOD</code>.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#PERCENT_REMAINDER"><code>PERCENT_REMAINDER</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="LN">
<h3>LN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LN</span></div>
</section>
</li>
<li>
<section class="detail" id="LOG10">
<h3>LOG10</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LOG10</span></div>
</section>
</li>
<li>
<section class="detail" id="ABS">
<h3>ABS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ABS</span></div>
</section>
</li>
<li>
<section class="detail" id="ACOS">
<h3>ACOS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ACOS</span></div>
</section>
</li>
<li>
<section class="detail" id="ASIN">
<h3>ASIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ASIN</span></div>
</section>
</li>
<li>
<section class="detail" id="ATAN">
<h3>ATAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ATAN</span></div>
</section>
</li>
<li>
<section class="detail" id="ATAN2">
<h3>ATAN2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ATAN2</span></div>
</section>
</li>
<li>
<section class="detail" id="CBRT">
<h3>CBRT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CBRT</span></div>
</section>
</li>
<li>
<section class="detail" id="COS">
<h3>COS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">COS</span></div>
</section>
</li>
<li>
<section class="detail" id="COT">
<h3>COT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">COT</span></div>
</section>
</li>
<li>
<section class="detail" id="DEGREES">
<h3>DEGREES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DEGREES</span></div>
</section>
</li>
<li>
<section class="detail" id="EXP">
<h3>EXP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">EXP</span></div>
</section>
</li>
<li>
<section class="detail" id="RADIANS">
<h3>RADIANS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">RADIANS</span></div>
</section>
</li>
<li>
<section class="detail" id="ROUND">
<h3>ROUND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ROUND</span></div>
</section>
</li>
<li>
<section class="detail" id="SIGN">
<h3>SIGN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SIGN</span></div>
</section>
</li>
<li>
<section class="detail" id="SIN">
<h3>SIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SIN</span></div>
</section>
</li>
<li>
<section class="detail" id="TAN">
<h3>TAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TAN</span></div>
</section>
</li>
<li>
<section class="detail" id="TRUNCATE">
<h3>TRUNCATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TRUNCATE</span></div>
</section>
</li>
<li>
<section class="detail" id="PI">
<h3>PI</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">PI</span></div>
</section>
</li>
<li>
<section class="detail" id="FIRST">
<h3>FIRST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">FIRST</span></div>
<div class="block"><code>FIRST</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="LAST">
<h3>LAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></span>&nbsp;<span class="element-name">LAST</span></div>
<div class="block"><code>LAST</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PREV">
<h3>PREV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></span>&nbsp;<span class="element-name">PREV</span></div>
<div class="block"><code>PREV</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="NEXT">
<h3>NEXT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">NEXT</span></div>
<div class="block"><code>NEXT</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="CLASSIFIER">
<h3>CLASSIFIER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlMatchFunction.html" title="class in org.apache.calcite.sql">SqlMatchFunction</a></span>&nbsp;<span class="element-name">CLASSIFIER</span></div>
<div class="block"><code>CLASSIFIER</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="MATCH_NUMBER">
<h3>MATCH_NUMBER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">MATCH_NUMBER</span></div>
<div class="block"><code>MATCH_NUMBER</code> function to be used within <code>MATCH_RECOGNIZE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="NULLIF">
<h3>NULLIF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">NULLIF</span></div>
</section>
</li>
<li>
<section class="detail" id="COALESCE">
<h3>COALESCE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">COALESCE</span></div>
<div class="block">The COALESCE builtin function.</div>
</section>
</li>
<li>
<section class="detail" id="FLOOR">
<h3>FLOOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">FLOOR</span></div>
<div class="block">The <code>FLOOR</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CEIL">
<h3>CEIL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CEIL</span></div>
<div class="block">The <code>CEIL</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="USER">
<h3>USER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">USER</span></div>
<div class="block">The <code>USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_USER">
<h3>CURRENT_USER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_USER</span></div>
<div class="block">The <code>CURRENT_USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="SESSION_USER">
<h3>SESSION_USER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SESSION_USER</span></div>
<div class="block">The <code>SESSION_USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="SYSTEM_USER">
<h3>SYSTEM_USER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SYSTEM_USER</span></div>
<div class="block">The <code>SYSTEM_USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_PATH">
<h3>CURRENT_PATH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_PATH</span></div>
<div class="block">The <code>CURRENT_PATH</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_ROLE">
<h3>CURRENT_ROLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_ROLE</span></div>
<div class="block">The <code>CURRENT_ROLE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_CATALOG">
<h3>CURRENT_CATALOG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_CATALOG</span></div>
<div class="block">The <code>CURRENT_CATALOG</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_SCHEMA">
<h3>CURRENT_SCHEMA</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_SCHEMA</span></div>
<div class="block">The <code>CURRENT_SCHEMA</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="LOCALTIME">
<h3>LOCALTIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LOCALTIME</span></div>
<div class="block">The <code>LOCALTIME [(<i>precision</i>)]</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="LOCALTIMESTAMP">
<h3>LOCALTIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LOCALTIMESTAMP</span></div>
<div class="block">The <code>LOCALTIMESTAMP [(<i>precision</i>)]</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_TIME">
<h3>CURRENT_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_TIME</span></div>
<div class="block">The <code>CURRENT_TIME [(<i>precision</i>)]</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_TIMESTAMP">
<h3>CURRENT_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_TIMESTAMP</span></div>
<div class="block">The <code>CURRENT_TIMESTAMP [(<i>precision</i>)]</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_DATE">
<h3>CURRENT_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_DATE</span></div>
<div class="block">The <code>CURRENT_DATE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_ADD">
<h3>TIMESTAMP_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_ADD</span></div>
<div class="block">The <code>TIMESTAMPADD</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_DIFF">
<h3>TIMESTAMP_DIFF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_DIFF</span></div>
<div class="block">The <code>TIMESTAMPDIFF</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="IN_FENNEL">
<h3>IN_FENNEL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">IN_FENNEL</span></div>
<div class="block">Use of the <code>IN_FENNEL</code> operator forces the argument to be
 evaluated in Fennel. Otherwise acts as identity function.</div>
</section>
</li>
<li>
<section class="detail" id="CAST">
<h3>CAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CAST</span></div>
<div class="block">The SQL <code>CAST</code> operator.

 <p>The SQL syntax is

 <blockquote><code>CAST(<i>expression</i> AS <i>type</i>)</code>
 </blockquote>

 <p>When the CAST operator is applies as a <a href="../SqlCall.html" title="class in org.apache.calcite.sql"><code>SqlCall</code></a>, it has two
 arguments: the expression and the type. The type must not include a
 constraint, so <code>CAST(x AS INTEGER NOT NULL)</code>, for instance, is
 invalid.</p>

 <p>When the CAST operator is applied as a <code>RexCall</code>, the
 target type is simply stored as the return type, not an explicit operand.
 For example, the expression <code>CAST(1 + 2 AS DOUBLE)</code> will
 become a call to <code>CAST</code> with the expression <code>1 + 2</code>
 as its only operand.</p>

 <p>The <code>RexCall</code> form can also have a type which contains a
 <code>NOT NULL</code> constraint. When this expression is implemented, if
 the value is NULL, an exception will be thrown.</p></div>
</section>
</li>
<li>
<section class="detail" id="EXTRACT">
<h3>EXTRACT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">EXTRACT</span></div>
<div class="block">The SQL <code>EXTRACT</code> operator. Extracts a specified field value
 from a DATETIME or an INTERVAL. E.g.<br>
 <code>EXTRACT(HOUR FROM INTERVAL '364 23:59:59')</code> returns <code>
 23</code></div>
</section>
</li>
<li>
<section class="detail" id="YEAR">
<h3>YEAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">YEAR</span></div>
<div class="block">The SQL <code>YEAR</code> operator. Returns the Year
 from a DATETIME  E.g.<br>
 <code>YEAR(date '2008-9-23')</code> returns <code>
 2008</code></div>
</section>
</li>
<li>
<section class="detail" id="QUARTER">
<h3>QUARTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">QUARTER</span></div>
<div class="block">The SQL <code>QUARTER</code> operator. Returns the Quarter
 from a DATETIME  E.g.<br>
 <code>QUARTER(date '2008-9-23')</code> returns <code>
 3</code></div>
</section>
</li>
<li>
<section class="detail" id="MONTH">
<h3>MONTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">MONTH</span></div>
<div class="block">The SQL <code>MONTH</code> operator. Returns the Month
 from a DATETIME  E.g.<br>
 <code>MONTH(date '2008-9-23')</code> returns <code>
 9</code></div>
</section>
</li>
<li>
<section class="detail" id="WEEK">
<h3>WEEK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">WEEK</span></div>
<div class="block">The SQL <code>WEEK</code> operator. Returns the Week
 from a DATETIME  E.g.<br>
 <code>WEEK(date '2008-9-23')</code> returns <code>
 39</code></div>
</section>
</li>
<li>
<section class="detail" id="DAYOFYEAR">
<h3>DAYOFYEAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">DAYOFYEAR</span></div>
<div class="block">The SQL <code>DAYOFYEAR</code> operator. Returns the DOY
 from a DATETIME  E.g.<br>
 <code>DAYOFYEAR(date '2008-9-23')</code> returns <code>
 267</code></div>
</section>
</li>
<li>
<section class="detail" id="DAYOFMONTH">
<h3>DAYOFMONTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">DAYOFMONTH</span></div>
<div class="block">The SQL <code>DAYOFMONTH</code> operator. Returns the Day
 from a DATETIME  E.g.<br>
 <code>DAYOFMONTH(date '2008-9-23')</code> returns <code>
 23</code></div>
</section>
</li>
<li>
<section class="detail" id="DAYOFWEEK">
<h3>DAYOFWEEK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">DAYOFWEEK</span></div>
<div class="block">The SQL <code>DAYOFWEEK</code> operator. Returns the DOW
 from a DATETIME  E.g.<br>
 <code>DAYOFWEEK(date '2008-9-23')</code> returns <code>
 2</code></div>
</section>
</li>
<li>
<section class="detail" id="HOUR">
<h3>HOUR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">HOUR</span></div>
<div class="block">The SQL <code>HOUR</code> operator. Returns the Hour
 from a DATETIME  E.g.<br>
 <code>HOUR(timestamp '2008-9-23 01:23:45')</code> returns <code>
 1</code></div>
</section>
</li>
<li>
<section class="detail" id="MINUTE">
<h3>MINUTE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">MINUTE</span></div>
<div class="block">The SQL <code>MINUTE</code> operator. Returns the Minute
 from a DATETIME  E.g.<br>
 <code>MINUTE(timestamp '2008-9-23 01:23:45')</code> returns <code>
 23</code></div>
</section>
</li>
<li>
<section class="detail" id="SECOND">
<h3>SECOND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDatePartFunction.html" title="class in org.apache.calcite.sql.fun">SqlDatePartFunction</a></span>&nbsp;<span class="element-name">SECOND</span></div>
<div class="block">The SQL <code>SECOND</code> operator. Returns the Second
 from a DATETIME  E.g.<br>
 <code>SECOND(timestamp '2008-9-23 01:23:45')</code> returns <code>
 45</code></div>
</section>
</li>
<li>
<section class="detail" id="LAST_DAY">
<h3>LAST_DAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LAST_DAY</span></div>
</section>
</li>
<li>
<section class="detail" id="ELEMENT">
<h3>ELEMENT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ELEMENT</span></div>
<div class="block">The ELEMENT operator, used to convert a multiset with only one item to a
 "regular" type. Example ... log(ELEMENT(MULTISET[1])) ...</div>
</section>
</li>
<li>
<section class="detail" id="ITEM">
<h3>ITEM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">ITEM</span></div>
<div class="block">The item operator <code>[ ... ]</code>, used to access a given element of an
 array, map or struct. For example, <code>myArray[3]</code>, <code>"myMap['foo']"</code>,
 <code>myStruct[2]</code> or <code>myStruct['fieldName']</code>.

 <p>The SQL standard calls the ARRAY variant a
 &lt;array element reference&gt;. Index is 1-based. The standard says
 to raise "data exception - array element error" but we currently return
 null.</p>

 <p>MAP is not standard SQL.</p></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_VALUE_CONSTRUCTOR">
<h3>ARRAY_VALUE_CONSTRUCTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlArrayValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlArrayValueConstructor</a></span>&nbsp;<span class="element-name">ARRAY_VALUE_CONSTRUCTOR</span></div>
<div class="block">The ARRAY Value Constructor. e.g. "<code>ARRAY[1, 2, 3]</code>".</div>
</section>
</li>
<li>
<section class="detail" id="MAP_VALUE_CONSTRUCTOR">
<h3>MAP_VALUE_CONSTRUCTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlMapValueConstructor.html" title="class in org.apache.calcite.sql.fun">SqlMapValueConstructor</a></span>&nbsp;<span class="element-name">MAP_VALUE_CONSTRUCTOR</span></div>
<div class="block">The MAP Value Constructor,
 e.g. "<code>MAP['washington', 1, 'obama', 44]</code>".</div>
</section>
</li>
<li>
<section class="detail" id="SLICE">
<h3>SLICE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">SLICE</span></div>
<div class="block">The internal "$SLICE" operator takes a multiset of records and returns a
 multiset of the first column of those records.

 <p>It is introduced when multisets of scalar types are created, in order
 to keep types consistent. For example, <code>MULTISET [5]</code> has type
 <code>INTEGER MULTISET</code> but is translated to an expression of type
 <code>RECORD(INTEGER EXPR$0) MULTISET</code> 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 <code>
 INTEGER MULTISET</code> multiset value.

 <p><code>$SLICE</code> is often translated away when the multiset type is
 converted back to scalar values.</div>
</section>
</li>
<li>
<section class="detail" id="ELEMENT_SLICE">
<h3>ELEMENT_SLICE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">ELEMENT_SLICE</span></div>
<div class="block">The internal "$ELEMENT_SLICE" operator returns the first field of the
 only element of a multiset.

 <p>It is introduced when multisets of scalar types are created, in order
 to keep types consistent. For example, <code>ELEMENT(MULTISET [5])</code>
 is translated to <code>$ELEMENT_SLICE(MULTISET (VALUES ROW (5
 EXPR$0))</code> It is translated away when the multiset type is converted
 back to scalar values.</p>

 <p>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!</p></div>
</section>
</li>
<li>
<section class="detail" id="SCALAR_QUERY">
<h3>SCALAR_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">SCALAR_QUERY</span></div>
<div class="block">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.</div>
</section>
</li>
<li>
<section class="detail" id="STRUCT_ACCESS">
<h3>STRUCT_ACCESS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">STRUCT_ACCESS</span></div>
<div class="block">The internal <code>$STRUCT_ACCESS</code> operator is used to access a
 field of a record.

 <p>In contrast with <a href="#DOT"><code>DOT</code></a> operator, it never appears in an
 <a href="../SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> tree and allows to access fields by position and
 not by name.</div>
</section>
</li>
<li>
<section class="detail" id="CARDINALITY">
<h3>CARDINALITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CARDINALITY</span></div>
<div class="block">The CARDINALITY operator, used to retrieve the number of elements in a
 MULTISET, ARRAY or MAP.</div>
</section>
</li>
<li>
<section class="detail" id="COLLECT">
<h3>COLLECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">COLLECT</span></div>
<div class="block">The COLLECT operator. Multiset aggregator function.</div>
</section>
</li>
<li>
<section class="detail" id="PERCENTILE_CONT">
<h3>PERCENTILE_CONT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">PERCENTILE_CONT</span></div>
<div class="block"><code>PERCENTILE_CONT</code> inverse distribution aggregate function.

 <p>The argument must be a numeric literal in the range 0 to 1 inclusive
 (representing a percentage), and the return type is <code>DOUBLE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PERCENTILE_DISC">
<h3>PERCENTILE_DISC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">PERCENTILE_DISC</span></div>
<div class="block"><code>PERCENTILE_DISC</code> inverse distribution aggregate function.

 <p>The argument must be a numeric literal in the range 0 to 1 inclusive
 (representing a percentage), and the return type is <code>DOUBLE</code>.
 (The return type should determined by the type of the <code>ORDER BY</code>
 expression, but this cannot be determined by the function itself.)</div>
</section>
</li>
<li>
<section class="detail" id="LISTAGG">
<h3>LISTAGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LISTAGG</span></div>
<div class="block">The LISTAGG operator. String aggregator function.</div>
</section>
</li>
<li>
<section class="detail" id="FUSION">
<h3>FUSION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">FUSION</span></div>
<div class="block">The FUSION operator. Multiset aggregator function.</div>
</section>
</li>
<li>
<section class="detail" id="INTERSECTION">
<h3>INTERSECTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">INTERSECTION</span></div>
<div class="block">The INTERSECTION operator. Multiset aggregator function.</div>
</section>
</li>
<li>
<section class="detail" id="NEXT_VALUE">
<h3>NEXT_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">NEXT_VALUE</span></div>
<div class="block">The sequence next value function: <code>NEXT VALUE FOR sequence</code>.</div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_VALUE">
<h3>CURRENT_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">CURRENT_VALUE</span></div>
<div class="block">The sequence current value function: <code>CURRENT VALUE FOR
 sequence</code>.</div>
</section>
</li>
<li>
<section class="detail" id="TABLESAMPLE">
<h3>TABLESAMPLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">TABLESAMPLE</span></div>
<div class="block">The <code>TABLESAMPLE</code> operator.

 <p>Examples:

 <ul>
 <li><code>&lt;query&gt; TABLESAMPLE SUBSTITUTE('sampleName')</code>
 (non-standard)
 <li><code>&lt;query&gt; TABLESAMPLE BERNOULLI(&lt;percent&gt;)
 [REPEATABLE(&lt;seed&gt;)]</code> (standard, but not implemented for FTRS
 yet)
 <li><code>&lt;query&gt; TABLESAMPLE SYSTEM(&lt;percent&gt;)
 [REPEATABLE(&lt;seed&gt;)]</code> (standard, but not implemented for FTRS
 yet)
 </ul>

 <p>Operand #0 is a query or table; Operand #1 is a <a href="../SqlSampleSpec.html" title="class in org.apache.calcite.sql"><code>SqlSampleSpec</code></a>
 wrapped in a <a href="../SqlLiteral.html" title="class in org.apache.calcite.sql"><code>SqlLiteral</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DESCRIPTOR">
<h3>DESCRIPTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">DESCRIPTOR</span></div>
<div class="block">DESCRIPTOR(column_name, ...).</div>
</section>
</li>
<li>
<section class="detail" id="TUMBLE">
<h3>TUMBLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TUMBLE</span></div>
<div class="block">TUMBLE as a table function.</div>
</section>
</li>
<li>
<section class="detail" id="HOP">
<h3>HOP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">HOP</span></div>
<div class="block">HOP as a table function.</div>
</section>
</li>
<li>
<section class="detail" id="SESSION">
<h3>SESSION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SESSION</span></div>
<div class="block">SESSION as a table function.</div>
</section>
</li>
<li>
<section class="detail" id="TUMBLE_OLD">
<h3>TUMBLE_OLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">TUMBLE_OLD</span></div>
<div class="block">The <code>TUMBLE</code> group function.

 <p>This operator is named "$TUMBLE" (not "TUMBLE") because it is created
 directly by the parser, not by looking up an operator by name.

 <p>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.

 <p>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.</div>
</section>
</li>
<li>
<section class="detail" id="TUMBLE_START">
<h3>TUMBLE_START</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">TUMBLE_START</span></div>
<div class="block">The <code>TUMBLE_START</code> auxiliary function of
 the <code>TUMBLE</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="TUMBLE_END">
<h3>TUMBLE_END</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">TUMBLE_END</span></div>
<div class="block">The <code>TUMBLE_END</code> auxiliary function of
 the <code>TUMBLE</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="HOP_OLD">
<h3>HOP_OLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">HOP_OLD</span></div>
<div class="block">The <code>HOP</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="HOP_START">
<h3>HOP_START</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">HOP_START</span></div>
<div class="block">The <code>HOP_START</code> auxiliary function of
 the <code>HOP</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="HOP_END">
<h3>HOP_END</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">HOP_END</span></div>
<div class="block">The <code>HOP_END</code> auxiliary function of
 the <code>HOP</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="SESSION_OLD">
<h3>SESSION_OLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">SESSION_OLD</span></div>
<div class="block">The <code>SESSION</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="SESSION_START">
<h3>SESSION_START</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">SESSION_START</span></div>
<div class="block">The <code>SESSION_START</code> auxiliary function of
 the <code>SESSION</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="SESSION_END">
<h3>SESSION_END</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">SESSION_END</span></div>
<div class="block">The <code>SESSION_END</code> auxiliary function of
 the <code>SESSION</code> group function.</div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_ALTER">
<h3>PATTERN_ALTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">PATTERN_ALTER</span></div>
<div class="block"><code>|</code> operator to create alternate patterns
 within <code>MATCH_RECOGNIZE</code>.

 <p>If <code>p1</code> and <code>p2</code> are patterns then <code>p1 | p2</code> is a
 pattern that matches <code>p1</code> or <code>p2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_CONCAT">
<h3>PATTERN_CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBinaryOperator.html" title="class in org.apache.calcite.sql">SqlBinaryOperator</a></span>&nbsp;<span class="element-name">PATTERN_CONCAT</span></div>
<div class="block">Operator to concatenate patterns within <code>MATCH_RECOGNIZE</code>.

 <p>If <code>p1</code> and <code>p2</code> are patterns then <code>p1 p2</code> is a
 pattern that matches <code>p1</code> followed by <code>p2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_QUANTIFIER">
<h3>PATTERN_QUANTIFIER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">PATTERN_QUANTIFIER</span></div>
<div class="block">Operator to quantify patterns within <code>MATCH_RECOGNIZE</code>.

 <p>If <code>p</code> is a pattern then <code>p{3, 5}</code> is a
 pattern that matches between 3 and 5 occurrences of <code>p</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_PERMUTE">
<h3>PATTERN_PERMUTE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">PATTERN_PERMUTE</span></div>
<div class="block"><code>PERMUTE</code> operator to combine patterns within
 <code>MATCH_RECOGNIZE</code>.

 <p>If <code>p1</code> and <code>p2</code> are patterns then <code>PERMUTE (p1, p2)</code>
 is a pattern that matches all permutations of <code>p1</code> and
 <code>p2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_EXCLUDE">
<h3>PATTERN_EXCLUDE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">PATTERN_EXCLUDE</span></div>
<div class="block"><code>EXCLUDE</code> operator within <code>MATCH_RECOGNIZE</code>.

 <p>If <code>p</code> is a pattern then <code>{- p -} </code>} is a
 pattern that excludes <code>p</code> from the output.</div>
</section>
</li>
<li>
<section class="detail" id="SET_SEMANTICS_TABLE">
<h3>SET_SEMANTICS_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlInternalOperator.html" title="class in org.apache.calcite.sql">SqlInternalOperator</a></span>&nbsp;<span class="element-name">SET_SEMANTICS_TABLE</span></div>
<div class="block">SetSemanticsTable represents as an input table with set semantics.</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>SqlStdOperatorTable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlStdOperatorTable</span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="instance()">
<h3>instance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlStdOperatorTable.html" title="class in org.apache.calcite.sql.fun">SqlStdOperatorTable</a></span>&nbsp;<span class="element-name">instance</span>()</div>
<div class="block">Returns the standard operator table, creating it if necessary.</div>
</section>
</li>
<li>
<section class="detail" id="auxiliaryToGroup(org.apache.calcite.sql.SqlKind)">
<h3>auxiliaryToGroup</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../SqlGroupedWindowFunction.html" title="class in org.apache.calcite.sql">SqlGroupedWindowFunction</a></span>&nbsp;<span class="element-name">auxiliaryToGroup</span><wbr><span class="parameters">(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind)</span></div>
<div class="block">Returns the group function for which a given kind is an auxiliary
 function, or null if it is not an auxiliary function.</div>
</section>
</li>
<li>
<section class="detail" id="convertAuxiliaryToGroupCall(org.apache.calcite.sql.SqlCall)">
<h3>convertAuxiliaryToGroupCall</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></span>&nbsp;<span class="element-name">convertAuxiliaryToGroupCall</span><wbr><span class="parameters">(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
<div class="block">Converts a call to a grouped auxiliary function
 to a call to the grouped window function. For other calls returns null.

 <p>For example, converts <code>TUMBLE_START(rowtime, INTERVAL '1' HOUR))</code>
 to <code>TUMBLE(rowtime, INTERVAL '1' HOUR))</code>.</div>
</section>
</li>
<li>
<section class="detail" id="convertGroupToAuxiliaryCalls(org.apache.calcite.sql.SqlCall)">
<h3>convertGroupToAuxiliaryCalls</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../../sql2rel/AuxiliaryConverter.html" title="interface in org.apache.calcite.sql2rel">AuxiliaryConverter</a>&gt;&gt;</span>&nbsp;<span class="element-name">convertGroupToAuxiliaryCalls</span><wbr><span class="parameters">(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
<div class="block">Converts a call to a grouped window function to a call to its auxiliary
 window function(s). For other calls returns null.

 <p>For example, converts <code>TUMBLE_START(rowtime, INTERVAL '1' HOUR))</code>
 to <code>TUMBLE(rowtime, INTERVAL '1' HOUR))</code>.</div>
</section>
</li>
<li>
<section class="detail" id="some(org.apache.calcite.sql.SqlKind)">
<h3>some</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">some</span><wbr><span class="parameters">(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;comparisonKind)</span></div>
<div class="block">Returns the operator for <code>SOME comparisonKind</code>.</div>
</section>
</li>
<li>
<section class="detail" id="all(org.apache.calcite.sql.SqlKind)">
<h3>all</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlQuantifyOperator.html" title="class in org.apache.calcite.sql.fun">SqlQuantifyOperator</a></span>&nbsp;<span class="element-name">all</span><wbr><span class="parameters">(<a href="../SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;comparisonKind)</span></div>
<div class="block">Returns the operator for <code>ALL comparisonKind</code>.</div>
</section>
</li>
<li>
<section class="detail" id="reverse(org.apache.calcite.sql.SqlOperator)">
<h3>reverse</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">reverse</span><wbr><span class="parameters">(<a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../SqlOperator.html#reverse()"><code>SqlOperator.reverse()</code></a>, but beware that it has
 slightly different semantics</div>
</div>
<div class="block">Returns the binary operator that corresponds to this operator but in the opposite
 direction. Or returns this, if its kind is not reversible.

 <p>For example, <code>reverse(GREATER_THAN)</code> returns <a href="#LESS_THAN"><code>LESS_THAN</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="like(boolean,boolean)">
<h3>like</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">like</span><wbr><span class="parameters">(boolean&nbsp;negated,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns the operator for <code>LIKE</code> with given case-sensitivity,
 optionally negated.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
