<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>BuiltInMethod (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.util, enum: BuiltInMethod">
<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><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#enum-constant-summary">Enum Constants</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</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="#enum-constant-detail">Enum Constants</a>&nbsp;|&nbsp;</li>
<li><a href="#field-detail">Field</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.util</a></div>
<h1 title="Enum BuiltInMethod" class="title">Enum BuiltInMethod</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">java.lang.Enum</a>&lt;<a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>&gt;
<div class="inheritance">org.apache.calcite.util.BuiltInMethod</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Serializable.html" title="class or interface in java.io" class="external-link">Serializable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;<a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>&gt;</code>, <code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/constant/Constable.html" title="class or interface in java.lang.constant" class="external-link">Constable</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public enum </span><span class="element-name type-name-label">BuiltInMethod</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;<a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>&gt;</span></div>
<div class="block">Built-in methods.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="inherited-list">
<h2 id="nested-classes-inherited-from-class-java.lang.Enum">Nested classes/interfaces inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a></h2>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.EnumDesc.html" title="class or interface in java.lang" class="external-link">Enum.EnumDesc</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.EnumDesc.html" title="class or interface in java.lang" class="external-link">E</a> extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.EnumDesc.html" title="class or interface in java.lang" class="external-link">E</a>&gt;&gt;</code></div>
</section>
</li>
<!-- =========== ENUM CONSTANT SUMMARY =========== -->
<li>
<section class="constants-summary" id="enum-constant-summary">
<h2>Enum Constant Summary</h2>
<div class="caption"><span>Enum Constants</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Enum Constant</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="#ABSTRACT_ENUMERABLE_CTOR" class="member-name-link">ABSTRACT_ENUMERABLE_CTOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ADD_MONTHS" class="member-name-link">ADD_MONTHS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ADD_MONTHS_INT" class="member-name-link">ADD_MONTHS_INT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AGG_LAMBDA_FACTORY_ACC_ADDER" class="member-name-link">AGG_LAMBDA_FACTORY_ACC_ADDER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#AGG_LAMBDA_FACTORY_ACC_INITIALIZER" class="member-name-link">AGG_LAMBDA_FACTORY_ACC_INITIALIZER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR" class="member-name-link">AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#AGG_LAMBDA_FACTORY_ACC_SINGLE_GROUP_RESULT_SELECTOR" class="member-name-link">AGG_LAMBDA_FACTORY_ACC_SINGLE_GROUP_RESULT_SELECTOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AGGREGATE" class="member-name-link">AGGREGATE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ALL_PREDICATES" class="member-name-link">ALL_PREDICATES</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ANTI_JOIN" class="member-name-link">ANTI_JOIN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ANY_ITEM" class="member-name-link">ANY_ITEM</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ARRAY" class="member-name-link">ARRAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ARRAY_COMPARER" class="member-name-link">ARRAY_COMPARER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ARRAY_ITEM" class="member-name-link">ARRAY_ITEM</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ARRAY_REVERSE" class="member-name-link">ARRAY_REVERSE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ARRAYS_AS_LIST" class="member-name-link">ARRAYS_AS_LIST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#AS_ENUMERABLE" class="member-name-link">AS_ENUMERABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AS_ENUMERABLE2" class="member-name-link">AS_ENUMERABLE2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#AS_LIST" class="member-name-link">AS_LIST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AS_QUERYABLE" class="member-name-link">AS_QUERYABLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ASCII" class="member-name-link">ASCII</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#AVERAGE_COLUMN_SIZES" class="member-name-link">AVERAGE_COLUMN_SIZES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#AVERAGE_ROW_SIZE" class="member-name-link">AVERAGE_ROW_SIZE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BASIC_AGGREGATE_LAMBDA_FACTORY" class="member-name-link">BASIC_AGGREGATE_LAMBDA_FACTORY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BASIC_LAZY_ACCUMULATOR" class="member-name-link">BASIC_LAZY_ACCUMULATOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BI_PREDICATE_TEST" class="member-name-link">BI_PREDICATE_TEST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BIG_DECIMAL_ADD" class="member-name-link">BIG_DECIMAL_ADD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BIG_DECIMAL_NEGATE" class="member-name-link">BIG_DECIMAL_NEGATE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BINARY_SEARCH5_LOWER" class="member-name-link">BINARY_SEARCH5_LOWER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BINARY_SEARCH5_UPPER" class="member-name-link">BINARY_SEARCH5_UPPER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BINARY_SEARCH6_LOWER" class="member-name-link">BINARY_SEARCH6_LOWER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BINARY_SEARCH6_UPPER" class="member-name-link">BINARY_SEARCH6_UPPER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BINDABLE_BIND" class="member-name-link">BINDABLE_BIND</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BIT_AND" class="member-name-link">BIT_AND</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BIT_OR" class="member-name-link">BIT_OR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#BIT_XOR" class="member-name-link">BIT_XOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#BOOLEAN_TO_STRING" class="member-name-link">BOOLEAN_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CEIL" class="member-name-link">CEIL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CHAR_FROM_ASCII" class="member-name-link">CHAR_FROM_ASCII</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CHAR_FROM_UTF8" class="member-name-link">CHAR_FROM_UTF8</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CHAR_LENGTH" class="member-name-link">CHAR_LENGTH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COLLATIONS" class="member-name-link">COLLATIONS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COLLECTION_ADD" class="member-name-link">COLLECTION_ADD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COLLECTION_ADDALL" class="member-name-link">COLLECTION_ADDALL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COLLECTION_RETAIN_ALL" class="member-name-link">COLLECTION_RETAIN_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COLLECTION_SIZE" class="member-name-link">COLLECTION_SIZE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COLLECTIONS_EMPTY_LIST" class="member-name-link">COLLECTIONS_EMPTY_LIST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COLLECTIONS_REVERSE_ORDER" class="member-name-link">COLLECTIONS_REVERSE_ORDER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COLLECTIONS_SINGLETON_LIST" class="member-name-link">COLLECTIONS_SINGLETON_LIST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COLUMN_ORIGIN" class="member-name-link">COLUMN_ORIGIN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COLUMN_UNIQUENESS" class="member-name-link">COLUMN_UNIQUENESS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COMPARABLE_EMPTY_LIST" class="member-name-link">COMPARABLE_EMPTY_LIST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COMPARATOR_COMPARE" class="member-name-link">COMPARATOR_COMPARE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COMPARE" class="member-name-link">COMPARE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COMPARE_NULLS_FIRST" class="member-name-link">COMPARE_NULLS_FIRST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COMPARE_NULLS_FIRST2" class="member-name-link">COMPARE_NULLS_FIRST2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COMPARE_NULLS_LAST" class="member-name-link">COMPARE_NULLS_LAST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COMPARE_NULLS_LAST2" class="member-name-link">COMPARE_NULLS_LAST2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COMPARE_TO" class="member-name-link">COMPARE_TO</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COMPARE2" class="member-name-link">COMPARE2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#COMPRESS" class="member-name-link">COMPRESS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CONCAT" class="member-name-link">CONCAT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CONSUMER_ACCEPT" class="member-name-link">CONSUMER_ACCEPT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CONTEXT_ROOT" class="member-name-link">CONTEXT_ROOT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CONTEXT_VALUES" class="member-name-link">CONTEXT_VALUES</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CORRELATE_BATCH_JOIN" class="member-name-link">CORRELATE_BATCH_JOIN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CORRELATE_JOIN" class="member-name-link">CORRELATE_JOIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#COSH" class="member-name-link">COSH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CREATE_ENRICHER" class="member-name-link">CREATE_ENRICHER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUMULATIVE_COST" class="member-name-link">CUMULATIVE_COST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CUMULATIVE_MEMORY_WITHIN_PHASE" class="member-name-link">CUMULATIVE_MEMORY_WITHIN_PHASE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT" class="member-name-link">CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CURRENT_DATE" class="member-name-link">CURRENT_DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CURRENT_TIME" class="member-name-link">CURRENT_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CURRENT_TIMESTAMP" class="member-name-link">CURRENT_TIMESTAMP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUSTOM_DATE_ADD" class="member-name-link">CUSTOM_DATE_ADD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CUSTOM_DATE_CEIL" class="member-name-link">CUSTOM_DATE_CEIL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUSTOM_DATE_DIFF" class="member-name-link">CUSTOM_DATE_DIFF</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CUSTOM_DATE_FLOOR" class="member-name-link">CUSTOM_DATE_FLOOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUSTOM_TIMESTAMP_ADD" class="member-name-link">CUSTOM_TIMESTAMP_ADD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CUSTOM_TIMESTAMP_CEIL" class="member-name-link">CUSTOM_TIMESTAMP_CEIL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#CUSTOM_TIMESTAMP_DIFF" class="member-name-link">CUSTOM_TIMESTAMP_DIFF</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#CUSTOM_TIMESTAMP_FLOOR" class="member-name-link">CUSTOM_TIMESTAMP_FLOOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DATA_CONTEXT_GET" class="member-name-link">DATA_CONTEXT_GET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DATA_CONTEXT_GET_QUERY_PROVIDER" class="member-name-link">DATA_CONTEXT_GET_QUERY_PROVIDER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DATA_CONTEXT_GET_ROOT_SCHEMA" class="member-name-link">DATA_CONTEXT_GET_ROOT_SCHEMA</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DATE_TO_INT" class="member-name-link">DATE_TO_INT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DATE_TO_INT_OFFSET" class="member-name-link">DATE_TO_INT_OFFSET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DATE_TO_INT_OPTIONAL" class="member-name-link">DATE_TO_INT_OPTIONAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DATE_TO_INT_OPTIONAL_OFFSET" class="member-name-link">DATE_TO_INT_OPTIONAL_OFFSET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DAYNAME_WITH_DATE" class="member-name-link">DAYNAME_WITH_DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DAYNAME_WITH_TIMESTAMP" class="member-name-link">DAYNAME_WITH_TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DEJSONIZE" class="member-name-link">DEJSONIZE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DIFFERENCE" class="member-name-link">DIFFERENCE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DISTINCT" class="member-name-link">DISTINCT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DISTINCT_ROW_COUNT" class="member-name-link">DISTINCT_ROW_COUNT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#DISTINCT2" class="member-name-link">DISTINCT2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#DISTRIBUTION" class="member-name-link">DISTRIBUTION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ELEMENT" class="member-name-link">ELEMENT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#EMITTER_EMIT" class="member-name-link">EMITTER_EMIT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#EMPTY_ENUMERABLE" class="member-name-link">EMPTY_ENUMERABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ENDS_WITH" class="member-name-link">ENDS_WITH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ENUMERABLE_ENUMERATOR" class="member-name-link">ENUMERABLE_ENUMERATOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ENUMERABLE_FOREACH" class="member-name-link">ENUMERABLE_FOREACH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ENUMERABLE_TO_LIST" class="member-name-link">ENUMERABLE_TO_LIST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ENUMERATOR_CLOSE" class="member-name-link">ENUMERATOR_CLOSE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ENUMERATOR_CURRENT" class="member-name-link">ENUMERATOR_CURRENT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ENUMERATOR_MOVE_NEXT" class="member-name-link">ENUMERATOR_MOVE_NEXT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ENUMERATOR_RESET" class="member-name-link">ENUMERATOR_RESET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#EXISTS_NODE" class="member-name-link">EXISTS_NODE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#EXPLAIN_VISIBILITY" class="member-name-link">EXPLAIN_VISIBILITY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#EXPRESSION_LINEAGE" class="member-name-link">EXPRESSION_LINEAGE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#EXTRACT_VALUE" class="member-name-link">EXTRACT_VALUE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#EXTRACT_XML" class="member-name-link">EXTRACT_XML</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#FLAT_LIST" class="member-name-link">FLAT_LIST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#FLAT_PRODUCT" class="member-name-link">FLAT_PRODUCT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#FLOOR" class="member-name-link">FLOOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#FLOOR_DIV" class="member-name-link">FLOOR_DIV</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#FLOOR_MOD" class="member-name-link">FLOOR_MOD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#FROM_BASE64" class="member-name-link">FROM_BASE64</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#FUNCTION_APPLY" class="member-name-link">FUNCTION_APPLY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#FUNCTION_CONTEXTS_OF" class="member-name-link">FUNCTION_CONTEXTS_OF</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#FUNCTION0_APPLY" class="member-name-link">FUNCTION0_APPLY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#FUNCTION1_APPLY" class="member-name-link">FUNCTION1_APPLY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#GREATER" class="member-name-link">GREATER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#GROUP_BY" class="member-name-link">GROUP_BY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#GROUP_BY_MULTIPLE" class="member-name-link">GROUP_BY_MULTIPLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#GROUP_BY2" class="member-name-link">GROUP_BY2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#GT" class="member-name-link">GT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#GT_NULLABLE" class="member-name-link">GT_NULLABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#HASH" class="member-name-link">HASH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#HASH_JOIN" class="member-name-link">HASH_JOIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#HOPPING" class="member-name-link">HOPPING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#IDENTITY_COMPARER" class="member-name-link">IDENTITY_COMPARER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#IDENTITY_SELECTOR" class="member-name-link">IDENTITY_SELECTOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ILIKE" class="member-name-link">ILIKE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#INTERNAL_TO_DATE" class="member-name-link">INTERNAL_TO_DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#INTERNAL_TO_TIME" class="member-name-link">INTERNAL_TO_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#INTERNAL_TO_TIMESTAMP" class="member-name-link">INTERNAL_TO_TIMESTAMP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#INTERSECT" class="member-name-link">INTERSECT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#INTERVAL_DAY_TIME_TO_STRING" class="member-name-link">INTERVAL_DAY_TIME_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#INTERVAL_YEAR_MONTH_TO_STRING" class="member-name-link">INTERVAL_YEAR_MONTH_TO_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#INTO" class="member-name-link">INTO</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#IS_A_SET" class="member-name-link">IS_A_SET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#IS_EMPTY" class="member-name-link">IS_EMPTY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><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><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><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><a href="#IS_NOT_FALSE" class="member-name-link">IS_NOT_FALSE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#IS_PHASE_TRANSITION" class="member-name-link">IS_PHASE_TRANSITION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#ITERABLE_FOR_EACH" class="member-name-link">ITERABLE_FOR_EACH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ITERATOR_HAS_NEXT" class="member-name-link">ITERATOR_HAS_NEXT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ITERATOR_NEXT" class="member-name-link">ITERATOR_NEXT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JDBC_ARRAY_TO_LIST" class="member-name-link">JDBC_ARRAY_TO_LIST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JDBC_SCHEMA_DATA_SOURCE" class="member-name-link">JDBC_SCHEMA_DATA_SOURCE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_API_COMMON_SYNTAX" class="member-name-link">JSON_API_COMMON_SYNTAX</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first 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><a href="#JSON_ARRAYAGG_ADD" class="member-name-link">JSON_ARRAYAGG_ADD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_DEPTH" class="member-name-link">JSON_DEPTH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#JSON_INSERT" class="member-name-link">JSON_INSERT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_KEYS" class="member-name-link">JSON_KEYS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_LENGTH" class="member-name-link">JSON_LENGTH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_OBJECT" class="member-name-link">JSON_OBJECT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_OBJECTAGG_ADD" class="member-name-link">JSON_OBJECTAGG_ADD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_PRETTY" class="member-name-link">JSON_PRETTY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_QUERY" class="member-name-link">JSON_QUERY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_REMOVE" class="member-name-link">JSON_REMOVE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_REPLACE" class="member-name-link">JSON_REPLACE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_SET" class="member-name-link">JSON_SET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#JSON_STORAGE_SIZE" class="member-name-link">JSON_STORAGE_SIZE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#JSON_TYPE" class="member-name-link">JSON_TYPE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first 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><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><a href="#JSONIZE" class="member-name-link">JSONIZE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LAST_DAY" class="member-name-link">LAST_DAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LAZY_AGGREGATE_LAMBDA_FACTORY" class="member-name-link">LAZY_AGGREGATE_LAMBDA_FACTORY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LAZY_COLLECTION_SPOOL" class="member-name-link">LAZY_COLLECTION_SPOOL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LEFT" class="member-name-link">LEFT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LESSER" class="member-name-link">LESSER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first 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><a href="#LIST_GET" class="member-name-link">LIST_GET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LIST_N" class="member-name-link">LIST_N</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LIST2" class="member-name-link">LIST2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LIST3" class="member-name-link">LIST3</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LIST4" class="member-name-link">LIST4</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LIST5" class="member-name-link">LIST5</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LIST6" class="member-name-link">LIST6</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LOCAL_TIME" class="member-name-link">LOCAL_TIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LOCAL_TIMESTAMP" class="member-name-link">LOCAL_TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LOCALE" class="member-name-link">LOCALE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LONG_VALUE" class="member-name-link">LONG_VALUE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LOWER" class="member-name-link">LOWER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LOWER_BOUND_COST" class="member-name-link">LOWER_BOUND_COST</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LPAD" class="member-name-link">LPAD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LT" class="member-name-link">LT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#LT_NULLABLE" class="member-name-link">LT_NULLABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#LTRIM" class="member-name-link">LTRIM</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MAP_CLEAR" class="member-name-link">MAP_CLEAR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MAP_GET" class="member-name-link">MAP_GET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MAP_GET_OR_DEFAULT" class="member-name-link">MAP_GET_OR_DEFAULT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MAP_ITEM" class="member-name-link">MAP_ITEM</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MAP_PUT" class="member-name-link">MAP_PUT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MATCH" class="member-name-link">MATCH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MATCH_UTILS_LAST_WITH_SYMBOL" class="member-name-link">MATCH_UTILS_LAST_WITH_SYMBOL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MATCHER_BUILDER" class="member-name-link">MATCHER_BUILDER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MATCHER_BUILDER_ADD" class="member-name-link">MATCHER_BUILDER_ADD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MATCHER_BUILDER_BUILD" class="member-name-link">MATCHER_BUILDER_BUILD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MATH_MAX" class="member-name-link">MATH_MAX</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MATH_MIN" class="member-name-link">MATH_MIN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MAX_ROW_COUNT" class="member-name-link">MAX_ROW_COUNT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MD5" class="member-name-link">MD5</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MEMBER_OF" class="member-name-link">MEMBER_OF</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MEMORY" class="member-name-link">MEMORY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MEMORY_GET0" class="member-name-link">MEMORY_GET0</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MEMORY_GET1" class="member-name-link">MEMORY_GET1</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MERGE_JOIN" class="member-name-link">MERGE_JOIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MERGE_UNION" class="member-name-link">MERGE_UNION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#METADATA_REL" class="member-name-link">METADATA_REL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MIN_ROW_COUNT" class="member-name-link">MIN_ROW_COUNT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION" class="member-name-link">MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MONTHNAME_WITH_DATE" class="member-name-link">MONTHNAME_WITH_DATE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MONTHNAME_WITH_TIMESTAMP" class="member-name-link">MONTHNAME_WITH_TIMESTAMP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MULTI_STRING_CONCAT" class="member-name-link">MULTI_STRING_CONCAT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MULTISET_EXCEPT_ALL" class="member-name-link">MULTISET_EXCEPT_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MULTISET_EXCEPT_DISTINCT" class="member-name-link">MULTISET_EXCEPT_DISTINCT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MULTISET_INTERSECT_ALL" class="member-name-link">MULTISET_INTERSECT_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#MULTISET_INTERSECT_DISTINCT" class="member-name-link">MULTISET_INTERSECT_DISTINCT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#MULTISET_UNION_ALL" class="member-name-link">MULTISET_UNION_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#NESTED_LOOP_JOIN" class="member-name-link">NESTED_LOOP_JOIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#NODE_TYPES" class="member-name-link">NODE_TYPES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#NON_CUMULATIVE_COST" class="member-name-link">NON_CUMULATIVE_COST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#NOT" class="member-name-link">NOT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#NULLS_COMPARATOR" class="member-name-link">NULLS_COMPARATOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#NULLS_COMPARATOR2" class="member-name-link">NULLS_COMPARATOR2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#OBJECT_TO_STRING" class="member-name-link">OBJECT_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#OBJECTS_EQUAL" class="member-name-link">OBJECTS_EQUAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first 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><a href="#ORDER_BY" class="member-name-link">ORDER_BY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ORDER_BY_WITH_FETCH_AND_OFFSET" class="member-name-link">ORDER_BY_WITH_FETCH_AND_OFFSET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#OVERLAY" class="member-name-link">OVERLAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#OVERLAY3" class="member-name-link">OVERLAY3</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#PATTERN_BUILDER" class="member-name-link">PATTERN_BUILDER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#PATTERN_BUILDER_BUILD" class="member-name-link">PATTERN_BUILDER_BUILD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#PATTERN_BUILDER_SEQ" class="member-name-link">PATTERN_BUILDER_SEQ</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#PATTERN_BUILDER_SYMBOL" class="member-name-link">PATTERN_BUILDER_SYMBOL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#PATTERN_TO_AUTOMATON" class="member-name-link">PATTERN_TO_AUTOMATON</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#PERCENTAGE_ORIGINAL_ROWS" class="member-name-link">PERCENTAGE_ORIGINAL_ROWS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#POPULATION_SIZE" class="member-name-link">POPULATION_SIZE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#POSITION" class="member-name-link">POSITION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#POSIX_REGEX" class="member-name-link">POSIX_REGEX</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#PREDICATE_TEST" class="member-name-link">PREDICATE_TEST</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#PREDICATES" class="member-name-link">PREDICATES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#QUERYABLE_AS_ENUMERABLE" class="member-name-link">QUERYABLE_AS_ENUMERABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#QUERYABLE_SELECT" class="member-name-link">QUERYABLE_SELECT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#QUERYABLE_TABLE_AS_QUERYABLE" class="member-name-link">QUERYABLE_TABLE_AS_QUERYABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RAND" class="member-name-link">RAND</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RAND_INTEGER" class="member-name-link">RAND_INTEGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RAND_INTEGER_SEED" class="member-name-link">RAND_INTEGER_SEED</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RAND_SEED" class="member-name-link">RAND_SEED</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#REFLECTIVE_SCHEMA_GET_TARGET" class="member-name-link">REFLECTIVE_SCHEMA_GET_TARGET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#REGEXP_REPLACE3" class="member-name-link">REGEXP_REPLACE3</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#REGEXP_REPLACE4" class="member-name-link">REGEXP_REPLACE4</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#REGEXP_REPLACE5" class="member-name-link">REGEXP_REPLACE5</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#REGEXP_REPLACE6" class="member-name-link">REGEXP_REPLACE6</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#REMOVE_ALL" class="member-name-link">REMOVE_ALL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#REPEAT" class="member-name-link">REPEAT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#REPEAT_UNION" class="member-name-link">REPEAT_UNION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#REPLACE" class="member-name-link">REPLACE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RESULT_SET_ENUMERABLE_OF" class="member-name-link">RESULT_SET_ENUMERABLE_OF</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RESULT_SET_ENUMERABLE_OF_PREPARED" class="member-name-link">RESULT_SET_ENUMERABLE_OF_PREPARED</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RESULT_SET_ENUMERABLE_SET_TIMEOUT" class="member-name-link">RESULT_SET_ENUMERABLE_SET_TIMEOUT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RESULT_SET_GET_DATE2" class="member-name-link">RESULT_SET_GET_DATE2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RESULT_SET_GET_TIME2" class="member-name-link">RESULT_SET_GET_TIME2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RESULT_SET_GET_TIMESTAMP2" class="member-name-link">RESULT_SET_GET_TIMESTAMP2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#REVERSE" class="member-name-link">REVERSE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RIGHT" class="member-name-link">RIGHT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RLIKE" class="member-name-link">RLIKE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ROUND_INT" class="member-name-link">ROUND_INT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ROUND_LONG" class="member-name-link">ROUND_LONG</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ROW_AS_COPY" class="member-name-link">ROW_AS_COPY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#ROW_COUNT" class="member-name-link">ROW_COUNT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ROW_VALUE" class="member-name-link">ROW_VALUE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#RPAD" class="member-name-link">RPAD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#RTRIM" class="member-name-link">RTRIM</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCALAR_EXECUTE1" class="member-name-link">SCALAR_EXECUTE1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCALAR_EXECUTE2" class="member-name-link">SCALAR_EXECUTE2</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCANNABLE_TABLE_SCAN" class="member-name-link">SCANNABLE_TABLE_SCAN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCHEMA_GET_SUB_SCHEMA" class="member-name-link">SCHEMA_GET_SUB_SCHEMA</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCHEMA_GET_TABLE" class="member-name-link">SCHEMA_GET_TABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCHEMA_PLUS_ADD_TABLE" class="member-name-link">SCHEMA_PLUS_ADD_TABLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCHEMA_PLUS_REMOVE_TABLE" class="member-name-link">SCHEMA_PLUS_REMOVE_TABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCHEMA_PLUS_UNWRAP" class="member-name-link">SCHEMA_PLUS_UNWRAP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCHEMAS_ENUMERABLE_FILTERABLE" class="member-name-link">SCHEMAS_ENUMERABLE_FILTERABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCHEMAS_ENUMERABLE_PROJECTABLE_FILTERABLE" class="member-name-link">SCHEMAS_ENUMERABLE_PROJECTABLE_FILTERABLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SCHEMAS_ENUMERABLE_SCANNABLE" class="member-name-link">SCHEMAS_ENUMERABLE_SCANNABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SCHEMAS_QUERYABLE" class="member-name-link">SCHEMAS_QUERYABLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SELECT" class="member-name-link">SELECT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SELECT_MANY" class="member-name-link">SELECT_MANY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SELECT2" class="member-name-link">SELECT2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SELECTIVITY" class="member-name-link">SELECTIVITY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SEMI_JOIN" class="member-name-link">SEMI_JOIN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SEQUENCE_CURRENT_VALUE" class="member-name-link">SEQUENCE_CURRENT_VALUE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SEQUENCE_NEXT_VALUE" class="member-name-link">SEQUENCE_NEXT_VALUE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SESSIONIZATION" class="member-name-link">SESSIONIZATION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SHA1" class="member-name-link">SHA1</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SIMILAR" class="member-name-link">SIMILAR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SINGLETON_ENUMERABLE" class="member-name-link">SINGLETON_ENUMERABLE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SINH" class="member-name-link">SINH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SKIP" class="member-name-link">SKIP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SLICE" class="member-name-link">SLICE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SLICE0" class="member-name-link">SLICE0</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SORTED_GROUP_BY" class="member-name-link">SORTED_GROUP_BY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SORTED_MULTI_MAP_ARRAYS" class="member-name-link">SORTED_MULTI_MAP_ARRAYS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SORTED_MULTI_MAP_PUT_MULTI" class="member-name-link">SORTED_MULTI_MAP_PUT_MULTI</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SORTED_MULTI_MAP_SINGLETON" class="member-name-link">SORTED_MULTI_MAP_SINGLETON</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SOUNDEX" class="member-name-link">SOUNDEX</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SOURCE_SORTER" class="member-name-link">SOURCE_SORTER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SPACE" class="member-name-link">SPACE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SPLIT_COUNT" class="member-name-link">SPLIT_COUNT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#ST_GEOM_FROM_EWKT" class="member-name-link">ST_GEOM_FROM_EWKT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#STARTS_WITH" class="member-name-link">STARTS_WITH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#STRCMP" class="member-name-link">STRCMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#STRING_CONCAT" class="member-name-link">STRING_CONCAT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#STRING_TO_BOOLEAN" class="member-name-link">STRING_TO_BOOLEAN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#STRING_TO_DATE" class="member-name-link">STRING_TO_DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#STRING_TO_TIME" class="member-name-link">STRING_TO_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#STRING_TO_TIME_WITH_LOCAL_TIME_ZONE" class="member-name-link">STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#STRING_TO_TIMESTAMP" class="member-name-link">STRING_TO_TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE" class="member-name-link">STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#STRUCT_ACCESS" class="member-name-link">STRUCT_ACCESS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SUBMULTISET_OF" class="member-name-link">SUBMULTISET_OF</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SUBSTRING" class="member-name-link">SUBSTRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#SUBTRACT_MONTHS" class="member-name-link">SUBTRACT_MONTHS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#SYSTEM_USER" class="member-name-link">SYSTEM_USER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TABLE_REFERENCES" class="member-name-link">TABLE_REFERENCES</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TAKE" class="member-name-link">TAKE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TANH" class="member-name-link">TANH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#THROW_UNLESS" class="member-name-link">THROW_UNLESS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE" class="member-name-link">TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIME_TO_INT" class="member-name-link">TIME_TO_INT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIME_TO_INT_OPTIONAL" class="member-name-link">TIME_TO_INT_OPTIONAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIME_WITH_LOCAL_TIME_ZONE_TO_STRING" class="member-name-link">TIME_WITH_LOCAL_TIME_ZONE_TO_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIME_WITH_LOCAL_TIME_ZONE_TO_TIME" class="member-name-link">TIME_WITH_LOCAL_TIME_ZONE_TO_TIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP" class="member-name-link">TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE" class="member-name-link">TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIME_ZONE" class="member-name-link">TIME_ZONE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIME_ZONE_GET_OFFSET" class="member-name-link">TIME_ZONE_GET_OFFSET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE" class="member-name-link">TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIMESTAMP_TO_DATE" class="member-name-link">TIMESTAMP_TO_DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_TO_LONG" class="member-name-link">TIMESTAMP_TO_LONG</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIMESTAMP_TO_LONG_OFFSET" class="member-name-link">TIMESTAMP_TO_LONG_OFFSET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_TO_LONG_OPTIONAL" class="member-name-link">TIMESTAMP_TO_LONG_OPTIONAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIMESTAMP_TO_LONG_OPTIONAL_OFFSET" class="member-name-link">TIMESTAMP_TO_LONG_OPTIONAL_OFFSET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE" class="member-name-link">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING" class="member-name-link">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME" class="member-name-link">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE" class="member-name-link">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP" class="member-name-link">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TO_BASE64" class="member-name-link">TO_BASE64</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TRANSLATE3" class="member-name-link">TRANSLATE3</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TRIM" class="member-name-link">TRIM</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#TRUNCATE_OR_PAD" class="member-name-link">TRUNCATE_OR_PAD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#TUMBLING" class="member-name-link">TUMBLING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#TYPED_GET_ELEMENT_TYPE" class="member-name-link">TYPED_GET_ELEMENT_TYPE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#UNION" class="member-name-link">UNION</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#UNIQUE_KEYS" class="member-name-link">UNIQUE_KEYS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#UNIX_DATE_CEIL" class="member-name-link">UNIX_DATE_CEIL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#UNIX_DATE_EXTRACT" class="member-name-link">UNIX_DATE_EXTRACT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#UNIX_DATE_FLOOR" class="member-name-link">UNIX_DATE_FLOOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#UNIX_DATE_TO_STRING" class="member-name-link">UNIX_DATE_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#UNIX_TIME_TO_STRING" class="member-name-link">UNIX_TIME_TO_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#UNIX_TIMESTAMP_CEIL" class="member-name-link">UNIX_TIMESTAMP_CEIL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#UNIX_TIMESTAMP_FLOOR" class="member-name-link">UNIX_TIMESTAMP_FLOOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#UNIX_TIMESTAMP_TO_STRING" class="member-name-link">UNIX_TIMESTAMP_TO_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first 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><a href="#USER" class="member-name-link">USER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#WHERE" class="member-name-link">WHERE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="#WHERE2" class="member-name-link">WHERE2</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="#XML_TRANSFORM" class="member-name-link">XML_TRANSFORM</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- =========== 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>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a></code></div>
<div class="col-second even-row-color"><code><a href="#constructor" class="member-name-link">constructor</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html" title="class or interface in java.lang.reflect" class="external-link">Field</a></code></div>
<div class="col-second odd-row-color"><code><a href="#field" class="member-name-link">field</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final com.google.common.collect.ImmutableMap&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>,<wbr><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#MAP" class="member-name-link">MAP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a></code></div>
<div class="col-second odd-row-color"><code><a href="#method" class="member-name-link">method</a></code></div>
<div class="col-last odd-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-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance 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></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-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMethodName()" class="member-name-link">getMethodName</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#valueOf(java.lang.String)" class="member-name-link">valueOf</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</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 enum constant of this type with the specified name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#values()" class="member-name-link">values</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 an array containing the constants of this enum type, in
the order they are declared.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Enum">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#compareTo(E)" title="class or interface in java.lang" class="external-link">compareTo</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#describeConstable()" title="class or interface in java.lang" class="external-link">describeConstable</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#getDeclaringClass()" title="class or interface in java.lang" class="external-link">getDeclaringClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#name()" title="class or interface in java.lang" class="external-link">name</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#ordinal()" title="class or interface in java.lang" class="external-link">ordinal</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Enum.html#valueOf(java.lang.Class,java.lang.String)" title="class or interface in java.lang" class="external-link">valueOf</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/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/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">
<!-- ============ ENUM CONSTANT DETAIL =========== -->
<li>
<section class="constant-details" id="enum-constant-detail">
<h2>Enum Constant Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="QUERYABLE_SELECT">
<h3>QUERYABLE_SELECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">QUERYABLE_SELECT</span></div>
</section>
</li>
<li>
<section class="detail" id="QUERYABLE_AS_ENUMERABLE">
<h3>QUERYABLE_AS_ENUMERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">QUERYABLE_AS_ENUMERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="QUERYABLE_TABLE_AS_QUERYABLE">
<h3>QUERYABLE_TABLE_AS_QUERYABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">QUERYABLE_TABLE_AS_QUERYABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="AS_QUERYABLE">
<h3>AS_QUERYABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AS_QUERYABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="ABSTRACT_ENUMERABLE_CTOR">
<h3>ABSTRACT_ENUMERABLE_CTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ABSTRACT_ENUMERABLE_CTOR</span></div>
</section>
</li>
<li>
<section class="detail" id="INTO">
<h3>INTO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTO</span></div>
</section>
</li>
<li>
<section class="detail" id="REMOVE_ALL">
<h3>REMOVE_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REMOVE_ALL</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMA_GET_SUB_SCHEMA">
<h3>SCHEMA_GET_SUB_SCHEMA</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMA_GET_SUB_SCHEMA</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMA_GET_TABLE">
<h3>SCHEMA_GET_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMA_GET_TABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMA_PLUS_ADD_TABLE">
<h3>SCHEMA_PLUS_ADD_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMA_PLUS_ADD_TABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMA_PLUS_REMOVE_TABLE">
<h3>SCHEMA_PLUS_REMOVE_TABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMA_PLUS_REMOVE_TABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMA_PLUS_UNWRAP">
<h3>SCHEMA_PLUS_UNWRAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMA_PLUS_UNWRAP</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMAS_ENUMERABLE_SCANNABLE">
<h3>SCHEMAS_ENUMERABLE_SCANNABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMAS_ENUMERABLE_SCANNABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMAS_ENUMERABLE_FILTERABLE">
<h3>SCHEMAS_ENUMERABLE_FILTERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMAS_ENUMERABLE_FILTERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMAS_ENUMERABLE_PROJECTABLE_FILTERABLE">
<h3>SCHEMAS_ENUMERABLE_PROJECTABLE_FILTERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMAS_ENUMERABLE_PROJECTABLE_FILTERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="SCHEMAS_QUERYABLE">
<h3>SCHEMAS_QUERYABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCHEMAS_QUERYABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="REFLECTIVE_SCHEMA_GET_TARGET">
<h3>REFLECTIVE_SCHEMA_GET_TARGET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REFLECTIVE_SCHEMA_GET_TARGET</span></div>
</section>
</li>
<li>
<section class="detail" id="DATA_CONTEXT_GET">
<h3>DATA_CONTEXT_GET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATA_CONTEXT_GET</span></div>
</section>
</li>
<li>
<section class="detail" id="DATA_CONTEXT_GET_ROOT_SCHEMA">
<h3>DATA_CONTEXT_GET_ROOT_SCHEMA</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATA_CONTEXT_GET_ROOT_SCHEMA</span></div>
</section>
</li>
<li>
<section class="detail" id="JDBC_SCHEMA_DATA_SOURCE">
<h3>JDBC_SCHEMA_DATA_SOURCE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JDBC_SCHEMA_DATA_SOURCE</span></div>
</section>
</li>
<li>
<section class="detail" id="ROW_VALUE">
<h3>ROW_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ROW_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="ROW_AS_COPY">
<h3>ROW_AS_COPY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ROW_AS_COPY</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_ENUMERABLE_SET_TIMEOUT">
<h3>RESULT_SET_ENUMERABLE_SET_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_ENUMERABLE_SET_TIMEOUT</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_ENUMERABLE_OF">
<h3>RESULT_SET_ENUMERABLE_OF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_ENUMERABLE_OF</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_ENUMERABLE_OF_PREPARED">
<h3>RESULT_SET_ENUMERABLE_OF_PREPARED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_ENUMERABLE_OF_PREPARED</span></div>
</section>
</li>
<li>
<section class="detail" id="CREATE_ENRICHER">
<h3>CREATE_ENRICHER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CREATE_ENRICHER</span></div>
</section>
</li>
<li>
<section class="detail" id="HASH_JOIN">
<h3>HASH_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">HASH_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="MATCH">
<h3>MATCH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATCH</span></div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_BUILDER">
<h3>PATTERN_BUILDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PATTERN_BUILDER</span></div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_BUILDER_SYMBOL">
<h3>PATTERN_BUILDER_SYMBOL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PATTERN_BUILDER_SYMBOL</span></div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_BUILDER_SEQ">
<h3>PATTERN_BUILDER_SEQ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PATTERN_BUILDER_SEQ</span></div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_BUILDER_BUILD">
<h3>PATTERN_BUILDER_BUILD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PATTERN_BUILDER_BUILD</span></div>
</section>
</li>
<li>
<section class="detail" id="PATTERN_TO_AUTOMATON">
<h3>PATTERN_TO_AUTOMATON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PATTERN_TO_AUTOMATON</span></div>
</section>
</li>
<li>
<section class="detail" id="MATCHER_BUILDER">
<h3>MATCHER_BUILDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATCHER_BUILDER</span></div>
</section>
</li>
<li>
<section class="detail" id="MATCHER_BUILDER_ADD">
<h3>MATCHER_BUILDER_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATCHER_BUILDER_ADD</span></div>
</section>
</li>
<li>
<section class="detail" id="MATCHER_BUILDER_BUILD">
<h3>MATCHER_BUILDER_BUILD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATCHER_BUILDER_BUILD</span></div>
</section>
</li>
<li>
<section class="detail" id="MATCH_UTILS_LAST_WITH_SYMBOL">
<h3>MATCH_UTILS_LAST_WITH_SYMBOL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATCH_UTILS_LAST_WITH_SYMBOL</span></div>
</section>
</li>
<li>
<section class="detail" id="EMITTER_EMIT">
<h3>EMITTER_EMIT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EMITTER_EMIT</span></div>
</section>
</li>
<li>
<section class="detail" id="MERGE_JOIN">
<h3>MERGE_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MERGE_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="SLICE0">
<h3>SLICE0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SLICE0</span></div>
</section>
</li>
<li>
<section class="detail" id="SEMI_JOIN">
<h3>SEMI_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SEMI_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="ANTI_JOIN">
<h3>ANTI_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ANTI_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="NESTED_LOOP_JOIN">
<h3>NESTED_LOOP_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NESTED_LOOP_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="CORRELATE_JOIN">
<h3>CORRELATE_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CORRELATE_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="CORRELATE_BATCH_JOIN">
<h3>CORRELATE_BATCH_JOIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CORRELATE_BATCH_JOIN</span></div>
</section>
</li>
<li>
<section class="detail" id="SELECT">
<h3>SELECT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SELECT</span></div>
</section>
</li>
<li>
<section class="detail" id="SELECT2">
<h3>SELECT2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SELECT2</span></div>
</section>
</li>
<li>
<section class="detail" id="SELECT_MANY">
<h3>SELECT_MANY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SELECT_MANY</span></div>
</section>
</li>
<li>
<section class="detail" id="WHERE">
<h3>WHERE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">WHERE</span></div>
</section>
</li>
<li>
<section class="detail" id="WHERE2">
<h3>WHERE2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">WHERE2</span></div>
</section>
</li>
<li>
<section class="detail" id="DISTINCT">
<h3>DISTINCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DISTINCT</span></div>
</section>
</li>
<li>
<section class="detail" id="DISTINCT2">
<h3>DISTINCT2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DISTINCT2</span></div>
</section>
</li>
<li>
<section class="detail" id="SORTED_GROUP_BY">
<h3>SORTED_GROUP_BY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SORTED_GROUP_BY</span></div>
</section>
</li>
<li>
<section class="detail" id="GROUP_BY">
<h3>GROUP_BY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GROUP_BY</span></div>
</section>
</li>
<li>
<section class="detail" id="GROUP_BY2">
<h3>GROUP_BY2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GROUP_BY2</span></div>
</section>
</li>
<li>
<section class="detail" id="GROUP_BY_MULTIPLE">
<h3>GROUP_BY_MULTIPLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GROUP_BY_MULTIPLE</span></div>
</section>
</li>
<li>
<section class="detail" id="AGGREGATE">
<h3>AGGREGATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AGGREGATE</span></div>
</section>
</li>
<li>
<section class="detail" id="ORDER_BY">
<h3>ORDER_BY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ORDER_BY</span></div>
</section>
</li>
<li>
<section class="detail" id="ORDER_BY_WITH_FETCH_AND_OFFSET">
<h3>ORDER_BY_WITH_FETCH_AND_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ORDER_BY_WITH_FETCH_AND_OFFSET</span></div>
</section>
</li>
<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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNION</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CONCAT</span></div>
</section>
</li>
<li>
<section class="detail" id="REPEAT_UNION">
<h3>REPEAT_UNION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REPEAT_UNION</span></div>
</section>
</li>
<li>
<section class="detail" id="MERGE_UNION">
<h3>MERGE_UNION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MERGE_UNION</span></div>
</section>
</li>
<li>
<section class="detail" id="LAZY_COLLECTION_SPOOL">
<h3>LAZY_COLLECTION_SPOOL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LAZY_COLLECTION_SPOOL</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERSECT</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXCEPT</span></div>
</section>
</li>
<li>
<section class="detail" id="SKIP">
<h3>SKIP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SKIP</span></div>
</section>
</li>
<li>
<section class="detail" id="TAKE">
<h3>TAKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TAKE</span></div>
</section>
</li>
<li>
<section class="detail" id="SINGLETON_ENUMERABLE">
<h3>SINGLETON_ENUMERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SINGLETON_ENUMERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="EMPTY_ENUMERABLE">
<h3>EMPTY_ENUMERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EMPTY_ENUMERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="NULLS_COMPARATOR">
<h3>NULLS_COMPARATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NULLS_COMPARATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="NULLS_COMPARATOR2">
<h3>NULLS_COMPARATOR2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NULLS_COMPARATOR2</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_COMPARER">
<h3>ARRAY_COMPARER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ARRAY_COMPARER</span></div>
</section>
</li>
<li>
<section class="detail" id="FUNCTION0_APPLY">
<h3>FUNCTION0_APPLY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FUNCTION0_APPLY</span></div>
</section>
</li>
<li>
<section class="detail" id="FUNCTION1_APPLY">
<h3>FUNCTION1_APPLY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FUNCTION1_APPLY</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAYS_AS_LIST">
<h3>ARRAYS_AS_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ARRAYS_AS_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY">
<h3>ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="FLAT_PRODUCT">
<h3>FLAT_PRODUCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FLAT_PRODUCT</span></div>
</section>
</li>
<li>
<section class="detail" id="FLAT_LIST">
<h3>FLAT_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FLAT_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST_N">
<h3>LIST_N</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST_N</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST2">
<h3>LIST2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST2</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST3">
<h3>LIST3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST3</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST4">
<h3>LIST4</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST4</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST5">
<h3>LIST5</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST5</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST6">
<h3>LIST6</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST6</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARABLE_EMPTY_LIST">
<h3>COMPARABLE_EMPTY_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARABLE_EMPTY_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="IDENTITY_COMPARER">
<h3>IDENTITY_COMPARER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IDENTITY_COMPARER</span></div>
</section>
</li>
<li>
<section class="detail" id="IDENTITY_SELECTOR">
<h3>IDENTITY_SELECTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IDENTITY_SELECTOR</span></div>
</section>
</li>
<li>
<section class="detail" id="AS_ENUMERABLE">
<h3>AS_ENUMERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AS_ENUMERABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="AS_ENUMERABLE2">
<h3>AS_ENUMERABLE2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AS_ENUMERABLE2</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_TO_LIST">
<h3>ENUMERABLE_TO_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERABLE_TO_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="AS_LIST">
<h3>AS_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AS_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="MEMORY_GET0">
<h3>MEMORY_GET0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MEMORY_GET0</span></div>
</section>
</li>
<li>
<section class="detail" id="MEMORY_GET1">
<h3>MEMORY_GET1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MEMORY_GET1</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERATOR_CURRENT">
<h3>ENUMERATOR_CURRENT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERATOR_CURRENT</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERATOR_MOVE_NEXT">
<h3>ENUMERATOR_MOVE_NEXT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERATOR_MOVE_NEXT</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERATOR_CLOSE">
<h3>ENUMERATOR_CLOSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERATOR_CLOSE</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERATOR_RESET">
<h3>ENUMERATOR_RESET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERATOR_RESET</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_ENUMERATOR">
<h3>ENUMERABLE_ENUMERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERABLE_ENUMERATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_FOREACH">
<h3>ENUMERABLE_FOREACH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENUMERABLE_FOREACH</span></div>
</section>
</li>
<li>
<section class="detail" id="ITERABLE_FOR_EACH">
<h3>ITERABLE_FOR_EACH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ITERABLE_FOR_EACH</span></div>
</section>
</li>
<li>
<section class="detail" id="FUNCTION_APPLY">
<h3>FUNCTION_APPLY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FUNCTION_APPLY</span></div>
</section>
</li>
<li>
<section class="detail" id="PREDICATE_TEST">
<h3>PREDICATE_TEST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PREDICATE_TEST</span></div>
</section>
</li>
<li>
<section class="detail" id="BI_PREDICATE_TEST">
<h3>BI_PREDICATE_TEST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BI_PREDICATE_TEST</span></div>
</section>
</li>
<li>
<section class="detail" id="CONSUMER_ACCEPT">
<h3>CONSUMER_ACCEPT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CONSUMER_ACCEPT</span></div>
</section>
</li>
<li>
<section class="detail" id="TYPED_GET_ELEMENT_TYPE">
<h3>TYPED_GET_ELEMENT_TYPE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TYPED_GET_ELEMENT_TYPE</span></div>
</section>
</li>
<li>
<section class="detail" id="BINDABLE_BIND">
<h3>BINDABLE_BIND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BINDABLE_BIND</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_GET_DATE2">
<h3>RESULT_SET_GET_DATE2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_GET_DATE2</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_GET_TIME2">
<h3>RESULT_SET_GET_TIME2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_GET_TIME2</span></div>
</section>
</li>
<li>
<section class="detail" id="RESULT_SET_GET_TIMESTAMP2">
<h3>RESULT_SET_GET_TIMESTAMP2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RESULT_SET_GET_TIMESTAMP2</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_ZONE_GET_OFFSET">
<h3>TIME_ZONE_GET_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_ZONE_GET_OFFSET</span></div>
</section>
</li>
<li>
<section class="detail" id="LONG_VALUE">
<h3>LONG_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LONG_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARATOR_COMPARE">
<h3>COMPARATOR_COMPARE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARATOR_COMPARE</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTIONS_REVERSE_ORDER">
<h3>COLLECTIONS_REVERSE_ORDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTIONS_REVERSE_ORDER</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTIONS_EMPTY_LIST">
<h3>COLLECTIONS_EMPTY_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTIONS_EMPTY_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTIONS_SINGLETON_LIST">
<h3>COLLECTIONS_SINGLETON_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTIONS_SINGLETON_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_SIZE">
<h3>COLLECTION_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTION_SIZE</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP_CLEAR">
<h3>MAP_CLEAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAP_CLEAR</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP_GET">
<h3>MAP_GET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAP_GET</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP_GET_OR_DEFAULT">
<h3>MAP_GET_OR_DEFAULT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAP_GET_OR_DEFAULT</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP_PUT">
<h3>MAP_PUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAP_PUT</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_ADD">
<h3>COLLECTION_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTION_ADD</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_ADDALL">
<h3>COLLECTION_ADDALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTION_ADDALL</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_RETAIN_ALL">
<h3>COLLECTION_RETAIN_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLECTION_RETAIN_ALL</span></div>
</section>
</li>
<li>
<section class="detail" id="LIST_GET">
<h3>LIST_GET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIST_GET</span></div>
</section>
</li>
<li>
<section class="detail" id="ITERATOR_HAS_NEXT">
<h3>ITERATOR_HAS_NEXT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ITERATOR_HAS_NEXT</span></div>
</section>
</li>
<li>
<section class="detail" id="ITERATOR_NEXT">
<h3>ITERATOR_NEXT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ITERATOR_NEXT</span></div>
</section>
</li>
<li>
<section class="detail" id="MATH_MAX">
<h3>MATH_MAX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATH_MAX</span></div>
</section>
</li>
<li>
<section class="detail" id="MATH_MIN">
<h3>MATH_MIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MATH_MIN</span></div>
</section>
</li>
<li>
<section class="detail" id="SORTED_MULTI_MAP_PUT_MULTI">
<h3>SORTED_MULTI_MAP_PUT_MULTI</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SORTED_MULTI_MAP_PUT_MULTI</span></div>
</section>
</li>
<li>
<section class="detail" id="SORTED_MULTI_MAP_ARRAYS">
<h3>SORTED_MULTI_MAP_ARRAYS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SORTED_MULTI_MAP_ARRAYS</span></div>
</section>
</li>
<li>
<section class="detail" id="SORTED_MULTI_MAP_SINGLETON">
<h3>SORTED_MULTI_MAP_SINGLETON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SORTED_MULTI_MAP_SINGLETON</span></div>
</section>
</li>
<li>
<section class="detail" id="BINARY_SEARCH5_LOWER">
<h3>BINARY_SEARCH5_LOWER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BINARY_SEARCH5_LOWER</span></div>
</section>
</li>
<li>
<section class="detail" id="BINARY_SEARCH5_UPPER">
<h3>BINARY_SEARCH5_UPPER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BINARY_SEARCH5_UPPER</span></div>
</section>
</li>
<li>
<section class="detail" id="BINARY_SEARCH6_LOWER">
<h3>BINARY_SEARCH6_LOWER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BINARY_SEARCH6_LOWER</span></div>
</section>
</li>
<li>
<section class="detail" id="BINARY_SEARCH6_UPPER">
<h3>BINARY_SEARCH6_UPPER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BINARY_SEARCH6_UPPER</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_ITEM">
<h3>ARRAY_ITEM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ARRAY_ITEM</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP_ITEM">
<h3>MAP_ITEM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAP_ITEM</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_ITEM">
<h3>ANY_ITEM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ANY_ITEM</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LOWER</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ASCII</span></div>
</section>
</li>
<li>
<section class="detail" id="CHAR_FROM_ASCII">
<h3>CHAR_FROM_ASCII</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CHAR_FROM_ASCII</span></div>
</section>
</li>
<li>
<section class="detail" id="CHAR_FROM_UTF8">
<h3>CHAR_FROM_UTF8</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CHAR_FROM_UTF8</span></div>
</section>
</li>
<li>
<section class="detail" id="REPEAT">
<h3>REPEAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REPEAT</span></div>
</section>
</li>
<li>
<section class="detail" id="SPACE">
<h3>SPACE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SPACE</span></div>
</section>
</li>
<li>
<section class="detail" id="SOUNDEX">
<h3>SOUNDEX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SOUNDEX</span></div>
</section>
</li>
<li>
<section class="detail" id="STRCMP">
<h3>STRCMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRCMP</span></div>
</section>
</li>
<li>
<section class="detail" id="DIFFERENCE">
<h3>DIFFERENCE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DIFFERENCE</span></div>
</section>
</li>
<li>
<section class="detail" id="REVERSE">
<h3>REVERSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REVERSE</span></div>
</section>
</li>
<li>
<section class="detail" id="LEFT">
<h3>LEFT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LEFT</span></div>
</section>
</li>
<li>
<section class="detail" id="RIGHT">
<h3>RIGHT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RIGHT</span></div>
</section>
</li>
<li>
<section class="detail" id="TO_BASE64">
<h3>TO_BASE64</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TO_BASE64</span></div>
</section>
</li>
<li>
<section class="detail" id="FROM_BASE64">
<h3>FROM_BASE64</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FROM_BASE64</span></div>
</section>
</li>
<li>
<section class="detail" id="MD5">
<h3>MD5</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MD5</span></div>
</section>
</li>
<li>
<section class="detail" id="SHA1">
<h3>SHA1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SHA1</span></div>
</section>
</li>
<li>
<section class="detail" id="THROW_UNLESS">
<h3>THROW_UNLESS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">THROW_UNLESS</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPRESS">
<h3>COMPRESS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPRESS</span></div>
</section>
</li>
<li>
<section class="detail" id="EXTRACT_VALUE">
<h3>EXTRACT_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXTRACT_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="XML_TRANSFORM">
<h3>XML_TRANSFORM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">XML_TRANSFORM</span></div>
</section>
</li>
<li>
<section class="detail" id="EXTRACT_XML">
<h3>EXTRACT_XML</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXTRACT_XML</span></div>
</section>
</li>
<li>
<section class="detail" id="EXISTS_NODE">
<h3>EXISTS_NODE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXISTS_NODE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSONIZE">
<h3>JSONIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSONIZE</span></div>
</section>
</li>
<li>
<section class="detail" id="DEJSONIZE">
<h3>DEJSONIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DEJSONIZE</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_VALUE_EXPRESSION</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_API_COMMON_SYNTAX">
<h3>JSON_API_COMMON_SYNTAX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_API_COMMON_SYNTAX</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_OBJECT</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_TYPE">
<h3>JSON_TYPE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_TYPE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_DEPTH">
<h3>JSON_DEPTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_DEPTH</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_KEYS">
<h3>JSON_KEYS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_KEYS</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_INSERT">
<h3>JSON_INSERT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_INSERT</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_PRETTY">
<h3>JSON_PRETTY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_PRETTY</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_LENGTH">
<h3>JSON_LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_LENGTH</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_REPLACE">
<h3>JSON_REPLACE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_REPLACE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_REMOVE">
<h3>JSON_REMOVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_REMOVE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_STORAGE_SIZE">
<h3>JSON_STORAGE_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_STORAGE_SIZE</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_SET">
<h3>JSON_SET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_SET</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_OBJECTAGG_ADD">
<h3>JSON_OBJECTAGG_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_OBJECTAGG_ADD</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="JSON_ARRAYAGG_ADD">
<h3>JSON_ARRAYAGG_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JSON_ARRAYAGG_ADD</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_JSON_SCALAR</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GEOM_FROM_EWKT">
<h3>ST_GEOM_FROM_EWKT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ST_GEOM_FROM_EWKT</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INITCAP</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SUBSTRING</span></div>
</section>
</li>
<li>
<section class="detail" id="LPAD">
<h3>LPAD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LPAD</span></div>
</section>
</li>
<li>
<section class="detail" id="RPAD">
<h3>RPAD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RPAD</span></div>
</section>
</li>
<li>
<section class="detail" id="STARTS_WITH">
<h3>STARTS_WITH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STARTS_WITH</span></div>
</section>
</li>
<li>
<section class="detail" id="ENDS_WITH">
<h3>ENDS_WITH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ENDS_WITH</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">OCTET_LENGTH</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CHAR_LENGTH</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_CONCAT">
<h3>STRING_CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_CONCAT</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTI_STRING_CONCAT">
<h3>MULTI_STRING_CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTI_STRING_CONCAT</span></div>
</section>
</li>
<li>
<section class="detail" id="FLOOR_DIV">
<h3>FLOOR_DIV</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FLOOR_DIV</span></div>
</section>
</li>
<li>
<section class="detail" id="FLOOR_MOD">
<h3>FLOOR_MOD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FLOOR_MOD</span></div>
</section>
</li>
<li>
<section class="detail" id="ADD_MONTHS">
<h3>ADD_MONTHS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ADD_MONTHS</span></div>
</section>
</li>
<li>
<section class="detail" id="ADD_MONTHS_INT">
<h3>ADD_MONTHS_INT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ADD_MONTHS_INT</span></div>
</section>
</li>
<li>
<section class="detail" id="SUBTRACT_MONTHS">
<h3>SUBTRACT_MONTHS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SUBTRACT_MONTHS</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FLOOR</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CEIL</span></div>
</section>
</li>
<li>
<section class="detail" id="COSH">
<h3>COSH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COSH</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">OVERLAY</span></div>
</section>
</li>
<li>
<section class="detail" id="OVERLAY3">
<h3>OVERLAY3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">OVERLAY3</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">POSITION</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RAND</span></div>
</section>
</li>
<li>
<section class="detail" id="RAND_SEED">
<h3>RAND_SEED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RAND_SEED</span></div>
</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RAND_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="RAND_INTEGER_SEED">
<h3>RAND_INTEGER_SEED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RAND_INTEGER_SEED</span></div>
</section>
</li>
<li>
<section class="detail" id="TANH">
<h3>TANH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TANH</span></div>
</section>
</li>
<li>
<section class="detail" id="SINH">
<h3>SINH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SINH</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TRUNCATE</span></div>
</section>
</li>
<li>
<section class="detail" id="TRUNCATE_OR_PAD">
<h3>TRUNCATE_OR_PAD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TRUNCATE_OR_PAD</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TRIM</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REPLACE</span></div>
</section>
</li>
<li>
<section class="detail" id="TRANSLATE3">
<h3>TRANSLATE3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TRANSLATE3</span></div>
</section>
</li>
<li>
<section class="detail" id="LTRIM">
<h3>LTRIM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LTRIM</span></div>
</section>
</li>
<li>
<section class="detail" id="RTRIM">
<h3>RTRIM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RTRIM</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LIKE</span></div>
</section>
</li>
<li>
<section class="detail" id="ILIKE">
<h3>ILIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ILIKE</span></div>
</section>
</li>
<li>
<section class="detail" id="RLIKE">
<h3>RLIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">RLIKE</span></div>
</section>
</li>
<li>
<section class="detail" id="SIMILAR">
<h3>SIMILAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SIMILAR</span></div>
</section>
</li>
<li>
<section class="detail" id="POSIX_REGEX">
<h3>POSIX_REGEX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">POSIX_REGEX</span></div>
</section>
</li>
<li>
<section class="detail" id="REGEXP_REPLACE3">
<h3>REGEXP_REPLACE3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REGEXP_REPLACE3</span></div>
</section>
</li>
<li>
<section class="detail" id="REGEXP_REPLACE4">
<h3>REGEXP_REPLACE4</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REGEXP_REPLACE4</span></div>
</section>
</li>
<li>
<section class="detail" id="REGEXP_REPLACE5">
<h3>REGEXP_REPLACE5</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REGEXP_REPLACE5</span></div>
</section>
</li>
<li>
<section class="detail" id="REGEXP_REPLACE6">
<h3>REGEXP_REPLACE6</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">REGEXP_REPLACE6</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_NOT_FALSE</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NOT</span></div>
</section>
</li>
<li>
<section class="detail" id="LESSER">
<h3>LESSER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LESSER</span></div>
</section>
</li>
<li>
<section class="detail" id="GREATER">
<h3>GREATER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GREATER</span></div>
</section>
</li>
<li>
<section class="detail" id="LT_NULLABLE">
<h3>LT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LT_NULLABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="GT_NULLABLE">
<h3>GT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GT_NULLABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="LT">
<h3>LT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LT</span></div>
</section>
</li>
<li>
<section class="detail" id="GT">
<h3>GT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">GT</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BIT_AND</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BIT_OR</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BIT_XOR</span></div>
</section>
</li>
<li>
<section class="detail" id="MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION">
<h3>MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION</span></div>
</section>
</li>
<li>
<section class="detail" id="SCANNABLE_TABLE_SCAN">
<h3>SCANNABLE_TABLE_SCAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCANNABLE_TABLE_SCAN</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_BOOLEAN">
<h3>STRING_TO_BOOLEAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_BOOLEAN</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERNAL_TO_DATE">
<h3>INTERNAL_TO_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERNAL_TO_DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERNAL_TO_TIME">
<h3>INTERNAL_TO_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERNAL_TO_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERNAL_TO_TIMESTAMP">
<h3>INTERNAL_TO_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERNAL_TO_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_DATE">
<h3>STRING_TO_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_TIME">
<h3>STRING_TO_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_TIMESTAMP">
<h3>STRING_TO_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_TIME_WITH_LOCAL_TIME_ZONE">
<h3>STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE">
<h3>TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE">
<h3>STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE">
<h3>TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_WITH_LOCAL_TIME_ZONE_TO_TIME">
<h3>TIME_WITH_LOCAL_TIME_ZONE_TO_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_WITH_LOCAL_TIME_ZONE_TO_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP">
<h3>TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE">
<h3>TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_WITH_LOCAL_TIME_ZONE_TO_STRING">
<h3>TIME_WITH_LOCAL_TIME_ZONE_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_WITH_LOCAL_TIME_ZONE_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE">
<h3>TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME">
<h3>TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE">
<h3>TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP">
<h3>TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING">
<h3>TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_DATE_TO_STRING">
<h3>UNIX_DATE_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_DATE_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_TIME_TO_STRING">
<h3>UNIX_TIME_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_TIME_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_TIMESTAMP_TO_STRING">
<h3>UNIX_TIMESTAMP_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_TIMESTAMP_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_YEAR_MONTH_TO_STRING">
<h3>INTERVAL_YEAR_MONTH_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERVAL_YEAR_MONTH_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_DAY_TIME_TO_STRING">
<h3>INTERVAL_DAY_TIME_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">INTERVAL_DAY_TIME_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_DATE_EXTRACT">
<h3>UNIX_DATE_EXTRACT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_DATE_EXTRACT</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_DATE_FLOOR">
<h3>UNIX_DATE_FLOOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_DATE_FLOOR</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_DATE_CEIL">
<h3>UNIX_DATE_CEIL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_DATE_CEIL</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_TIMESTAMP_FLOOR">
<h3>UNIX_TIMESTAMP_FLOOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_TIMESTAMP_FLOOR</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIX_TIMESTAMP_CEIL">
<h3>UNIX_TIMESTAMP_CEIL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIX_TIMESTAMP_CEIL</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_DATE_ADD">
<h3>CUSTOM_DATE_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_DATE_ADD</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_DATE_DIFF">
<h3>CUSTOM_DATE_DIFF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_DATE_DIFF</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_DATE_FLOOR">
<h3>CUSTOM_DATE_FLOOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_DATE_FLOOR</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_DATE_CEIL">
<h3>CUSTOM_DATE_CEIL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_DATE_CEIL</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_TIMESTAMP_ADD">
<h3>CUSTOM_TIMESTAMP_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_TIMESTAMP_ADD</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_TIMESTAMP_DIFF">
<h3>CUSTOM_TIMESTAMP_DIFF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_TIMESTAMP_DIFF</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_TIMESTAMP_FLOOR">
<h3>CUSTOM_TIMESTAMP_FLOOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_TIMESTAMP_FLOOR</span></div>
</section>
</li>
<li>
<section class="detail" id="CUSTOM_TIMESTAMP_CEIL">
<h3>CUSTOM_TIMESTAMP_CEIL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUSTOM_TIMESTAMP_CEIL</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TO_DATE">
<h3>TIMESTAMP_TO_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_TO_DATE</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LAST_DAY</span></div>
</section>
</li>
<li>
<section class="detail" id="DAYNAME_WITH_TIMESTAMP">
<h3>DAYNAME_WITH_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DAYNAME_WITH_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="DAYNAME_WITH_DATE">
<h3>DAYNAME_WITH_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DAYNAME_WITH_DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="MONTHNAME_WITH_TIMESTAMP">
<h3>MONTHNAME_WITH_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MONTHNAME_WITH_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="MONTHNAME_WITH_DATE">
<h3>MONTHNAME_WITH_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MONTHNAME_WITH_DATE</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CURRENT_TIMESTAMP</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CURRENT_TIME</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CURRENT_DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="LOCAL_TIMESTAMP">
<h3>LOCAL_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LOCAL_TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="LOCAL_TIME">
<h3>LOCAL_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LOCAL_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_ZONE">
<h3>TIME_ZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_ZONE</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">USER</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SYSTEM_USER</span></div>
</section>
</li>
<li>
<section class="detail" id="LOCALE">
<h3>LOCALE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LOCALE</span></div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_TO_STRING">
<h3>BOOLEAN_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BOOLEAN_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="JDBC_ARRAY_TO_LIST">
<h3>JDBC_ARRAY_TO_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">JDBC_ARRAY_TO_LIST</span></div>
</section>
</li>
<li>
<section class="detail" id="OBJECT_TO_STRING">
<h3>OBJECT_TO_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">OBJECT_TO_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="OBJECTS_EQUAL">
<h3>OBJECTS_EQUAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">OBJECTS_EQUAL</span></div>
</section>
</li>
<li>
<section class="detail" id="HASH">
<h3>HASH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">HASH</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE">
<h3>COMPARE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE_NULLS_FIRST">
<h3>COMPARE_NULLS_FIRST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE_NULLS_FIRST</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE_NULLS_LAST">
<h3>COMPARE_NULLS_LAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE_NULLS_LAST</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE2">
<h3>COMPARE2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE2</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE_NULLS_FIRST2">
<h3>COMPARE_NULLS_FIRST2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE_NULLS_FIRST2</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE_NULLS_LAST2">
<h3>COMPARE_NULLS_LAST2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE_NULLS_LAST2</span></div>
</section>
</li>
<li>
<section class="detail" id="ROUND_LONG">
<h3>ROUND_LONG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ROUND_LONG</span></div>
</section>
</li>
<li>
<section class="detail" id="ROUND_INT">
<h3>ROUND_INT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ROUND_INT</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_TO_INT">
<h3>DATE_TO_INT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATE_TO_INT</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_TO_INT_OFFSET">
<h3>DATE_TO_INT_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATE_TO_INT_OFFSET</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_TO_INT_OPTIONAL">
<h3>DATE_TO_INT_OPTIONAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATE_TO_INT_OPTIONAL</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_TO_INT_OPTIONAL_OFFSET">
<h3>DATE_TO_INT_OPTIONAL_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATE_TO_INT_OPTIONAL_OFFSET</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_TO_INT">
<h3>TIME_TO_INT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_TO_INT</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_TO_INT_OPTIONAL">
<h3>TIME_TO_INT_OPTIONAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIME_TO_INT_OPTIONAL</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TO_LONG">
<h3>TIMESTAMP_TO_LONG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_TO_LONG</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TO_LONG_OFFSET">
<h3>TIMESTAMP_TO_LONG_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_TO_LONG_OFFSET</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TO_LONG_OPTIONAL">
<h3>TIMESTAMP_TO_LONG_OPTIONAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_TO_LONG_OPTIONAL</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TO_LONG_OPTIONAL_OFFSET">
<h3>TIMESTAMP_TO_LONG_OPTIONAL_OFFSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TIMESTAMP_TO_LONG_OPTIONAL_OFFSET</span></div>
</section>
</li>
<li>
<section class="detail" id="SEQUENCE_CURRENT_VALUE">
<h3>SEQUENCE_CURRENT_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SEQUENCE_CURRENT_VALUE</span></div>
</section>
</li>
<li>
<section class="detail" id="SEQUENCE_NEXT_VALUE">
<h3>SEQUENCE_NEXT_VALUE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SEQUENCE_NEXT_VALUE</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SLICE</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ELEMENT</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MEMBER_OF</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_INTERSECT_DISTINCT</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_INTERSECT_ALL">
<h3>MULTISET_INTERSECT_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_INTERSECT_ALL</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_EXCEPT_DISTINCT</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_EXCEPT_ALL">
<h3>MULTISET_EXCEPT_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_EXCEPT_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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_UNION_DISTINCT</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_UNION_ALL">
<h3>MULTISET_UNION_ALL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MULTISET_UNION_ALL</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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_EMPTY</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SUBMULTISET_OF</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_REVERSE">
<h3>ARRAY_REVERSE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ARRAY_REVERSE</span></div>
</section>
</li>
<li>
<section class="detail" id="SELECTIVITY">
<h3>SELECTIVITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SELECTIVITY</span></div>
</section>
</li>
<li>
<section class="detail" id="UNIQUE_KEYS">
<h3>UNIQUE_KEYS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">UNIQUE_KEYS</span></div>
</section>
</li>
<li>
<section class="detail" id="AVERAGE_ROW_SIZE">
<h3>AVERAGE_ROW_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AVERAGE_ROW_SIZE</span></div>
</section>
</li>
<li>
<section class="detail" id="AVERAGE_COLUMN_SIZES">
<h3>AVERAGE_COLUMN_SIZES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AVERAGE_COLUMN_SIZES</span></div>
</section>
</li>
<li>
<section class="detail" id="IS_PHASE_TRANSITION">
<h3>IS_PHASE_TRANSITION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">IS_PHASE_TRANSITION</span></div>
</section>
</li>
<li>
<section class="detail" id="SPLIT_COUNT">
<h3>SPLIT_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SPLIT_COUNT</span></div>
</section>
</li>
<li>
<section class="detail" id="LOWER_BOUND_COST">
<h3>LOWER_BOUND_COST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LOWER_BOUND_COST</span></div>
</section>
</li>
<li>
<section class="detail" id="MEMORY">
<h3>MEMORY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MEMORY</span></div>
</section>
</li>
<li>
<section class="detail" id="CUMULATIVE_MEMORY_WITHIN_PHASE">
<h3>CUMULATIVE_MEMORY_WITHIN_PHASE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUMULATIVE_MEMORY_WITHIN_PHASE</span></div>
</section>
</li>
<li>
<section class="detail" id="CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT">
<h3>CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT</span></div>
</section>
</li>
<li>
<section class="detail" id="COLUMN_UNIQUENESS">
<h3>COLUMN_UNIQUENESS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLUMN_UNIQUENESS</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLATIONS">
<h3>COLLATIONS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLLATIONS</span></div>
</section>
</li>
<li>
<section class="detail" id="DISTRIBUTION">
<h3>DISTRIBUTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DISTRIBUTION</span></div>
</section>
</li>
<li>
<section class="detail" id="NODE_TYPES">
<h3>NODE_TYPES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NODE_TYPES</span></div>
</section>
</li>
<li>
<section class="detail" id="ROW_COUNT">
<h3>ROW_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ROW_COUNT</span></div>
</section>
</li>
<li>
<section class="detail" id="MAX_ROW_COUNT">
<h3>MAX_ROW_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MAX_ROW_COUNT</span></div>
</section>
</li>
<li>
<section class="detail" id="MIN_ROW_COUNT">
<h3>MIN_ROW_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">MIN_ROW_COUNT</span></div>
</section>
</li>
<li>
<section class="detail" id="DISTINCT_ROW_COUNT">
<h3>DISTINCT_ROW_COUNT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DISTINCT_ROW_COUNT</span></div>
</section>
</li>
<li>
<section class="detail" id="PERCENTAGE_ORIGINAL_ROWS">
<h3>PERCENTAGE_ORIGINAL_ROWS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PERCENTAGE_ORIGINAL_ROWS</span></div>
</section>
</li>
<li>
<section class="detail" id="POPULATION_SIZE">
<h3>POPULATION_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">POPULATION_SIZE</span></div>
</section>
</li>
<li>
<section class="detail" id="COLUMN_ORIGIN">
<h3>COLUMN_ORIGIN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COLUMN_ORIGIN</span></div>
</section>
</li>
<li>
<section class="detail" id="EXPRESSION_LINEAGE">
<h3>EXPRESSION_LINEAGE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXPRESSION_LINEAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="TABLE_REFERENCES">
<h3>TABLE_REFERENCES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TABLE_REFERENCES</span></div>
</section>
</li>
<li>
<section class="detail" id="CUMULATIVE_COST">
<h3>CUMULATIVE_COST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CUMULATIVE_COST</span></div>
</section>
</li>
<li>
<section class="detail" id="NON_CUMULATIVE_COST">
<h3>NON_CUMULATIVE_COST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">NON_CUMULATIVE_COST</span></div>
</section>
</li>
<li>
<section class="detail" id="PREDICATES">
<h3>PREDICATES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">PREDICATES</span></div>
</section>
</li>
<li>
<section class="detail" id="ALL_PREDICATES">
<h3>ALL_PREDICATES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">ALL_PREDICATES</span></div>
</section>
</li>
<li>
<section class="detail" id="EXPLAIN_VISIBILITY">
<h3>EXPLAIN_VISIBILITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">EXPLAIN_VISIBILITY</span></div>
</section>
</li>
<li>
<section class="detail" id="SCALAR_EXECUTE1">
<h3>SCALAR_EXECUTE1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCALAR_EXECUTE1</span></div>
</section>
</li>
<li>
<section class="detail" id="SCALAR_EXECUTE2">
<h3>SCALAR_EXECUTE2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SCALAR_EXECUTE2</span></div>
</section>
</li>
<li>
<section class="detail" id="CONTEXT_VALUES">
<h3>CONTEXT_VALUES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CONTEXT_VALUES</span></div>
</section>
</li>
<li>
<section class="detail" id="CONTEXT_ROOT">
<h3>CONTEXT_ROOT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">CONTEXT_ROOT</span></div>
</section>
</li>
<li>
<section class="detail" id="FUNCTION_CONTEXTS_OF">
<h3>FUNCTION_CONTEXTS_OF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">FUNCTION_CONTEXTS_OF</span></div>
</section>
</li>
<li>
<section class="detail" id="DATA_CONTEXT_GET_QUERY_PROVIDER">
<h3>DATA_CONTEXT_GET_QUERY_PROVIDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">DATA_CONTEXT_GET_QUERY_PROVIDER</span></div>
</section>
</li>
<li>
<section class="detail" id="METADATA_REL">
<h3>METADATA_REL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">METADATA_REL</span></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="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">STRUCT_ACCESS</span></div>
</section>
</li>
<li>
<section class="detail" id="SOURCE_SORTER">
<h3>SOURCE_SORTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SOURCE_SORTER</span></div>
</section>
</li>
<li>
<section class="detail" id="BASIC_LAZY_ACCUMULATOR">
<h3>BASIC_LAZY_ACCUMULATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BASIC_LAZY_ACCUMULATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="LAZY_AGGREGATE_LAMBDA_FACTORY">
<h3>LAZY_AGGREGATE_LAMBDA_FACTORY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">LAZY_AGGREGATE_LAMBDA_FACTORY</span></div>
</section>
</li>
<li>
<section class="detail" id="BASIC_AGGREGATE_LAMBDA_FACTORY">
<h3>BASIC_AGGREGATE_LAMBDA_FACTORY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BASIC_AGGREGATE_LAMBDA_FACTORY</span></div>
</section>
</li>
<li>
<section class="detail" id="AGG_LAMBDA_FACTORY_ACC_INITIALIZER">
<h3>AGG_LAMBDA_FACTORY_ACC_INITIALIZER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AGG_LAMBDA_FACTORY_ACC_INITIALIZER</span></div>
</section>
</li>
<li>
<section class="detail" id="AGG_LAMBDA_FACTORY_ACC_ADDER">
<h3>AGG_LAMBDA_FACTORY_ACC_ADDER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AGG_LAMBDA_FACTORY_ACC_ADDER</span></div>
</section>
</li>
<li>
<section class="detail" id="AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR">
<h3>AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR</span></div>
</section>
</li>
<li>
<section class="detail" id="AGG_LAMBDA_FACTORY_ACC_SINGLE_GROUP_RESULT_SELECTOR">
<h3>AGG_LAMBDA_FACTORY_ACC_SINGLE_GROUP_RESULT_SELECTOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">AGG_LAMBDA_FACTORY_ACC_SINGLE_GROUP_RESULT_SELECTOR</span></div>
</section>
</li>
<li>
<section class="detail" id="TUMBLING">
<h3>TUMBLING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">TUMBLING</span></div>
</section>
</li>
<li>
<section class="detail" id="HOPPING">
<h3>HOPPING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">HOPPING</span></div>
</section>
</li>
<li>
<section class="detail" id="SESSIONIZATION">
<h3>SESSIONIZATION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">SESSIONIZATION</span></div>
</section>
</li>
<li>
<section class="detail" id="BIG_DECIMAL_ADD">
<h3>BIG_DECIMAL_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BIG_DECIMAL_ADD</span></div>
</section>
</li>
<li>
<section class="detail" id="BIG_DECIMAL_NEGATE">
<h3>BIG_DECIMAL_NEGATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">BIG_DECIMAL_NEGATE</span></div>
</section>
</li>
<li>
<section class="detail" id="COMPARE_TO">
<h3>COMPARE_TO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">COMPARE_TO</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="method">
<h3>method</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a></span>&nbsp;<span class="element-name">method</span></div>
</section>
</li>
<li>
<section class="detail" id="constructor">
<h3>constructor</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a></span>&nbsp;<span class="element-name">constructor</span></div>
</section>
</li>
<li>
<section class="detail" id="field">
<h3>field</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html" title="class or interface in java.lang.reflect" class="external-link">Field</a></span>&nbsp;<span class="element-name">field</span></div>
</section>
</li>
<li>
<section class="detail" id="MAP">
<h3>MAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableMap&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>,<wbr><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>&gt;</span>&nbsp;<span class="element-name">MAP</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="values()">
<h3>values</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a>[]</span>&nbsp;<span class="element-name">values</span>()</div>
<div class="block">Returns an array containing the constants of this enum type, in
the order they are declared.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>an array containing the constants of this enum type, in the order they are declared</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="valueOf(java.lang.String)">
<h3>valueOf</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BuiltInMethod.html" title="enum in org.apache.calcite.util">BuiltInMethod</a></span>&nbsp;<span class="element-name">valueOf</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Returns the enum constant of this type with the specified name.
The string must match <i>exactly</i> an identifier used to declare an
enum constant in this type.  (Extraneous whitespace characters are 
not permitted.)</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - the name of the enum constant to be returned.</dd>
<dt>Returns:</dt>
<dd>the enum constant with the specified name</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if this enum type has no constant with the specified name</dd>
<dd><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link">NullPointerException</a></code> - if the argument is null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMethodName()">
<h3>getMethodName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getMethodName</span>()</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-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
