<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlLibraryOperators (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.sql.fun, class: SqlLibraryOperators">
<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 pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li>Method</li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql.fun</a></div>
<h1 title="Class SqlLibraryOperators" class="title">Class SqlLibraryOperators</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">org.apache.calcite.sql.fun.SqlLibraryOperators</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">SqlLibraryOperators</span>
<span class="extends-implements">extends <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></span></div>
<div class="block">Defines functions and operators that are not part of standard SQL but
 belong to one or more other dialects of SQL.

 <p>They are read by <a href="SqlLibraryOperatorTableFactory.html" title="class in org.apache.calcite.sql.fun"><code>SqlLibraryOperatorTableFactory</code></a> into instances
 of <a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql"><code>SqlOperatorTable</code></a> that contain functions and operators for
 particular libraries.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#AGGREGATE" class="member-name-link">AGGREGATE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "AGGREGATE(m)" aggregate function;
 aggregates a measure column according to the measure's rollup strategy.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARRAY_AGG" class="member-name-link">ARRAY_AGG</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "ARRAY_AGG(value [ ORDER BY ...])" aggregate function,
 in BigQuery and PostgreSQL, gathers values into arrays.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARRAY_CONCAT" class="member-name-link">ARRAY_CONCAT</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "ARRAY_CONCAT(array [, array]*)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARRAY_CONCAT_AGG" class="member-name-link">ARRAY_CONCAT_AGG</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "ARRAY_CONCAT_AGG(value [ ORDER BY ...])" aggregate function,
 in BigQuery and PostgreSQL, concatenates array values into arrays.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARRAY_LENGTH" class="member-name-link">ARRAY_LENGTH</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "ARRAY_LENGTH(array)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARRAY_REVERSE" class="member-name-link">ARRAY_REVERSE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "ARRAY_REVERSE(array)" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#BOOL_AND" class="member-name-link">BOOL_AND</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "BOOL_AND(condition)" aggregate function, PostgreSQL and Redshift's
 equivalent to <a href="SqlStdOperatorTable.html#EVERY"><code>SqlStdOperatorTable.EVERY</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BOOL_OR" class="member-name-link">BOOL_OR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "BOOL_OR(condition)" aggregate function, PostgreSQL and Redshift's
 equivalent to <a href="SqlStdOperatorTable.html#SOME"><code>SqlStdOperatorTable.SOME</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CHAR" class="member-name-link">CHAR</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "CHAR(n)" function; returns the character whose ASCII code is
 <code>n</code> % 256, or null if <code>n</code> &lt; 0.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CHR" class="member-name-link">CHR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "CHR(n)" function; returns the character whose UTF-8 code is
 <code>n</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CONCAT_FUNCTION" class="member-name-link">CONCAT_FUNCTION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "CONCAT(arg, ...)" function that concatenates strings.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CONCAT2" class="member-name-link">CONCAT2</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "CONCAT(arg0, arg1)" function that concatenates strings.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CONVERT_TIMEZONE" class="member-name-link">CONVERT_TIMEZONE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "CONVERT_TIMEZONE(tz1, tz2, datetime)" function;
 converts the timezone of <code>datetime</code> from <code>tz1</code> to <code>tz2</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#COSH" class="member-name-link">COSH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COUNTIF" class="member-name-link">COUNTIF</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "COUNTIF(condition) [OVER (...)]" function, in BigQuery,
 returns the count of TRUE values for expression.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#CURRENT_DATETIME" class="member-name-link">CURRENT_DATETIME</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "CURRENT_DATETIME([timezone])" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE" class="member-name-link">DATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DATE" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATE_FROM_UNIX_DATE" class="member-name-link">DATE_FROM_UNIX_DATE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "DATE_FROM_UNIX_DATE(integer)" function; returns a DATE value
 a given number of seconds after 1970-01-01.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE_PART" class="member-name-link">DATE_PART</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DATE_PART(timeUnit, datetime)" function
 (Databricks, Postgres, Redshift, Snowflake).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATE_SUB" class="member-name-link">DATE_SUB</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "DATE_SUB(date, interval)" function (BigQuery);
 subtracts interval from the date, independent of any time zone.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE_TRUNC" class="member-name-link">DATE_TRUNC</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DATE_TRUNC(date, timeUnit)" function (BigQuery);
 truncates a DATE value to the beginning of a timeUnit.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATEADD" class="member-name-link">DATEADD</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "DATEADD(timeUnit, numeric, datetime)" function
 (Microsoft SQL Server, Redshift, Snowflake).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATEDIFF" class="member-name-link">DATEDIFF</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DATEDIFF(timeUnit, datetime, datetime2)" function
 (Microsoft SQL Server, Redshift, Snowflake).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATEPART" class="member-name-link">DATEPART</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "DATEPART(timeUnit, datetime)" function
 (Microsoft SQL Server).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATETIME" class="member-name-link">DATETIME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DATETIME" function returns a Calcite
 <code>TIMESTAMP</code> (which BigQuery calls a <code>DATETIME</code>).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DAYNAME" class="member-name-link">DAYNAME</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "DAYNAME(datetime)" function; returns the name of the day of the week,
 in the current locale, of a TIMESTAMP or DATE argument.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DECODE" class="member-name-link">DECODE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "DECODE(v, v1, result1, [v2, result2, ...], resultN)" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#DIFFERENCE" class="member-name-link">DIFFERENCE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ENDS_WITH" class="member-name-link">ENDS_WITH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "ENDS_WITH(value1, value2)" function (BigQuery).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXTRACT_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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#FROM_BASE64" class="member-name-link">FROM_BASE64</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#GREATEST" class="member-name-link">GREATEST</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "GREATEST(value, value)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#GROUP_CONCAT" class="member-name-link">GROUP_CONCAT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "GROUP_CONCAT([DISTINCT] expr [, ...] [ORDER BY ...] [SEPARATOR sep])"
 aggregate function, MySQL's equivalent of
 <a href="SqlStdOperatorTable.html#LISTAGG"><code>SqlStdOperatorTable.LISTAGG</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#IF" class="member-name-link">IF</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "IF(condition, thenValue, elseValue)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#IFNULL" class="member-name-link">IFNULL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "IFNULL(value, value)" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#ILIKE" class="member-name-link">ILIKE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The case-insensitive variant of the LIKE operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INFIX_CAST" class="member-name-link">INFIX_CAST</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Infix "::" cast operator used by PostgreSQL, for example
 <code>'100'::INTEGER</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_INSERT" class="member-name-link">JSON_INSERT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_KEYS" class="member-name-link">JSON_KEYS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_LENGTH" class="member-name-link">JSON_LENGTH</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_PRETTY" class="member-name-link">JSON_PRETTY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#JSON_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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#JSON_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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LEAST" class="member-name-link">LEAST</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "LEAST(value, value)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LEFT" class="member-name-link">LEFT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LENGTH" class="member-name-link">LENGTH</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "LENGTH(string)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LOGICAL_AND" class="member-name-link">LOGICAL_AND</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "LOGICAL_AND(condition)" aggregate function, BigQuery's
 equivalent to <a href="SqlStdOperatorTable.html#EVERY"><code>SqlStdOperatorTable.EVERY</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LOGICAL_OR" class="member-name-link">LOGICAL_OR</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "LOGICAL_OR(condition)" aggregate function, BigQuery's
 equivalent to <a href="SqlStdOperatorTable.html#SOME"><code>SqlStdOperatorTable.SOME</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LPAD" class="member-name-link">LPAD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "LPAD(original_value, return_length[, pattern])" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#LTRIM" class="member-name-link">LTRIM</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "LTRIM(string)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MAX_BY" class="member-name-link">MAX_BY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "MAX_BY(value, comp)" aggregate function, Spark's
 equivalent to <a href="SqlStdOperatorTable.html#ARG_MAX"><code>SqlStdOperatorTable.ARG_MAX</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#MD5" class="member-name-link">MD5</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MIN_BY" class="member-name-link">MIN_BY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "MIN_BY(condition)" aggregate function, Spark's
 equivalent to <a href="SqlStdOperatorTable.html#ARG_MIN"><code>SqlStdOperatorTable.ARG_MIN</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#MONTHNAME" class="member-name-link">MONTHNAME</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "MONTHNAME(datetime)" function; returns the name of the month,
 in the current locale, of a TIMESTAMP or DATE argument.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NOT_ILIKE" class="member-name-link">NOT_ILIKE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The case-insensitive variant of the NOT LIKE operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#NOT_RLIKE" class="member-name-link">NOT_RLIKE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The regex variant of the NOT LIKE operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NULL_SAFE_EQUAL" class="member-name-link">NULL_SAFE_EQUAL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">NULL-safe "&lt;=&gt;" equal operator used by MySQL, for example
 <code>1&lt;=&gt;NULL</code>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlBasicFunction.html" title="class in org.apache.calcite.sql">SqlBasicFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#NVL" class="member-name-link">NVL</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "NVL(value, value)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#POW" class="member-name-link">POW</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#REGEXP_REPLACE" class="member-name-link">REGEXP_REPLACE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#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>static final <a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></code></div>
<div class="col-second even-row-color"><code><a href="#RLIKE" class="member-name-link">RLIKE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The regex variant of the LIKE operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RPAD" class="member-name-link">RPAD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "RPAD(original_value, return_length[, pattern])" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#RTRIM" class="member-name-link">RTRIM</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "RTRIM(string)" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SHA1" class="member-name-link">SHA1</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SINH" class="member-name-link">SINH</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SPACE" class="member-name-link">SPACE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STARTS_WITH" class="member-name-link">STARTS_WITH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "STARTS_WITH(value1, value2)" function (BigQuery).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRCMP" class="member-name-link">STRCMP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_AGG" class="member-name-link">STRING_AGG</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "STRING_AGG(value [, separator ] [ ORDER BY ...])" aggregate function,
 BigQuery and PostgreSQL's equivalent of
 <a href="SqlStdOperatorTable.html#LISTAGG"><code>SqlStdOperatorTable.LISTAGG</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SUBSTR_BIG_QUERY" class="member-name-link">SUBSTR_BIG_QUERY</a></code></div>
<div class="col-last even-row-color">
<div class="block">BigQuery's "SUBSTR(string, position [, substringLength ])" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SUBSTR_MYSQL" class="member-name-link">SUBSTR_MYSQL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">MySQL's "SUBSTR(string, position [, substringLength ])" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#SUBSTR_ORACLE" class="member-name-link">SUBSTR_ORACLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Oracle's "SUBSTR(string, position [, substringLength ])" function.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SUBSTR_POSTGRESQL" class="member-name-link">SUBSTR_POSTGRESQL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">PostgreSQL's "SUBSTR(string, position [, substringLength ])" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIME" class="member-name-link">TIME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIME" function.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIME_ADD" class="member-name-link">TIME_ADD</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIME_ADD(time, interval)" function (BigQuery);
 adds interval expression to the specified time expression.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIME_DIFF" class="member-name-link">TIME_DIFF</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIME_DIFF(time, time, timeUnit)" function (BigQuery);
 returns the number of timeUnit between the two time expressions.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIME_SUB" class="member-name-link">TIME_SUB</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIME_SUB(time, interval)" function (BigQuery);
 subtracts an interval from a time, independent of any time zone.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIME_TRUNC" class="member-name-link">TIME_TRUNC</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIME_TRUNC(time, timeUnit)" function (BigQuery);
 truncates a TIME value to the beginning of a timeUnit.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP" class="member-name-link">TIMESTAMP</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIMESTAMP" function returns a Calcite
 <code>TIMESTAMP WITH LOCAL TIME ZONE</code>
 (which BigQuery calls a <code>TIMESTAMP</code>).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_ADD2" class="member-name-link">TIMESTAMP_ADD2</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIMESTAMP_ADD(timestamp, interval)" function (BigQuery), the
 two-argument variant of the built-in
 <a href="SqlStdOperatorTable.html#TIMESTAMP_ADD"><code>TIMESTAMPADD</code></a> function, which has
 three arguments.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_DIFF3" class="member-name-link">TIMESTAMP_DIFF3</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIMESTAMP_DIFF(timestamp, timestamp, timeUnit)" function (BigQuery);
 returns the number of timeUnit between the two timestamp expressions.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_MICROS" class="member-name-link">TIMESTAMP_MICROS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIMESTAMP_MICROS(bigint)" function; returns a TIMESTAMP value
 a given number of micro-seconds after 1970-01-01 00:00:00.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_MILLIS" class="member-name-link">TIMESTAMP_MILLIS</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIMESTAMP_MILLIS(bigint)" function; returns a TIMESTAMP value
 a given number of milliseconds after 1970-01-01 00:00:00.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_SECONDS" class="member-name-link">TIMESTAMP_SECONDS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIMESTAMP_SECONDS(bigint)" function; returns a TIMESTAMP value
 a given number of seconds after 1970-01-01 00:00:00.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_SUB" class="member-name-link">TIMESTAMP_SUB</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TIMESTAMP_SUB(timestamp, interval)" function (BigQuery);
 subtracts an interval from a timestamp, independent of any time zone.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_TRUNC" class="member-name-link">TIMESTAMP_TRUNC</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TIMESTAMP_TRUNC(timestamp, timeUnit[, timeZone])" function (BigQuery);
 truncates a TIMESTAMP value to the beginning of a timeUnit.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#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>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TO_DATE" class="member-name-link">TO_DATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "TO_DATE(string1, string2)" function; casts string1
 to a DATE using the format specified in string2.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TO_TIMESTAMP" class="member-name-link">TO_TIMESTAMP</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "TO_TIMESTAMP(string1, string2)" function; casts string1
 to a TIMESTAMP using the format specified in string2.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TRANSLATE3" class="member-name-link">TRANSLATE3</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The <code>TRANSLATE(<i>string_expr</i>, <i>search_chars</i>,
 <i>replacement_chars</i>)</code> function returns <i>string_expr</i> with
 all occurrences of each character in <i>search_chars</i> replaced by its
 corresponding character in <i>replacement_chars</i>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#TRUNC" class="member-name-link">TRUNC</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UNIX_DATE" class="member-name-link">UNIX_DATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "UNIX_DATE(date)" function; returns the number of days since
 1970-01-01.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNIX_MICROS" class="member-name-link">UNIX_MICROS</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "UNIX_MICROS(bigint)" function; returns the number of microseconds
 since 1970-01-01 00:00:00.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#UNIX_MILLIS" class="member-name-link">UNIX_MILLIS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The "UNIX_MILLIS(bigint)" function; returns the number of milliseconds
 since 1970-01-01 00:00:00.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNIX_SECONDS" class="member-name-link">UNIX_SECONDS</a></code></div>
<div class="col-last even-row-color">
<div class="block">The "UNIX_SECONDS(bigint)" function; returns the number of seconds
 since 1970-01-01 00:00:00.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></code></div>
<div class="col-second odd-row-color"><code><a href="#XML_TRANSFORM" class="member-name-link">XML_TRANSFORM</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 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#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/Object.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/Object.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/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#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/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#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/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">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">AGGREGATE</span></div>
<div class="block">The "AGGREGATE(m)" aggregate function;
 aggregates a measure column according to the measure's rollup strategy.
 This is a Calcite-specific extension.

 <p>This operator is for SQL (and AST); for internal use (RexNode and
 Aggregate) use <code>AGG_M2M</code>.</div>
</section>
</li>
<li>
<section class="detail" id="CONVERT_TIMEZONE">
<h3>CONVERT_TIMEZONE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CONVERT_TIMEZONE</span></div>
<div class="block">The "CONVERT_TIMEZONE(tz1, tz2, datetime)" function;
 converts the timezone of <code>datetime</code> from <code>tz1</code> to <code>tz2</code>.
 This function is only on Redshift, but we list it in PostgreSQL
 because Redshift does not have its own library.</div>
</section>
</li>
<li>
<section class="detail" id="DATEADD">
<h3>DATEADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATEADD</span></div>
<div class="block">The "DATEADD(timeUnit, numeric, datetime)" function
 (Microsoft SQL Server, Redshift, Snowflake).</div>
</section>
</li>
<li>
<section class="detail" id="DATEDIFF">
<h3>DATEDIFF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATEDIFF</span></div>
<div class="block">The "DATEDIFF(timeUnit, datetime, datetime2)" function
 (Microsoft SQL Server, Redshift, Snowflake).

 <p>MySQL has "DATEDIFF(date, date2)" and "TIMEDIFF(time, time2)" functions
 but Calcite does not implement these because they have no "timeUnit"
 argument.</div>
</section>
</li>
<li>
<section class="detail" id="DATE_PART">
<h3>DATE_PART</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATE_PART</span></div>
<div class="block">The "DATE_PART(timeUnit, datetime)" function
 (Databricks, Postgres, Redshift, Snowflake).</div>
</section>
</li>
<li>
<section class="detail" id="DATE_SUB">
<h3>DATE_SUB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATE_SUB</span></div>
<div class="block">The "DATE_SUB(date, interval)" function (BigQuery);
 subtracts interval from the date, independent of any time zone.</div>
</section>
</li>
<li>
<section class="detail" id="DATEPART">
<h3>DATEPART</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATEPART</span></div>
<div class="block">The "DATEPART(timeUnit, datetime)" function
 (Microsoft SQL Server).</div>
</section>
</li>
<li>
<section class="detail" id="DECODE">
<h3>DECODE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DECODE</span></div>
<div class="block">The "DECODE(v, v1, result1, [v2, result2, ...], resultN)" function.</div>
</section>
</li>
<li>
<section class="detail" id="IF">
<h3>IF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">IF</span></div>
<div class="block">The "IF(condition, thenValue, elseValue)" function.</div>
</section>
</li>
<li>
<section class="detail" id="NVL">
<h3>NVL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlBasicFunction.html" title="class in org.apache.calcite.sql">SqlBasicFunction</a></span>&nbsp;<span class="element-name">NVL</span></div>
<div class="block">The "NVL(value, value)" function.</div>
</section>
</li>
<li>
<section class="detail" id="IFNULL">
<h3>IFNULL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">IFNULL</span></div>
<div class="block">The "IFNULL(value, value)" function.</div>
</section>
</li>
<li>
<section class="detail" id="LENGTH">
<h3>LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LENGTH</span></div>
<div class="block">The "LENGTH(string)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LPAD</span></div>
<div class="block">The "LPAD(original_value, return_length[, pattern])" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">RPAD</span></div>
<div class="block">The "RPAD(original_value, return_length[, pattern])" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LTRIM</span></div>
<div class="block">The "LTRIM(string)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">RTRIM</span></div>
<div class="block">The "RTRIM(string)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ENDS_WITH</span></div>
<div class="block">The "ENDS_WITH(value1, value2)" function (BigQuery).</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">STARTS_WITH</span></div>
<div class="block">The "STARTS_WITH(value1, value2)" function (BigQuery).</div>
</section>
</li>
<li>
<section class="detail" id="SUBSTR_BIG_QUERY">
<h3>SUBSTR_BIG_QUERY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SUBSTR_BIG_QUERY</span></div>
<div class="block">BigQuery's "SUBSTR(string, position [, substringLength ])" function.</div>
</section>
</li>
<li>
<section class="detail" id="SUBSTR_MYSQL">
<h3>SUBSTR_MYSQL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SUBSTR_MYSQL</span></div>
<div class="block">MySQL's "SUBSTR(string, position [, substringLength ])" function.</div>
</section>
</li>
<li>
<section class="detail" id="SUBSTR_ORACLE">
<h3>SUBSTR_ORACLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SUBSTR_ORACLE</span></div>
<div class="block">Oracle's "SUBSTR(string, position [, substringLength ])" function.

 <p>It has different semantics to standard SQL's
 <a href="SqlStdOperatorTable.html#SUBSTRING"><code>SqlStdOperatorTable.SUBSTRING</code></a> function:

 <ul>
   <li>If <code>substringLength</code> &le; 0, result is the empty string
   (Oracle would return null, because it treats the empty string as null,
   but Calcite does not have these semantics);
   <li>If <code>position</code> = 0, treat <code>position</code> as 1;
   <li>If <code>position</code> &lt; 0, treat <code>position</code> as
       "length(string) + position + 1".
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="SUBSTR_POSTGRESQL">
<h3>SUBSTR_POSTGRESQL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SUBSTR_POSTGRESQL</span></div>
<div class="block">PostgreSQL's "SUBSTR(string, position [, substringLength ])" function.</div>
</section>
</li>
<li>
<section class="detail" id="GREATEST">
<h3>GREATEST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">GREATEST</span></div>
<div class="block">The "GREATEST(value, value)" function.</div>
</section>
</li>
<li>
<section class="detail" id="LEAST">
<h3>LEAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LEAST</span></div>
<div class="block">The "LEAST(value, value)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TRANSLATE3</span></div>
<div class="block">The <code>TRANSLATE(<i>string_expr</i>, <i>search_chars</i>,
 <i>replacement_chars</i>)</code> function returns <i>string_expr</i> with
 all occurrences of each character in <i>search_chars</i> replaced by its
 corresponding character in <i>replacement_chars</i>.

 <p>It is not defined in the SQL standard, but occurs in Oracle and
 PostgreSQL.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_DEPTH</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_LENGTH</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_KEYS</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_PRETTY</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_STORAGE_SIZE</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_INSERT</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_REPLACE</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">JSON_SET</span></div>
</section>
</li>
<li>
<section class="detail" id="REGEXP_REPLACE">
<h3>REGEXP_REPLACE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">REGEXP_REPLACE</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">EXISTS_NODE</span></div>
</section>
</li>
<li>
<section class="detail" id="BOOL_AND">
<h3>BOOL_AND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">BOOL_AND</span></div>
<div class="block">The "BOOL_AND(condition)" aggregate function, PostgreSQL and Redshift's
 equivalent to <a href="SqlStdOperatorTable.html#EVERY"><code>SqlStdOperatorTable.EVERY</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="BOOL_OR">
<h3>BOOL_OR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">BOOL_OR</span></div>
<div class="block">The "BOOL_OR(condition)" aggregate function, PostgreSQL and Redshift's
 equivalent to <a href="SqlStdOperatorTable.html#SOME"><code>SqlStdOperatorTable.SOME</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="LOGICAL_AND">
<h3>LOGICAL_AND</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LOGICAL_AND</span></div>
<div class="block">The "LOGICAL_AND(condition)" aggregate function, BigQuery's
 equivalent to <a href="SqlStdOperatorTable.html#EVERY"><code>SqlStdOperatorTable.EVERY</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="LOGICAL_OR">
<h3>LOGICAL_OR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">LOGICAL_OR</span></div>
<div class="block">The "LOGICAL_OR(condition)" aggregate function, BigQuery's
 equivalent to <a href="SqlStdOperatorTable.html#SOME"><code>SqlStdOperatorTable.SOME</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="COUNTIF">
<h3>COUNTIF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">COUNTIF</span></div>
<div class="block">The "COUNTIF(condition) [OVER (...)]" function, in BigQuery,
 returns the count of TRUE values for expression.

 <p><code>COUNTIF(b)</code> is equivalent to
 <code>COUNT(*) FILTER (WHERE b)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_AGG">
<h3>ARRAY_AGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">ARRAY_AGG</span></div>
<div class="block">The "ARRAY_AGG(value [ ORDER BY ...])" aggregate function,
 in BigQuery and PostgreSQL, gathers values into arrays.</div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_CONCAT_AGG">
<h3>ARRAY_CONCAT_AGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">ARRAY_CONCAT_AGG</span></div>
<div class="block">The "ARRAY_CONCAT_AGG(value [ ORDER BY ...])" aggregate function,
 in BigQuery and PostgreSQL, concatenates array values into arrays.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_AGG">
<h3>STRING_AGG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">STRING_AGG</span></div>
<div class="block">The "STRING_AGG(value [, separator ] [ ORDER BY ...])" aggregate function,
 BigQuery and PostgreSQL's equivalent of
 <a href="SqlStdOperatorTable.html#LISTAGG"><code>SqlStdOperatorTable.LISTAGG</code></a>.

 <p><code>STRING_AGG(v, sep ORDER BY x, y)</code> is implemented by
 rewriting to <code>LISTAGG(v, sep) WITHIN GROUP (ORDER BY x, y)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="GROUP_CONCAT">
<h3>GROUP_CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">GROUP_CONCAT</span></div>
<div class="block">The "GROUP_CONCAT([DISTINCT] expr [, ...] [ORDER BY ...] [SEPARATOR sep])"
 aggregate function, MySQL's equivalent of
 <a href="SqlStdOperatorTable.html#LISTAGG"><code>SqlStdOperatorTable.LISTAGG</code></a>.

 <p><code>GROUP_CONCAT(v ORDER BY x, y SEPARATOR s)</code> is implemented by
 rewriting to <code>LISTAGG(v, s) WITHIN GROUP (ORDER BY x, y)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="MAX_BY">
<h3>MAX_BY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">MAX_BY</span></div>
<div class="block">The "MAX_BY(value, comp)" aggregate function, Spark's
 equivalent to <a href="SqlStdOperatorTable.html#ARG_MAX"><code>SqlStdOperatorTable.ARG_MAX</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="MIN_BY">
<h3>MIN_BY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlAggFunction.html" title="class in org.apache.calcite.sql">SqlAggFunction</a></span>&nbsp;<span class="element-name">MIN_BY</span></div>
<div class="block">The "MIN_BY(condition)" aggregate function, Spark's
 equivalent to <a href="SqlStdOperatorTable.html#ARG_MIN"><code>SqlStdOperatorTable.ARG_MIN</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DATE">
<h3>DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATE</span></div>
<div class="block">The "DATE" function. It has the following overloads:

 <ul>
   <li><code>DATE(string)</code> is syntactic sugar for
       <code>CAST(string AS DATE)</code>
   <li><code>DATE(year, month, day)</code>
   <li><code>DATE(timestampLtz [, timeZone])</code>
   <li><code>DATE(timestamp)</code>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME">
<h3>DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATETIME</span></div>
<div class="block">The "DATETIME" function returns a Calcite
 <code>TIMESTAMP</code> (which BigQuery calls a <code>DATETIME</code>).
 It has the following overloads:

 <ul>
   <li><code>DATETIME(year, month, day, hour, minute, second)</code>
   <li><code>DATETIME(date[, time])</code>
   <li><code>DATETIME(timestampLtz[, timeZone])</code>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="TIME">
<h3>TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIME</span></div>
<div class="block">The "TIME" function. It has the following overloads:

 <ul>
   <li><code>TIME(hour, minute, second)</code>
   <li><code>TIME(timestampLtz [, timeZone])</code>
   <li><code>TIME(timestamp)</code>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP">
<h3>TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP</span></div>
<div class="block">The "TIMESTAMP" function returns a Calcite
 <code>TIMESTAMP WITH LOCAL TIME ZONE</code>
 (which BigQuery calls a <code>TIMESTAMP</code>). It has the following overloads:

 <ul>
   <li><code>TIMESTAMP(string[, timeZone])</code>
   <li><code>TIMESTAMP(date[, timeZone])</code>
   <li><code>TIMESTAMP(timestamp[, timeZone])</code>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="CURRENT_DATETIME">
<h3>CURRENT_DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CURRENT_DATETIME</span></div>
<div class="block">The "CURRENT_DATETIME([timezone])" function.</div>
</section>
</li>
<li>
<section class="detail" id="DATE_FROM_UNIX_DATE">
<h3>DATE_FROM_UNIX_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATE_FROM_UNIX_DATE</span></div>
<div class="block">The "DATE_FROM_UNIX_DATE(integer)" function; returns a DATE value
 a given number of seconds after 1970-01-01.</div>
</section>
</li>
<li>
<section class="detail" id="UNIX_DATE">
<h3>UNIX_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">UNIX_DATE</span></div>
<div class="block">The "UNIX_DATE(date)" function; returns the number of days since
 1970-01-01.</div>
</section>
</li>
<li>
<section class="detail" id="MONTHNAME">
<h3>MONTHNAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">MONTHNAME</span></div>
<div class="block">The "MONTHNAME(datetime)" function; returns the name of the month,
 in the current locale, of a TIMESTAMP or DATE argument.</div>
</section>
</li>
<li>
<section class="detail" id="DAYNAME">
<h3>DAYNAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DAYNAME</span></div>
<div class="block">The "DAYNAME(datetime)" function; returns the name of the day of the week,
 in the current locale, of a TIMESTAMP or DATE argument.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">LEFT</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">REPEAT</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">RIGHT</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SPACE</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">STRCMP</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SOUNDEX</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DIFFERENCE</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="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">ILIKE</span></div>
<div class="block">The case-insensitive variant of the LIKE operator.</div>
</section>
</li>
<li>
<section class="detail" id="NOT_ILIKE">
<h3>NOT_ILIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">NOT_ILIKE</span></div>
<div class="block">The case-insensitive variant of the NOT LIKE operator.</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="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">RLIKE</span></div>
<div class="block">The regex variant of the LIKE operator.</div>
</section>
</li>
<li>
<section class="detail" id="NOT_RLIKE">
<h3>NOT_RLIKE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlSpecialOperator.html" title="class in org.apache.calcite.sql">SqlSpecialOperator</a></span>&nbsp;<span class="element-name">NOT_RLIKE</span></div>
<div class="block">The regex variant of the NOT LIKE operator.</div>
</section>
</li>
<li>
<section class="detail" id="CONCAT_FUNCTION">
<h3>CONCAT_FUNCTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CONCAT_FUNCTION</span></div>
<div class="block">The "CONCAT(arg, ...)" function that concatenates strings.
 For example, "CONCAT('a', 'bc', 'd')" returns "abcd".</div>
</section>
</li>
<li>
<section class="detail" id="CONCAT2">
<h3>CONCAT2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CONCAT2</span></div>
<div class="block">The "CONCAT(arg0, arg1)" function that concatenates strings.
 For example, "CONCAT('a', 'bc')" returns "abc".

 <p>It is assigned <a href="../SqlKind.html#CONCAT2"><code>SqlKind.CONCAT2</code></a> to make it not equal to
 <a href="#CONCAT_FUNCTION"><code>CONCAT_FUNCTION</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_LENGTH">
<h3>ARRAY_LENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ARRAY_LENGTH</span></div>
<div class="block">The "ARRAY_LENGTH(array)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ARRAY_REVERSE</span></div>
<div class="block">The "ARRAY_REVERSE(array)" function.</div>
</section>
</li>
<li>
<section class="detail" id="ARRAY_CONCAT">
<h3>ARRAY_CONCAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">ARRAY_CONCAT</span></div>
<div class="block">The "ARRAY_CONCAT(array [, array]*)" function.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">REVERSE</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">FROM_BASE64</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TO_BASE64</span></div>
</section>
</li>
<li>
<section class="detail" id="TO_DATE">
<h3>TO_DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TO_DATE</span></div>
<div class="block">The "TO_DATE(string1, string2)" function; casts string1
 to a DATE using the format specified in string2.</div>
</section>
</li>
<li>
<section class="detail" id="TO_TIMESTAMP">
<h3>TO_TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TO_TIMESTAMP</span></div>
<div class="block">The "TO_TIMESTAMP(string1, string2)" function; casts string1
 to a TIMESTAMP using the format specified in string2.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_ADD2">
<h3>TIMESTAMP_ADD2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_ADD2</span></div>
<div class="block">The "TIMESTAMP_ADD(timestamp, interval)" function (BigQuery), the
 two-argument variant of the built-in
 <a href="SqlStdOperatorTable.html#TIMESTAMP_ADD"><code>TIMESTAMPADD</code></a> function, which has
 three arguments.

 <p>In BigQuery, the syntax is "TIMESTAMP_ADD(timestamp, INTERVAL
 int64_expression date_part)" but in Calcite the second argument can be any
 interval expression, not just an interval literal.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_DIFF3">
<h3>TIMESTAMP_DIFF3</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_DIFF3</span></div>
<div class="block">The "TIMESTAMP_DIFF(timestamp, timestamp, timeUnit)" function (BigQuery);
 returns the number of timeUnit between the two timestamp expressions.

 <p><code>TIMESTAMP_DIFF(t1, t2, unit)</code> is equivalent to
 <code>TIMESTAMPDIFF(unit, t2, t1)</code> and <code>(t1 - t2) unit</code>.</div>
</section>
</li>
<li>
<section class="detail" id="TIME_ADD">
<h3>TIME_ADD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIME_ADD</span></div>
<div class="block">The "TIME_ADD(time, interval)" function (BigQuery);
 adds interval expression to the specified time expression.</div>
</section>
</li>
<li>
<section class="detail" id="TIME_DIFF">
<h3>TIME_DIFF</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIME_DIFF</span></div>
<div class="block">The "TIME_DIFF(time, time, timeUnit)" function (BigQuery);
 returns the number of timeUnit between the two time expressions.</div>
</section>
</li>
<li>
<section class="detail" id="DATE_TRUNC">
<h3>DATE_TRUNC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">DATE_TRUNC</span></div>
<div class="block">The "DATE_TRUNC(date, timeUnit)" function (BigQuery);
 truncates a DATE value to the beginning of a timeUnit.</div>
</section>
</li>
<li>
<section class="detail" id="TIME_SUB">
<h3>TIME_SUB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIME_SUB</span></div>
<div class="block">The "TIME_SUB(time, interval)" function (BigQuery);
 subtracts an interval from a time, independent of any time zone.

 <p>In BigQuery, the syntax is "TIME_SUB(time, INTERVAL int64 date_part)"
 but in Calcite the second argument can be any interval expression, not just
 an interval literal.</div>
</section>
</li>
<li>
<section class="detail" id="TIME_TRUNC">
<h3>TIME_TRUNC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIME_TRUNC</span></div>
<div class="block">The "TIME_TRUNC(time, timeUnit)" function (BigQuery);
 truncates a TIME value to the beginning of a timeUnit.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_SUB">
<h3>TIMESTAMP_SUB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_SUB</span></div>
<div class="block">The "TIMESTAMP_SUB(timestamp, interval)" function (BigQuery);
 subtracts an interval from a timestamp, independent of any time zone.

 <p>In BigQuery, the syntax is "TIMESTAMP_SUB(timestamp,
 INTERVAL int64 date_part)" but in Calcite the second argument can be any
 interval expression, not just an interval literal.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_TRUNC">
<h3>TIMESTAMP_TRUNC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_TRUNC</span></div>
<div class="block">The "TIMESTAMP_TRUNC(timestamp, timeUnit[, timeZone])" function (BigQuery);
 truncates a TIMESTAMP value to the beginning of a timeUnit.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_SECONDS">
<h3>TIMESTAMP_SECONDS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_SECONDS</span></div>
<div class="block">The "TIMESTAMP_SECONDS(bigint)" function; returns a TIMESTAMP value
 a given number of seconds after 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_MILLIS">
<h3>TIMESTAMP_MILLIS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_MILLIS</span></div>
<div class="block">The "TIMESTAMP_MILLIS(bigint)" function; returns a TIMESTAMP value
 a given number of milliseconds after 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_MICROS">
<h3>TIMESTAMP_MICROS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TIMESTAMP_MICROS</span></div>
<div class="block">The "TIMESTAMP_MICROS(bigint)" function; returns a TIMESTAMP value
 a given number of micro-seconds after 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="UNIX_SECONDS">
<h3>UNIX_SECONDS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">UNIX_SECONDS</span></div>
<div class="block">The "UNIX_SECONDS(bigint)" function; returns the number of seconds
 since 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="UNIX_MILLIS">
<h3>UNIX_MILLIS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">UNIX_MILLIS</span></div>
<div class="block">The "UNIX_MILLIS(bigint)" function; returns the number of milliseconds
 since 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="UNIX_MICROS">
<h3>UNIX_MICROS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">UNIX_MICROS</span></div>
<div class="block">The "UNIX_MICROS(bigint)" function; returns the number of microseconds
 since 1970-01-01 00:00:00.</div>
</section>
</li>
<li>
<section class="detail" id="CHAR">
<h3>CHAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CHAR</span></div>
<div class="block">The "CHAR(n)" function; returns the character whose ASCII code is
 <code>n</code> % 256, or null if <code>n</code> &lt; 0.</div>
</section>
</li>
<li>
<section class="detail" id="CHR">
<h3>CHR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">CHR</span></div>
<div class="block">The "CHR(n)" function; returns the character whose UTF-8 code is
 <code>n</code>.</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TANH</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">COSH</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SINH</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</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="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">SHA1</span></div>
</section>
</li>
<li>
<section class="detail" id="POW">
<h3>POW</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">POW</span></div>
</section>
</li>
<li>
<section class="detail" id="TRUNC">
<h3>TRUNC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlFunction.html" title="class in org.apache.calcite.sql">SqlFunction</a></span>&nbsp;<span class="element-name">TRUNC</span></div>
</section>
</li>
<li>
<section class="detail" id="INFIX_CAST">
<h3>INFIX_CAST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">INFIX_CAST</span></div>
<div class="block">Infix "::" cast operator used by PostgreSQL, for example
 <code>'100'::INTEGER</code>.</div>
</section>
</li>
<li>
<section class="detail" id="NULL_SAFE_EQUAL">
<h3>NULL_SAFE_EQUAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">NULL_SAFE_EQUAL</span></div>
<div class="block">NULL-safe "&lt;=&gt;" equal operator used by MySQL, for example
 <code>1&lt;=&gt;NULL</code>.</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>
