<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlFunctions (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.runtime, class: SqlFunctions">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&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>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.runtime</a></div>
<h1 title="Class SqlFunctions" class="title">Class SqlFunctions</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.runtime.SqlFunctions</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">SqlFunctions</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">Helper methods to implement SQL functions in generated code.

 <p>Not present: and, or, not (builtin operators are better, because they
 use lazy evaluation. Implementations do not check for null values; the
 calling code must do that.

 <p>Many of the functions do not check for null values. This is intentional.
 If null arguments are possible, the code-generation framework checks for
 nulls before calling the functions.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</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">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlFunctions.FlatProductInputType.html" class="type-name-link" title="enum in org.apache.calcite.runtime">SqlFunctions.FlatProductInputType</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type of argument passed into <a href="#flatProduct(int%5B%5D,boolean,org.apache.calcite.runtime.SqlFunctions.FlatProductInputType%5B%5D)"><code>flatProduct(int[], boolean, org.apache.calcite.runtime.SqlFunctions.FlatProductInputType[])</code></a>.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(byte)" class="member-name-link">abs</a><wbr>(byte&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to byte values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(double)" class="member-name-link">abs</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(float)" class="member-name-link">abs</a><wbr>(float&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to float values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(int)" class="member-name-link">abs</a><wbr>(int&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(long)" class="member-name-link">abs</a><wbr>(long&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to long values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(short)" class="member-name-link">abs</a><wbr>(short&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to short values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#abs(java.math.BigDecimal)" class="member-name-link">abs</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ABS</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#acos(double)" class="member-name-link">acos</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ACOS</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#acos(java.math.BigDecimal)" class="member-name-link">acos</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ACOS</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#array(java.lang.Object...)" class="member-name-link">array</a><wbr>(<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>...&nbsp;args)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#arrayItem(java.util.List,int)" class="member-name-link">arrayItem</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list,
 int&nbsp;item)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for "array element reference".</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#arrayItemOptional(java.util.List,int)" class="member-name-link">arrayItemOptional</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list,
 int&nbsp;item)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As <a href="#arrayItem(java.util.List,int)"><code>arrayItem(java.util.List, int)</code></a> method, but allows array to be nullable.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#arrayToList(java.sql.Array)" class="member-name-link">arrayToList</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Array.html" title="class or interface in java.sql" class="external-link">Array</a>&nbsp;a)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a JDBC array to a list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ascii(java.lang.String)" class="member-name-link">ascii</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL ASCII(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asin(double)" class="member-name-link">asin</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ASIN</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asin(java.math.BigDecimal)" class="member-name-link">asin</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ASIN</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan(double)" class="member-name-link">atan</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan(java.math.BigDecimal)" class="member-name-link">atan</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan2(double,double)" class="member-name-link">atan2</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN2</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan2(double,java.math.BigDecimal)" class="member-name-link">atan2</a><wbr>(double&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN2</code> operator applied to double/BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan2(java.math.BigDecimal,double)" class="member-name-link">atan2</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN2</code> operator applied to BigDecimal/double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#atan2(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">atan2</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ATAN2</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitAnd(long,long)" class="member-name-link">bitAnd</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_AND</code> applied to integer values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitAnd(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">bitAnd</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_AND</code> applied to binary values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitOr(long,long)" class="member-name-link">bitOr</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_OR</code> applied to integer values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitOr(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">bitOr</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_OR</code> applied to binary values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitXor(long,long)" class="member-name-link">bitXor</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_XOR</code> applied to integer values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bitXor(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">bitXor</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Bitwise function <code>BIT_XOR</code> applied to binary values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cbrt(double)" class="member-name-link">cbrt</a><wbr>(double&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CBRT</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cbrt(java.math.BigDecimal)" class="member-name-link">cbrt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CBRT</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(byte,byte)" class="member-name-link">ceil</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> operator applied to byte values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(double)" class="member-name-link">ceil</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(float)" class="member-name-link">ceil</a><wbr>(float&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(int,int)" class="member-name-link">ceil</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(int,java.math.BigDecimal)" class="member-name-link">ceil</a><wbr>(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(long,long)" class="member-name-link">ceil</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> operator applied to long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(short,short)" class="member-name-link">ceil</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> operator applied to short values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(java.math.BigDecimal)" class="member-name-link">ceil</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(java.math.BigDecimal,int)" class="member-name-link">ceil</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ceil(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ceil</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#charFromAscii(int)" class="member-name-link">charFromAscii</a><wbr>(int&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL CHAR(integer) function, as in MySQL and Spark.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#charFromUtf8(int)" class="member-name-link">charFromUtf8</a><wbr>(int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL CHR(integer) function, as in Oracle and Postgres.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#charLength(java.lang.String)" class="member-name-link">charLength</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL CHARACTER_LENGTH(string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concat(java.lang.String,java.lang.String)" class="member-name-link">concat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>string || string</code> operator.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concat(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">concat</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>binary || binary</code> operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatMulti(java.lang.String...)" class="member-name-link">concatMulti</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;args)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CONCAT(arg0, arg1, arg2, ...)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cos(double)" class="member-name-link">cos</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COS</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cos(java.math.BigDecimal)" class="member-name-link">cos</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COS</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cosh(double)" class="member-name-link">cosh</a><wbr>(double&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COSH</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cosh(java.math.BigDecimal)" class="member-name-link">cosh</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COSH</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cot(double)" class="member-name-link">cot</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COT</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cot(java.math.BigDecimal)" class="member-name-link">cot</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>COT</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#currentDate(org.apache.calcite.DataContext)" class="member-name-link">currentDate</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CURRENT_DATE</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#currentTime(org.apache.calcite.DataContext)" class="member-name-link">currentTime</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CURRENT_TIME</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#currentTimestamp(org.apache.calcite.DataContext)" class="member-name-link">currentTimestamp</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CURRENT_TIMESTAMP</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)" class="member-name-link">customDateAdd</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;interval,
 int&nbsp;date)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATEADD</code> function applied to a custom time frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customDateCeil(org.apache.calcite.DataContext,java.lang.String,int)" class="member-name-link">customDateCeil</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> function applied to a <code>DATE</code> value
 and a custom time frame.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customDateDiff(org.apache.calcite.DataContext,java.lang.String,int,int)" class="member-name-link">customDateDiff</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date,
 int&nbsp;date2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATEDIFF</code> function applied to a custom time frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customDateFloor(org.apache.calcite.DataContext,java.lang.String,int)" class="member-name-link">customDateFloor</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> function applied to a <code>DATE</code> value
 and a custom time frame.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customTimestampAdd(org.apache.calcite.DataContext,java.lang.String,long,long)" class="member-name-link">customTimestampAdd</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;interval,
 long&nbsp;timestamp)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMPADD</code> function applied to a custom time frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customTimestampCeil(org.apache.calcite.DataContext,java.lang.String,long)" class="member-name-link">customTimestampCeil</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>CEIL</code> function applied to a <code>TIMESTAMP</code> value
 and a custom time frame.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customTimestampDiff(org.apache.calcite.DataContext,java.lang.String,long,long)" class="member-name-link">customTimestampDiff</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp,
 long&nbsp;timestamp2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMPDIFF</code> function applied to a custom time frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#customTimestampFloor(org.apache.calcite.DataContext,java.lang.String,long)" class="member-name-link">customTimestampFloor</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> function applied to a <code>TIMESTAMP</code> value
 and a custom time frame.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#date(int,int,int)" class="member-name-link">date</a><wbr>(int&nbsp;year,
 int&nbsp;month,
 int&nbsp;day)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATE(year, month, day)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#date(long)" class="member-name-link">date</a><wbr>(long&nbsp;timestampMillis)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATE(TIMESTAMP)</code> and
 <code>DATE(TIMESTAMP WITH LOCAL TIME ZONE)</code> functions.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#date(long,java.lang.String)" class="member-name-link">date</a><wbr>(long&nbsp;timestampMillis,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATE(TIMESTAMP WITH LOCAL TIME, timeZone)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dateFromUnixDate(int)" class="member-name-link">dateFromUnixDate</a><wbr>(int&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#DATE_FROM_UNIX_DATE"><code>SqlLibraryOperators.DATE_FROM_UNIX_DATE</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#datetime(int)" class="member-name-link">datetime</a><wbr>(int&nbsp;daysSinceEpoch)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATETIME(DATE)</code> function; returns a Calcite TIMESTAMP.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#datetime(int,int)" class="member-name-link">datetime</a><wbr>(int&nbsp;daysSinceEpoch,
 int&nbsp;millisSinceMidnight)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATETIME(DATE, TIME)</code> function; returns a Calcite TIMESTAMP.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#datetime(int,int,int,int,int,int)" class="member-name-link">datetime</a><wbr>(int&nbsp;year,
 int&nbsp;month,
 int&nbsp;day,
 int&nbsp;hour,
 int&nbsp;minute,
 int&nbsp;second)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATETIME(&lt;year&gt;, &lt;month&gt;, &lt;day&gt;, &lt;hour&gt;, &lt;minute&gt;, &lt;second&gt;)</code>
 function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#datetime(long)" class="member-name-link">datetime</a><wbr>(long&nbsp;millisSinceEpoch)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATETIME(TIMESTAMP WITH LOCAL TIME ZONE)</code> function;
 returns a Calcite TIMESTAMP.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#datetime(long,java.lang.String)" class="member-name-link">datetime</a><wbr>(long&nbsp;millisSinceEpoch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DATETIME(TIMESTAMP, timeZone)</code> function;
 returns a Calcite TIMESTAMP.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dayNameWithDate(int,java.util.Locale)" class="member-name-link">dayNameWithDate</a><wbr>(int&nbsp;date,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DAYNAME</code> function, applied to a DATE argument.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dayNameWithTimestamp(long,java.util.Locale)" class="member-name-link">dayNameWithTimestamp</a><wbr>(long&nbsp;timestamp,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DAYNAME</code> function, applied to a TIMESTAMP argument.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#degrees(double)" class="member-name-link">degrees</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DEGREES</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#degrees(java.math.BigDecimal)" class="member-name-link">degrees</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>DEGREES</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#difference(java.lang.String,java.lang.String)" class="member-name-link">difference</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL DIFFERENCE(string, string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(int,int)" class="member-name-link">divide</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(int,java.lang.Integer)" class="member-name-link">divide</a><wbr>(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to int values; right side may be
 null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(int,java.math.BigDecimal)" class="member-name-link">divide</a><wbr>(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(long,java.math.BigDecimal)" class="member-name-link">divide</a><wbr>(long&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(java.lang.Integer,int)" class="member-name-link">divide</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to int values; left side may be
 null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(java.lang.Integer,java.lang.Integer)" class="member-name-link">divide</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to nullable int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(java.lang.Integer,java.lang.Long)" class="member-name-link">divide</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to nullable int and long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">divide</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(java.lang.Long,java.lang.Integer)" class="member-name-link">divide</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to nullable long and int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divideAny(java.lang.Object,java.lang.Object)" class="member-name-link">divideAny</a><wbr>(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>/</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#element(java.util.List)" class="member-name-link">element</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the ELEMENT function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#endsWith(java.lang.String,java.lang.String)" class="member-name-link">endsWith</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ENDS_WITH(string, string)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#endsWith(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">endsWith</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ENDS_WITH(binary, binary)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eq(java.lang.Object%5B%5D,java.lang.Object%5B%5D)" class="member-name-link">eq</a><wbr>(@Nullable <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> @Nullable []&nbsp;b0,
 @Nullable <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> @Nullable []&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>=</code> operator applied to Object[] values (neither may be
 null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eq(java.lang.Object,java.lang.Object)" class="member-name-link">eq</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>=</code> operator applied to Object values (including String;
 neither side may be null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eq(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">eq</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>=</code> operator applied to String values with a certain Comparator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eq(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">eq</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>=</code> operator applied to BigDecimal values (neither may be
 null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eqAny(java.lang.Object,java.lang.Object)" class="member-name-link">eqAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>=</code> operator applied to Object values (at least one operand
 has ANY type; neither may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exp(double)" class="member-name-link">exp</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>EXP</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exp(java.math.BigDecimal)" class="member-name-link">exp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../linq4j/function/Function1.html" title="interface in org.apache.calcite.linq4j.function">Function1</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<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>&gt;,<wbr><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<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>&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#flatList()" class="member-name-link">flatList</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Function that, given a certain List containing single-item structs (i.e.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../linq4j/function/Function1.html" title="interface in org.apache.calcite.linq4j.function">Function1</a>&lt;<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>,<wbr><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime">FlatLists.ComparableList</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&gt;&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#flatProduct(int%5B%5D,boolean,org.apache.calcite.runtime.SqlFunctions.FlatProductInputType%5B%5D)" class="member-name-link">flatProduct</a><wbr>(int[]&nbsp;fieldCounts,
 boolean&nbsp;withOrdinality,
 <a href="SqlFunctions.FlatProductInputType.html" title="enum in org.apache.calcite.runtime">SqlFunctions.FlatProductInputType</a>[]&nbsp;inputTypes)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(byte,byte)" class="member-name-link">floor</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> operator applied to byte values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(double)" class="member-name-link">floor</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(float)" class="member-name-link">floor</a><wbr>(float&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(int,int)" class="member-name-link">floor</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> operator applied to int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(int,java.math.BigDecimal)" class="member-name-link">floor</a><wbr>(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(long,long)" class="member-name-link">floor</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> operator applied to long values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(short,short)" class="member-name-link">floor</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>FLOOR</code> operator applied to short values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(java.math.BigDecimal)" class="member-name-link">floor</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(java.math.BigDecimal,int)" class="member-name-link">floor</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#floor(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">floor</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#fromBase64(java.lang.String)" class="member-name-link">fromBase64</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base64)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL FROM_BASE64(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ge(boolean,boolean)" class="member-name-link">ge</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to boolean values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ge(java.lang.String,java.lang.String)" class="member-name-link">ge</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to String values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ge(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">ge</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to String values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ge(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ge</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ge(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ge</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to ByteString values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#geAny(java.lang.Object,java.lang.Object)" class="member-name-link">geAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&ge;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(boolean,boolean)" class="member-name-link">greater</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(byte,byte)" class="member-name-link">greater</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static char</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(char,char)" class="member-name-link">greater</a><wbr>(char&nbsp;b0,
 char&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(double,double)" class="member-name-link">greater</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(float,float)" class="member-name-link">greater</a><wbr>(float&nbsp;b0,
 float&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(int,int)" class="member-name-link">greater</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(long,long)" class="member-name-link">greater</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(short,short)" class="member-name-link">greater</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greater(T,T)" class="member-name-link">greater</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for implementing MAX.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greatest(T,T)" class="member-name-link">greatest</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">GREATEST operator.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(boolean,boolean)" class="member-name-link">gt</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to boolean values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(byte,byte)" class="member-name-link">gt</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(char,char)" class="member-name-link">gt</a><wbr>(char&nbsp;b0,
 char&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(double,double)" class="member-name-link">gt</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(float,float)" class="member-name-link">gt</a><wbr>(float&nbsp;b0,
 float&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(int,int)" class="member-name-link">gt</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(long,long)" class="member-name-link">gt</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(short,short)" class="member-name-link">gt</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(java.lang.String,java.lang.String)" class="member-name-link">gt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to String values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">gt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to String values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">gt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gt(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">gt</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to ByteString values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gtAny(java.lang.Object,java.lang.Object)" class="member-name-link">gtAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&gt;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#gtNullable(T,T)" class="member-name-link">gtNullable</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>b0</code> is greater than <code>b1</code>
 (or <code>b1</code> is null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ilike(java.lang.String,java.lang.String)" class="member-name-link">ilike</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ILIKE</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ilike(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">ilike</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ILIKE</code> function with escape.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#initcap(java.lang.String)" class="member-name-link">initcap</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL INITCAP(string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToDate(int)" class="member-name-link">internalToDate</a><wbr>(int&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL DATE value from the internal representation type
 (number of days since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToDate(java.lang.Integer)" class="member-name-link">internalToDate</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL DATE value from the internal representation type
 (number of days since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToTime(int)" class="member-name-link">internalToTime</a><wbr>(int&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIME value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToTime(java.lang.Integer)" class="member-name-link">internalToTime</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL TIME value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToTimestamp(long)" class="member-name-link">internalToTimestamp</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIMESTAMP value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java Type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>)
 in the local time zone.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#internalToTimestamp(java.lang.Long)" class="member-name-link">internalToTimestamp</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL TIMESTAMP value from the internal representation
 type (number of milliseconds since January 1st, 1970) to the Java Type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>)
 in the local time zone.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isASet(java.util.Collection)" class="member-name-link">isASet</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the IS A SET function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isFalse(java.lang.Boolean)" class="member-name-link">isFalse</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">NULL &rarr; FALSE, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isNotFalse(java.lang.Boolean)" class="member-name-link">isNotFalse</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">NULL &rarr; TRUE, FALSE &rarr; FALSE, TRUE &rarr; TRUE.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isNotTrue(java.lang.Boolean)" class="member-name-link">isNotTrue</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">NULL &rarr; TRUE, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isTrue(java.lang.Boolean)" class="member-name-link">isTrue</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">NULL &rarr; FALSE, FALSE &rarr; FALSE, TRUE &rarr; TRUE.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#item(java.lang.Object,java.lang.Object)" class="member-name-link">item</a><wbr>(<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>&nbsp;object,
 <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>&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Implements the <code>[ ... ]</code> operator on an object whose type is not
 known until runtime.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#itemOptional(java.lang.Object,java.lang.Object)" class="member-name-link">itemOptional</a><wbr>(@Nullable <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>&nbsp;object,
 <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>&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As <a href="#item(java.lang.Object,java.lang.Object)"><code>item(java.lang.Object, java.lang.Object)</code></a> method, but allows object to be nullable.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#le(boolean,boolean)" class="member-name-link">le</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to boolean values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#le(java.lang.String,java.lang.String)" class="member-name-link">le</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to String values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#le(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">le</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to String values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#le(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">le</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#le(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">le</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to ByteString values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leAny(java.lang.Object,java.lang.Object)" class="member-name-link">leAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&le;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#least(T,T)" class="member-name-link">least</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">LEAST operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#left(java.lang.String,int)" class="member-name-link">left</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL LEFT(string, integer) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#left(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">left</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL LEFT(ByteString, integer) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(boolean,boolean)" class="member-name-link">lesser</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(byte,byte)" class="member-name-link">lesser</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static char</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(char,char)" class="member-name-link">lesser</a><wbr>(char&nbsp;b0,
 char&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(double,double)" class="member-name-link">lesser</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(float,float)" class="member-name-link">lesser</a><wbr>(float&nbsp;b0,
 float&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(int,int)" class="member-name-link">lesser</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(long,long)" class="member-name-link">lesser</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(short,short)" class="member-name-link">lesser</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lesser(T,T)" class="member-name-link">lesser</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for implementing MIN.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#like(java.lang.String,java.lang.String)" class="member-name-link">like</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LIKE</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#like(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">like</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LIKE</code> function with escape.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ln(double)" class="member-name-link">ln</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LN(number)</code> function applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ln(java.math.BigDecimal)" class="member-name-link">ln</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;d)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LN(number)</code> function applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#locale(org.apache.calcite.DataContext)" class="member-name-link">locale</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#localTime(org.apache.calcite.DataContext)" class="member-name-link">localTime</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LOCAL_TIME</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#localTimestamp(org.apache.calcite.DataContext)" class="member-name-link">localTimestamp</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LOCAL_TIMESTAMP</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#log10(double)" class="member-name-link">log10</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LOG10(numeric)</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#log10(java.math.BigDecimal)" class="member-name-link">log10</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LOG10(number)</code> function applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lower(java.lang.String)" class="member-name-link">lower</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL LOWER(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lpad(java.lang.String,int)" class="member-name-link">lpad</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LPAD(string, integer)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lpad(java.lang.String,int,java.lang.String)" class="member-name-link">lpad</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LPAD(string, integer, string)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lpad(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">lpad</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LPAD(binary, integer, binary)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lpad(org.apache.calcite.avatica.util.ByteString,int,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">lpad</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength,
 org.apache.calcite.avatica.util.ByteString&nbsp;pattern)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LPAD(binary, integer, binary)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(boolean,boolean)" class="member-name-link">lt</a><wbr>(boolean&nbsp;b0,
 boolean&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to boolean values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(byte,byte)" class="member-name-link">lt</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(char,char)" class="member-name-link">lt</a><wbr>(char&nbsp;b0,
 char&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(double,double)" class="member-name-link">lt</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(float,float)" class="member-name-link">lt</a><wbr>(float&nbsp;b0,
 float&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(int,int)" class="member-name-link">lt</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(long,long)" class="member-name-link">lt</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(short,short)" class="member-name-link">lt</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(java.lang.String,java.lang.String)" class="member-name-link">lt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to String values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">lt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to String values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">lt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lt(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">lt</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to ByteString values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ltAny(java.lang.Object,java.lang.Object)" class="member-name-link">ltAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;</code> operator applied to Object values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;<br>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ltNullable(T,T)" class="member-name-link">ltNullable</a><wbr>(T&nbsp;b0,
 T&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>b0</code> is less than <code>b1</code>
 (or <code>b1</code> is null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ltrim(java.lang.String)" class="member-name-link">ltrim</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>LTRIM</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mapItem(java.util.Map,java.lang.Object)" class="member-name-link">mapItem</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&nbsp;map,
 <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>&nbsp;item)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for "map element reference".</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mapItemOptional(java.util.Map,java.lang.Object)" class="member-name-link">mapItemOptional</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&nbsp;map,
 <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>&nbsp;item)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As <a href="#mapItem(java.util.Map,java.lang.Object)"><code>mapItem(java.util.Map, java.lang.Object)</code></a> method, but allows map to be nullable.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#md5(java.lang.String)" class="member-name-link">md5</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL MD5(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#md5(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">md5</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;string)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL MD5(string) function for binary string.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberOf(java.lang.Object,java.util.Collection)" class="member-name-link">memberOf</a><wbr>(@Nullable <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>&nbsp;object,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MEMBER OF function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(int,int)" class="member-name-link">minus</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(int,java.lang.Integer)" class="member-name-link">minus</a><wbr>(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to int values; right side may be
 null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.lang.Integer,int)" class="member-name-link">minus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to int values; left side may be
 null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.lang.Integer,java.lang.Integer)" class="member-name-link">minus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to nullable int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.lang.Integer,java.lang.Long)" class="member-name-link">minus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to nullable int and long values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.lang.Long,java.lang.Integer)" class="member-name-link">minus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to nullable long and int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">minus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to nullable BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minusAny(java.lang.Object,java.lang.Object)" class="member-name-link">minusAny</a><wbr>(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>-</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(byte,byte)" class="member-name-link">mod</a><wbr>(byte&nbsp;b0,
 byte&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MOD</code> operator applied to byte values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(int,int)" class="member-name-link">mod</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MOD</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(int,java.math.BigDecimal)" class="member-name-link">mod</a><wbr>(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(long,long)" class="member-name-link">mod</a><wbr>(long&nbsp;b0,
 long&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MOD</code> operator applied to long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(short,short)" class="member-name-link">mod</a><wbr>(short&nbsp;b0,
 short&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MOD</code> operator applied to short values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(java.math.BigDecimal,int)" class="member-name-link">mod</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mod(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">mod</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#monthNameWithDate(int,java.util.Locale)" class="member-name-link">monthNameWithDate</a><wbr>(int&nbsp;date,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MONTHNAME</code> function, applied to a DATE argument.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#monthNameWithTimestamp(long,java.util.Locale)" class="member-name-link">monthNameWithTimestamp</a><wbr>(long&nbsp;timestamp,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>MONTHNAME</code> function, applied to a TIMESTAMP argument.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(int,int)" class="member-name-link">multiply</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(int,java.lang.Integer)" class="member-name-link">multiply</a><wbr>(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to int values; right side may be
 null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(java.lang.Integer,int)" class="member-name-link">multiply</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to int values; left side may be
 null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(java.lang.Integer,java.lang.Integer)" class="member-name-link">multiply</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to nullable int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(java.lang.Integer,java.lang.Long)" class="member-name-link">multiply</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to nullable int and long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(java.lang.Long,java.lang.Integer)" class="member-name-link">multiply</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to nullable long and int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">multiply</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to nullable BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAny(java.lang.Object,java.lang.Object)" class="member-name-link">multiplyAny</a><wbr>(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>*</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetExceptAll(java.util.Collection,java.util.Collection)" class="member-name-link">multisetExceptAll</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET EXCEPT ALL function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetExceptDistinct(java.util.Collection,java.util.Collection)" class="member-name-link">multisetExceptDistinct</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET EXCEPT DISTINCT function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetIntersectAll(java.util.Collection,java.util.Collection)" class="member-name-link">multisetIntersectAll</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET INTERSECT ALL function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetIntersectDistinct(java.util.Collection,java.util.Collection)" class="member-name-link">multisetIntersectDistinct</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET INTERSECT DISTINCT function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetUnionAll(java.util.Collection,java.util.Collection)" class="member-name-link">multisetUnionAll</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET UNION ALL function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multisetUnionDistinct(java.util.Collection,java.util.Collection)" class="member-name-link">multisetUnionDistinct</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the MULTISET UNION function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ne(java.lang.Object,java.lang.Object)" class="member-name-link">ne</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;gt;</code> operator applied to Object values (including
 String; neither side may be null).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ne(java.lang.String,java.lang.String,java.util.Comparator)" class="member-name-link">ne</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;gt;</code> operator applied to OString values with a certain Comparator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ne(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ne</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;gt;</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#neAny(java.lang.Object,java.lang.Object)" class="member-name-link">neAny</a><wbr>(<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>&nbsp;b0,
 <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>&lt;gt;</code> operator applied to Object values (at least one
  operand has ANY type, including String; neither may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#not(java.lang.Boolean)" class="member-name-link">not</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">NULL &rarr; NULL, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#octetLength(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">octetLength</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL OCTET_LENGTH(binary) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#overlay(java.lang.String,java.lang.String,int)" class="member-name-link">overlay</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;r,
 int&nbsp;start)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>OVERLAY</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#overlay(java.lang.String,java.lang.String,int,int)" class="member-name-link">overlay</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;r,
 int&nbsp;start,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>OVERLAY</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#overlay(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">overlay</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 org.apache.calcite.avatica.util.ByteString&nbsp;r,
 int&nbsp;start)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>OVERLAY</code> function applied to binary strings.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#overlay(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int,int)" class="member-name-link">overlay</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 org.apache.calcite.avatica.util.ByteString&nbsp;r,
 int&nbsp;start,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>OVERLAY</code> function applied to binary strings.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(int,int)" class="member-name-link">plus</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(int,java.lang.Integer)" class="member-name-link">plus</a><wbr>(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to int values; right side may be
 null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(java.lang.Integer,int)" class="member-name-link">plus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to int values; left side may be
 null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(java.lang.Integer,java.lang.Integer)" class="member-name-link">plus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to nullable int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(java.lang.Integer,java.lang.Long)" class="member-name-link">plus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to nullable int and long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(java.lang.Long,java.lang.Integer)" class="member-name-link">plus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to nullable long and int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plus(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">plus</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#plusAny(java.lang.Object,java.lang.Object)" class="member-name-link">plusAny</a><wbr>(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>+</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#position(java.lang.String,java.lang.String)" class="member-name-link">position</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>POSITION(seek IN string)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#position(java.lang.String,java.lang.String,int)" class="member-name-link">position</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;from)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>POSITION(seek IN string FROM integer)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#position(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">position</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;seek,
 org.apache.calcite.avatica.util.ByteString&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>POSITION(seek IN string)</code> function for byte strings.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#position(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">position</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;seek,
 org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;from)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>POSITION(seek IN string FROM integer)</code> function for byte
 strings.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#posixRegex(java.lang.String,java.lang.String,boolean)" class="member-name-link">posixRegex</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(double,double)" class="member-name-link">power</a><wbr>(double&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>POWER</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(double,java.math.BigDecimal)" class="member-name-link">power</a><wbr>(double&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(java.math.BigDecimal,double)" class="member-name-link">power</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 double&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">power</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&gt;<br><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime">FlatLists.ComparableList</a>&lt;E&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#product(java.util.List,int,boolean)" class="member-name-link">product</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../linq4j/Enumerator.html" title="interface in org.apache.calcite.linq4j">Enumerator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;&gt;&nbsp;enumerators,
 int&nbsp;fieldCount,
 boolean&nbsp;withOrdinality)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Similar to <a href="../linq4j/Linq4j.html#product(java.lang.Iterable)"><code>Linq4j.product(Iterable)</code></a> but each resulting list
 implements <a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime"><code>FlatLists.ComparableList</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#radians(double)" class="member-name-link">radians</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RADIANS</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#radians(java.math.BigDecimal)" class="member-name-link">radians</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RADIANS</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#regexpReplace(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">regexpReplace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 3 arguments.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#regexpReplace(java.lang.String,java.lang.String,java.lang.String,int)" class="member-name-link">regexpReplace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 4 arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#regexpReplace(java.lang.String,java.lang.String,java.lang.String,int,int)" class="member-name-link">regexpReplace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos,
 int&nbsp;occurrence)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 5 arguments.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#regexpReplace(java.lang.String,java.lang.String,java.lang.String,int,int,java.lang.String)" class="member-name-link">regexpReplace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos,
 int&nbsp;occurrence,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;matchType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 6 arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#repeat(java.lang.String,int)" class="member-name-link">repeat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL REPEAT(string, int) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#replace(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">replace</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;search,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>REPLACE(string, search, replacement)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reverse(java.lang.String)" class="member-name-link">reverse</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL REVERSE(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reverse(java.util.List)" class="member-name-link">reverse</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the ARRAY_REVERSE function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#right(java.lang.String,int)" class="member-name-link">right</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL RIGHT(string, integer) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#right(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">right</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL RIGHT(ByteString, integer) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rlike(java.lang.String,java.lang.String)" class="member-name-link">rlike</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RLIKE</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#round(int,int)" class="member-name-link">round</a><wbr>(int&nbsp;v,
 int&nbsp;x)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for rounding.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#round(long,long)" class="member-name-link">round</a><wbr>(long&nbsp;v,
 long&nbsp;x)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for rounding.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rpad(java.lang.String,int)" class="member-name-link">rpad</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RPAD(string, integer)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rpad(java.lang.String,int,java.lang.String)" class="member-name-link">rpad</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RPAD(string, integer, string)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rpad(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">rpad</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RPAD(binary, integer)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rpad(org.apache.calcite.avatica.util.ByteString,int,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">rpad</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength,
 org.apache.calcite.avatica.util.ByteString&nbsp;pattern)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RPAD(binary, integer, binary)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rtrim(java.lang.String)" class="member-name-link">rtrim</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>RTRIM</code> function applied to string.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rtrim(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">rtrim</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for CAST.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sequenceCurrentValue(java.lang.String)" class="member-name-link">sequenceCurrentValue</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the <code>CURRENT VALUE OF sequence</code> operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sequenceNextValue(java.lang.String)" class="member-name-link">sequenceNextValue</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the <code>NEXT VALUE OF sequence</code> operator.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sha1(java.lang.String)" class="member-name-link">sha1</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SHA1(string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sha1(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">sha1</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;string)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SHA1(string) function for binary string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sign(double)" class="member-name-link">sign</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIGN</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sign(int)" class="member-name-link">sign</a><wbr>(int&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIGN</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sign(long)" class="member-name-link">sign</a><wbr>(long&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIGN</code> operator applied to long values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sign(java.math.BigDecimal)" class="member-name-link">sign</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIGN</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#similar(java.lang.String,java.lang.String)" class="member-name-link">similar</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIMILAR</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#similar(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">similar</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIMILAR</code> function with escape.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sin(double)" class="member-name-link">sin</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIN</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sin(java.math.BigDecimal)" class="member-name-link">sin</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SIN</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sinh(double)" class="member-name-link">sinh</a><wbr>(double&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SINH</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sinh(java.math.BigDecimal)" class="member-name-link">sinh</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SINH</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#slice(java.util.List)" class="member-name-link">slice</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the SLICE function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#soundex(java.lang.String)" class="member-name-link">soundex</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SOUNDEX(string) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#space(int)" class="member-name-link">space</a><wbr>(int&nbsp;n)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SPACE(int) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(double)" class="member-name-link">sround</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(double,int)" class="member-name-link">sround</a><wbr>(double&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to double values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(int)" class="member-name-link">sround</a><wbr>(int&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(int,int)" class="member-name-link">sround</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to int values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(long)" class="member-name-link">sround</a><wbr>(long&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(long,int)" class="member-name-link">sround</a><wbr>(long&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to long values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(java.math.BigDecimal)" class="member-name-link">sround</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sround(java.math.BigDecimal,int)" class="member-name-link">sround</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>ROUND</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#startsWith(java.lang.String,java.lang.String)" class="member-name-link">startsWith</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>STARTS_WITH(string, string)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#startsWith(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)" class="member-name-link">startsWith</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>STARTS_WITH(binary, binary)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#strcmp(java.lang.String,java.lang.String)" class="member-name-link">strcmp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL STRCMP(String,String) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#structAccess(java.lang.Object,int,java.lang.String)" class="member-name-link">structAccess</a><wbr>(@Nullable <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>&nbsp;structObject,
 int&nbsp;index,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fieldName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Implements the <code>.</code> (field access) operator on an object
 whose type is not known until runtime.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(double)" class="member-name-link">struncate</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRUNCATE</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(double,int)" class="member-name-link">struncate</a><wbr>(double&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(int)" class="member-name-link">struncate</a><wbr>(int&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRUNCATE</code> operator applied to int values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(int,int)" class="member-name-link">struncate</a><wbr>(int&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(long)" class="member-name-link">struncate</a><wbr>(long&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRUNCATE</code> operator applied to long values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(long,int)" class="member-name-link">struncate</a><wbr>(long&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(java.math.BigDecimal)" class="member-name-link">struncate</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRUNCATE</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#struncate(java.math.BigDecimal,int)" class="member-name-link">struncate</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#submultisetOf(java.util.Collection,java.util.Collection)" class="member-name-link">submultisetOf</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;possibleSubMultiset,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;multiset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Support the SUBMULTISET OF function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(java.lang.String,int)" class="member-name-link">substring</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;c,
 int&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SUBSTRING(string FROM ...) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(java.lang.String,int,int)" class="member-name-link">substring</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;c,
 int&nbsp;s,
 int&nbsp;l)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SUBSTRING(string FROM ...</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">substring</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;c,
 int&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SUBSTRING(binary FROM ...) function for binary.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#substring(org.apache.calcite.avatica.util.ByteString,int,int)" class="member-name-link">substring</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;c,
 int&nbsp;s,
 int&nbsp;l)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL SUBSTRING(binary FROM ...</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#systemUser(org.apache.calcite.DataContext)" class="member-name-link">systemUser</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>SYSTEM_USER</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tan(double)" class="member-name-link">tan</a><wbr>(double&nbsp;b0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TAN</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tan(java.math.BigDecimal)" class="member-name-link">tan</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TAN</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tanh(double)" class="member-name-link">tanh</a><wbr>(double&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TANH</code> operator applied to double values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tanh(java.math.BigDecimal)" class="member-name-link">tanh</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TANH</code> operator applied to BigDecimal values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#throwUnless(boolean,java.lang.String)" class="member-name-link">throwUnless</a><wbr>(boolean&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Internal THROW_UNLESS(condition, message) function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#time(int,int,int)" class="member-name-link">time</a><wbr>(int&nbsp;hour,
 int&nbsp;minute,
 int&nbsp;second)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIME(&lt;hour&gt;, &lt;minute&gt;, &lt;second&gt;)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#time(long)" class="member-name-link">time</a><wbr>(long&nbsp;timestampMillis)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIME(&lt;timestamp&gt;)</code> and <code>TIME(&lt;timestampLtz&gt;)</code>
 functions.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#time(long,java.lang.String)" class="member-name-link">time</a><wbr>(long&nbsp;timestampMillis,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIME(&lt;timestampLtz&gt;, &lt;timeZone&gt;)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(int)" class="member-name-link">timestamp</a><wbr>(int&nbsp;days)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;date&gt;)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(int,java.lang.String)" class="member-name-link">timestamp</a><wbr>(int&nbsp;days,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;date&gt;, &lt;timeZone&gt;)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(long)" class="member-name-link">timestamp</a><wbr>(long&nbsp;millisSinceEpoch)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;timestamp&gt;)</code> function; returns a TIMESTAMP WITH
 LOCAL TIME ZONE.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(long,java.lang.String)" class="member-name-link">timestamp</a><wbr>(long&nbsp;millisSinceEpoch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;timestamp&gt;, &lt;timeZone&gt;)</code> function; returns a
 TIMESTAMP WITH LOCAL TIME ZONE.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(java.lang.String)" class="member-name-link">timestamp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;string&gt;)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestamp(java.lang.String,java.lang.String)" class="member-name-link">timestamp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TIMESTAMP(&lt;string&gt;, &lt;timeZone&gt;)</code> function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampMicros(long)" class="member-name-link">timestampMicros</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_MICROS"><code>SqlLibraryOperators.TIMESTAMP_MICROS</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampMillis(long)" class="member-name-link">timestampMillis</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_MILLIS"><code>SqlLibraryOperators.TIMESTAMP_MILLIS</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampSeconds(long)" class="member-name-link">timestampSeconds</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_SECONDS"><code>SqlLibraryOperators.TIMESTAMP_SECONDS</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampToDate(long)" class="member-name-link">timestampToDate</a><wbr>(long&nbsp;timestamp)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a timestamp (milliseconds since epoch)
 to a date (days since epoch).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampToTime(long)" class="member-name-link">timestampToTime</a><wbr>(long&nbsp;timestamp)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a timestamp (milliseconds since epoch)
 to a time (milliseconds since midnight).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampWithLocalTimeZoneToDate(long,java.util.TimeZone)" class="member-name-link">timestampWithLocalTimeZoneToDate</a><wbr>(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampWithLocalTimeZoneToString(long,java.util.TimeZone)" class="member-name-link">timestampWithLocalTimeZoneToString</a><wbr>(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampWithLocalTimeZoneToTime(long,java.util.TimeZone)" class="member-name-link">timestampWithLocalTimeZoneToTime</a><wbr>(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampWithLocalTimeZoneToTimestamp(long,java.util.TimeZone)" class="member-name-link">timestampWithLocalTimeZoneToTimestamp</a><wbr>(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampWithLocalTimeZoneToTimeWithLocalTimeZone(long)" class="member-name-link">timestampWithLocalTimeZoneToTimeWithLocalTimeZone</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeWithLocalTimeZoneToString(int,java.util.TimeZone)" class="member-name-link">timeWithLocalTimeZoneToString</a><wbr>(int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeWithLocalTimeZoneToTime(int,java.util.TimeZone)" class="member-name-link">timeWithLocalTimeZoneToTime</a><wbr>(int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeWithLocalTimeZoneToTimestamp(java.lang.String,int,java.util.TimeZone)" class="member-name-link">timeWithLocalTimeZoneToTimestamp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;date,
 int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeWithLocalTimeZoneToTimestampWithLocalTimeZone(java.lang.String,int)" class="member-name-link">timeWithLocalTimeZoneToTimestampWithLocalTimeZone</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;date,
 int&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeZone(org.apache.calcite.DataContext)" class="member-name-link">timeZone</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBase64(java.lang.String)" class="member-name-link">toBase64</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL TO_BASE64(string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBase64(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">toBase64</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;string)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL TO_BASE64(string) function for binary string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBigDecimal(java.lang.Number)" class="member-name-link">toBigDecimal</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBigDecimal(java.lang.Object)" class="member-name-link">toBigDecimal</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBigDecimal(java.lang.String)" class="member-name-link">toBigDecimal</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBoolean(java.lang.Number)" class="member-name-link">toBoolean</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBoolean(java.lang.Object)" class="member-name-link">toBoolean</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toBoolean(java.lang.String)" class="member-name-link">toBoolean</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">CAST(VARCHAR AS BOOLEAN).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toByte(java.lang.Number)" class="member-name-link">toByte</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toByte(java.lang.Object)" class="member-name-link">toByte</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static char</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toChar(java.lang.String)" class="member-name-link">toChar</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toCharBoxed(java.lang.String)" class="member-name-link">toCharBoxed</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toDouble(java.lang.Number)" class="member-name-link">toDouble</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toDouble(java.lang.Object)" class="member-name-link">toDouble</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toDouble(java.lang.String)" class="member-name-link">toDouble</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toFloat(java.lang.Number)" class="member-name-link">toFloat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toFloat(java.lang.Object)" class="member-name-link">toFloat</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toFloat(java.lang.String)" class="member-name-link">toFloat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.lang.Number)" class="member-name-link">toInt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.lang.Object)" class="member-name-link">toInt</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.lang.String)" class="member-name-link">toInt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.sql.Date)" class="member-name-link">toInt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <code>int</code>)
 in the local time zone.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.sql.Date,java.util.TimeZone)" class="member-name-link">toInt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <code>int</code>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toInt(java.sql.Time)" class="member-name-link">toInt</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIME value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>int</code>)
 in the local time zone.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toIntOptional(java.lang.Object)" class="member-name-link">toIntOptional</a><wbr>(@PolyNull <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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toIntOptional(java.sql.Date)" class="member-name-link">toIntOptional</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>)
 in the local time zone.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toIntOptional(java.sql.Date,java.util.TimeZone)" class="member-name-link">toIntOptional</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toIntOptional(java.sql.Time)" class="member-name-link">toIntOptional</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL TIME value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.lang.Number)" class="member-name-link">toLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.lang.Object)" class="member-name-link">toLong</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.lang.String)" class="member-name-link">toLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.sql.Timestamp)" class="member-name-link">toLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)" class="member-name-link">toLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLong(java.util.Date)" class="member-name-link">toLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLongOptional(java.lang.Object)" class="member-name-link">toLongOptional</a><wbr>(@PolyNull <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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLongOptional(java.sql.Timestamp)" class="member-name-link">toLongOptional</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a>)
 in the local time zone.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLongOptional(java.sql.Timestamp,java.util.TimeZone)" class="member-name-link">toLongOptional</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a nullable SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toShort(java.lang.Number)" class="member-name-link">toShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toShort(java.lang.Object)" class="member-name-link">toShort</a><wbr>(<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>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toShort(java.lang.String)" class="member-name-link">toShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(boolean)" class="member-name-link">toString</a><wbr>(boolean&nbsp;x)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">CAST(BOOLEAN AS VARCHAR).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(double)" class="member-name-link">toString</a><wbr>(double&nbsp;x)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">CAST(DOUBLE AS VARCHAR).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(float)" class="member-name-link">toString</a><wbr>(float&nbsp;x)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">CAST(FLOAT AS VARCHAR).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(java.math.BigDecimal)" class="member-name-link">toString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">CAST(DECIMAL AS VARCHAR).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toTimestampWithLocalTimeZone(java.lang.String)" class="member-name-link">toTimestampWithLocalTimeZone</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toTimestampWithLocalTimeZone(java.lang.String,java.util.TimeZone)" class="member-name-link">toTimestampWithLocalTimeZone</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toTimeWithLocalTimeZone(java.lang.String)" class="member-name-link">toTimeWithLocalTimeZone</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toTimeWithLocalTimeZone(java.lang.String,java.util.TimeZone)" class="member-name-link">toTimeWithLocalTimeZone</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#translate3(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">translate3</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;search,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRANSLATE(string, search_chars, replacement_chars)</code>
 function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#trim(boolean,boolean,java.lang.String,java.lang.String)" class="member-name-link">trim</a><wbr>(boolean&nbsp;left,
 boolean&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRIM(... seek FROM s)</code> function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#trim(boolean,boolean,java.lang.String,java.lang.String,boolean)" class="member-name-link">trim</a><wbr>(boolean&nbsp;left,
 boolean&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 boolean&nbsp;strict)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#trim(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">trim</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>TRIM</code> function applied to binary string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncate(int,int)" class="member-name-link">truncate</a><wbr>(int&nbsp;v,
 int&nbsp;x)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for rounding.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncate(long,long)" class="member-name-link">truncate</a><wbr>(long&nbsp;v,
 long&nbsp;x)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for rounding.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncate(java.lang.String,int)" class="member-name-link">truncate</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;maxLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for CAST(...</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncate(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">truncate</a><wbr>(@PolyNull org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;maxLength)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for CAST(...</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncateOrPad(java.lang.String,int)" class="member-name-link">truncateOrPad</a><wbr>(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;maxLength)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for CAST(...</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#truncateOrPad(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">truncateOrPad</a><wbr>(@PolyNull org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;maxLength)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Helper for CAST(...</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unixDate(int)" class="member-name-link">unixDate</a><wbr>(int&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_DATE"><code>SqlLibraryOperators.UNIX_DATE</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unixMicros(long)" class="member-name-link">unixMicros</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_MICROS"><code>SqlLibraryOperators.UNIX_MICROS</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unixMillis(long)" class="member-name-link">unixMillis</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_MILLIS"><code>SqlLibraryOperators.UNIX_MILLIS</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unixSeconds(long)" class="member-name-link">unixSeconds</a><wbr>(long&nbsp;v)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_SECONDS"><code>SqlLibraryOperators.UNIX_SECONDS</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#upper(java.lang.String)" class="member-name-link">upper</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL UPPER(string) function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#user(org.apache.calcite.DataContext)" class="member-name-link">user</a><wbr>(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">SQL <code>USER</code> function.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#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">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="throwUnless(boolean,java.lang.String)">
<h3>throwUnless</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">throwUnless</span><wbr><span class="parameters">(boolean&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message)</span></div>
<div class="block">Internal THROW_UNLESS(condition, message) function.

 <p>The method is marked <a href="../linq4j/function/NonDeterministic.html" title="annotation in org.apache.calcite.linq4j.function"><code>NonDeterministic</code></a> to prevent the generator
 from storing its value as a constant.</div>
</section>
</li>
<li>
<section class="detail" id="toBase64(java.lang.String)">
<h3>toBase64</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toBase64</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</span></div>
<div class="block">SQL TO_BASE64(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="toBase64(org.apache.calcite.avatica.util.ByteString)">
<h3>toBase64</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toBase64</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;string)</span></div>
<div class="block">SQL TO_BASE64(string) function for binary string.</div>
</section>
</li>
<li>
<section class="detail" id="fromBase64(java.lang.String)">
<h3>fromBase64</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">fromBase64</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;base64)</span></div>
<div class="block">SQL FROM_BASE64(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="md5(java.lang.String)">
<h3>md5</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">md5</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</span></div>
<div class="block">SQL MD5(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="md5(org.apache.calcite.avatica.util.ByteString)">
<h3>md5</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">md5</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;string)</span></div>
<div class="block">SQL MD5(string) function for binary string.</div>
</section>
</li>
<li>
<section class="detail" id="sha1(java.lang.String)">
<h3>sha1</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">sha1</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;string)</span></div>
<div class="block">SQL SHA1(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="sha1(org.apache.calcite.avatica.util.ByteString)">
<h3>sha1</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">sha1</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;string)</span></div>
<div class="block">SQL SHA1(string) function for binary string.</div>
</section>
</li>
<li>
<section class="detail" id="regexpReplace(java.lang.String,java.lang.String,java.lang.String)">
<h3>regexpReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">regexpReplace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</span></div>
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 3 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="regexpReplace(java.lang.String,java.lang.String,java.lang.String,int)">
<h3>regexpReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">regexpReplace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos)</span></div>
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 4 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="regexpReplace(java.lang.String,java.lang.String,java.lang.String,int,int)">
<h3>regexpReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">regexpReplace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos,
 int&nbsp;occurrence)</span></div>
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 5 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="regexpReplace(java.lang.String,java.lang.String,java.lang.String,int,int,java.lang.String)">
<h3>regexpReplace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">regexpReplace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement,
 int&nbsp;pos,
 int&nbsp;occurrence,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;matchType)</span></div>
<div class="block">SQL <code>REGEXP_REPLACE</code> function with 6 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="lpad(java.lang.String,int,java.lang.String)">
<h3>lpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">lpad</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>LPAD(string, integer, string)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="lpad(java.lang.String,int)">
<h3>lpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">lpad</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength)</span></div>
<div class="block">SQL <code>LPAD(string, integer)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="lpad(org.apache.calcite.avatica.util.ByteString,int,org.apache.calcite.avatica.util.ByteString)">
<h3>lpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">lpad</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength,
 org.apache.calcite.avatica.util.ByteString&nbsp;pattern)</span></div>
<div class="block">SQL <code>LPAD(binary, integer, binary)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="lpad(org.apache.calcite.avatica.util.ByteString,int)">
<h3>lpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">lpad</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength)</span></div>
<div class="block">SQL <code>LPAD(binary, integer, binary)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="rpad(java.lang.String,int,java.lang.String)">
<h3>rpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">rpad</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>RPAD(string, integer, string)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="rpad(java.lang.String,int)">
<h3>rpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">rpad</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;originalValue,
 int&nbsp;returnLength)</span></div>
<div class="block">SQL <code>RPAD(string, integer)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="rpad(org.apache.calcite.avatica.util.ByteString,int,org.apache.calcite.avatica.util.ByteString)">
<h3>rpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">rpad</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength,
 org.apache.calcite.avatica.util.ByteString&nbsp;pattern)</span></div>
<div class="block">SQL <code>RPAD(binary, integer, binary)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="rpad(org.apache.calcite.avatica.util.ByteString,int)">
<h3>rpad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">rpad</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;originalValue,
 int&nbsp;returnLength)</span></div>
<div class="block">SQL <code>RPAD(binary, integer)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="endsWith(java.lang.String,java.lang.String)">
<h3>endsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">endsWith</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">SQL <code>ENDS_WITH(string, string)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="endsWith(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>endsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">endsWith</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</span></div>
<div class="block">SQL <code>ENDS_WITH(binary, binary)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="startsWith(java.lang.String,java.lang.String)">
<h3>startsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">startsWith</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">SQL <code>STARTS_WITH(string, string)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="startsWith(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>startsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">startsWith</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</span></div>
<div class="block">SQL <code>STARTS_WITH(binary, binary)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="substring(java.lang.String,int)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;c,
 int&nbsp;s)</span></div>
<div class="block">SQL SUBSTRING(string FROM ...) function.</div>
</section>
</li>
<li>
<section class="detail" id="substring(java.lang.String,int,int)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;c,
 int&nbsp;s,
 int&nbsp;l)</span></div>
<div class="block">SQL SUBSTRING(string FROM ... FOR ...) function.</div>
</section>
</li>
<li>
<section class="detail" id="substring(org.apache.calcite.avatica.util.ByteString,int)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;c,
 int&nbsp;s)</span></div>
<div class="block">SQL SUBSTRING(binary FROM ...) function for binary.</div>
</section>
</li>
<li>
<section class="detail" id="substring(org.apache.calcite.avatica.util.ByteString,int,int)">
<h3>substring</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">substring</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;c,
 int&nbsp;s,
 int&nbsp;l)</span></div>
<div class="block">SQL SUBSTRING(binary FROM ... FOR ...) function for binary.</div>
</section>
</li>
<li>
<section class="detail" id="upper(java.lang.String)">
<h3>upper</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">upper</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL UPPER(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="lower(java.lang.String)">
<h3>lower</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">lower</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL LOWER(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="initcap(java.lang.String)">
<h3>initcap</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">initcap</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL INITCAP(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="reverse(java.lang.String)">
<h3>reverse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">reverse</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL REVERSE(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="ascii(java.lang.String)">
<h3>ascii</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ascii</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL ASCII(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="repeat(java.lang.String,int)">
<h3>repeat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">repeat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</span></div>
<div class="block">SQL REPEAT(string, int) function.</div>
</section>
</li>
<li>
<section class="detail" id="space(int)">
<h3>space</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">space</span><wbr><span class="parameters">(int&nbsp;n)</span></div>
<div class="block">SQL SPACE(int) function.</div>
</section>
</li>
<li>
<section class="detail" id="strcmp(java.lang.String,java.lang.String)">
<h3>strcmp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">strcmp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">SQL STRCMP(String,String) function.</div>
</section>
</li>
<li>
<section class="detail" id="soundex(java.lang.String)">
<h3>soundex</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">soundex</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL SOUNDEX(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="difference(java.lang.String,java.lang.String)">
<h3>difference</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">difference</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">SQL DIFFERENCE(string, string) function.</div>
</section>
</li>
<li>
<section class="detail" id="left(java.lang.String,int)">
<h3>left</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">left</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</span></div>
<div class="block">SQL LEFT(string, integer) function.</div>
</section>
</li>
<li>
<section class="detail" id="left(org.apache.calcite.avatica.util.ByteString,int)">
<h3>left</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">left</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;n)</span></div>
<div class="block">SQL LEFT(ByteString, integer) function.</div>
</section>
</li>
<li>
<section class="detail" id="right(java.lang.String,int)">
<h3>right</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">right</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;n)</span></div>
<div class="block">SQL RIGHT(string, integer) function.</div>
</section>
</li>
<li>
<section class="detail" id="right(org.apache.calcite.avatica.util.ByteString,int)">
<h3>right</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">right</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;n)</span></div>
<div class="block">SQL RIGHT(ByteString, integer) function.</div>
</section>
</li>
<li>
<section class="detail" id="charFromAscii(int)">
<h3>charFromAscii</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">charFromAscii</span><wbr><span class="parameters">(int&nbsp;n)</span></div>
<div class="block">SQL CHAR(integer) function, as in MySQL and Spark.

 <p>Returns the ASCII character of <code>n</code> modulo 256,
 or null if <code>n</code> &lt; 0.</div>
</section>
</li>
<li>
<section class="detail" id="charFromUtf8(int)">
<h3>charFromUtf8</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">charFromUtf8</span><wbr><span class="parameters">(int&nbsp;n)</span></div>
<div class="block">SQL CHR(integer) function, as in Oracle and Postgres.

 <p>Returns the UTF-8 character whose code is <code>n</code>.</div>
</section>
</li>
<li>
<section class="detail" id="octetLength(org.apache.calcite.avatica.util.ByteString)">
<h3>octetLength</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">octetLength</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s)</span></div>
<div class="block">SQL OCTET_LENGTH(binary) function.</div>
</section>
</li>
<li>
<section class="detail" id="charLength(java.lang.String)">
<h3>charLength</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">charLength</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL CHARACTER_LENGTH(string) function.</div>
</section>
</li>
<li>
<section class="detail" id="concat(java.lang.String,java.lang.String)">
<h3>concat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">concat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">SQL <code>string || string</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="concat(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>concat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">concat</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s0,
 org.apache.calcite.avatica.util.ByteString&nbsp;s1)</span></div>
<div class="block">SQL <code>binary || binary</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="concatMulti(java.lang.String...)">
<h3>concatMulti</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">concatMulti</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;args)</span></div>
<div class="block">SQL <code>CONCAT(arg0, arg1, arg2, ...)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="rtrim(java.lang.String)">
<h3>rtrim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">rtrim</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL <code>RTRIM</code> function applied to string.</div>
</section>
</li>
<li>
<section class="detail" id="ltrim(java.lang.String)">
<h3>ltrim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ltrim</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL <code>LTRIM</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="trim(boolean,boolean,java.lang.String,java.lang.String)">
<h3>trim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">trim</span><wbr><span class="parameters">(boolean&nbsp;left,
 boolean&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL <code>TRIM(... seek FROM s)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="trim(boolean,boolean,java.lang.String,java.lang.String,boolean)">
<h3>trim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">trim</span><wbr><span class="parameters">(boolean&nbsp;left,
 boolean&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 boolean&nbsp;strict)</span></div>
</section>
</li>
<li>
<section class="detail" id="trim(org.apache.calcite.avatica.util.ByteString)">
<h3>trim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">trim</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s)</span></div>
<div class="block">SQL <code>TRIM</code> function applied to binary string.</div>
</section>
</li>
<li>
<section class="detail" id="rtrim(org.apache.calcite.avatica.util.ByteString)">
<h3>rtrim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">rtrim</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s)</span></div>
<div class="block">Helper for CAST.</div>
</section>
</li>
<li>
<section class="detail" id="overlay(java.lang.String,java.lang.String,int)">
<h3>overlay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">overlay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;r,
 int&nbsp;start)</span></div>
<div class="block">SQL <code>OVERLAY</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="overlay(java.lang.String,java.lang.String,int,int)">
<h3>overlay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">overlay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;r,
 int&nbsp;start,
 int&nbsp;length)</span></div>
<div class="block">SQL <code>OVERLAY</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="overlay(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int)">
<h3>overlay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">overlay</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 org.apache.calcite.avatica.util.ByteString&nbsp;r,
 int&nbsp;start)</span></div>
<div class="block">SQL <code>OVERLAY</code> function applied to binary strings.</div>
</section>
</li>
<li>
<section class="detail" id="overlay(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int,int)">
<h3>overlay</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">overlay</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;s,
 org.apache.calcite.avatica.util.ByteString&nbsp;r,
 int&nbsp;start,
 int&nbsp;length)</span></div>
<div class="block">SQL <code>OVERLAY</code> function applied to binary strings.</div>
</section>
</li>
<li>
<section class="detail" id="like(java.lang.String,java.lang.String)">
<h3>like</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">like</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>LIKE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="like(java.lang.String,java.lang.String,java.lang.String)">
<h3>like</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">like</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</span></div>
<div class="block">SQL <code>LIKE</code> function with escape.</div>
</section>
</li>
<li>
<section class="detail" id="ilike(java.lang.String,java.lang.String)">
<h3>ilike</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ilike</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>ILIKE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="ilike(java.lang.String,java.lang.String,java.lang.String)">
<h3>ilike</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ilike</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</span></div>
<div class="block">SQL <code>ILIKE</code> function with escape.</div>
</section>
</li>
<li>
<section class="detail" id="rlike(java.lang.String,java.lang.String)">
<h3>rlike</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">rlike</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>RLIKE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="similar(java.lang.String,java.lang.String)">
<h3>similar</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">similar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern)</span></div>
<div class="block">SQL <code>SIMILAR</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="similar(java.lang.String,java.lang.String,java.lang.String)">
<h3>similar</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">similar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;pattern,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;escape)</span></div>
<div class="block">SQL <code>SIMILAR</code> function with escape.</div>
</section>
</li>
<li>
<section class="detail" id="posixRegex(java.lang.String,java.lang.String,boolean)">
<h3>posixRegex</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">posixRegex</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;regex,
 boolean&nbsp;caseSensitive)</span></div>
</section>
</li>
<li>
<section class="detail" id="eq(java.math.BigDecimal,java.math.BigDecimal)">
<h3>eq</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eq</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>=</code> operator applied to BigDecimal values (neither may be
 null).</div>
</section>
</li>
<li>
<section class="detail" id="eq(java.lang.Object[],java.lang.Object[])">
<h3>eq</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eq</span><wbr><span class="parameters">(@Nullable <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> @Nullable []&nbsp;b0,
 @Nullable <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> @Nullable []&nbsp;b1)</span></div>
<div class="block">SQL <code>=</code> operator applied to Object[] values (neither may be
 null).</div>
</section>
</li>
<li>
<section class="detail" id="eq(java.lang.Object,java.lang.Object)">
<h3>eq</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eq</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>=</code> operator applied to Object values (including String;
 neither side may be null).</div>
</section>
</li>
<li>
<section class="detail" id="eq(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>eq</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eq</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>=</code> operator applied to String values with a certain Comparator.</div>
</section>
</li>
<li>
<section class="detail" id="eqAny(java.lang.Object,java.lang.Object)">
<h3>eqAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eqAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>=</code> operator applied to Object values (at least one operand
 has ANY type; neither may be null).</div>
</section>
</li>
<li>
<section class="detail" id="ne(java.math.BigDecimal,java.math.BigDecimal)">
<h3>ne</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ne</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;gt;</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="ne(java.lang.Object,java.lang.Object)">
<h3>ne</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ne</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;gt;</code> operator applied to Object values (including
 String; neither side may be null).</div>
</section>
</li>
<li>
<section class="detail" id="ne(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>ne</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ne</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>&lt;gt;</code> operator applied to OString values with a certain Comparator.</div>
</section>
</li>
<li>
<section class="detail" id="neAny(java.lang.Object,java.lang.Object)">
<h3>neAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">neAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;gt;</code> operator applied to Object values (at least one
  operand has ANY type, including String; neither may be null).</div>
</section>
</li>
<li>
<section class="detail" id="lt(boolean,boolean)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to boolean values.</div>
</section>
</li>
<li>
<section class="detail" id="lt(java.lang.String,java.lang.String)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="lt(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="lt(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to ByteString values.</div>
</section>
</li>
<li>
<section class="detail" id="lt(java.math.BigDecimal,java.math.BigDecimal)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="ltNullable(T,T)">
<h3 id="ltNullable(java.lang.Comparable,java.lang.Comparable)">ltNullable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ltNullable</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">Returns whether <code>b0</code> is less than <code>b1</code>
 (or <code>b1</code> is null). Helper for <code>ARG_MIN</code>.</div>
</section>
</li>
<li>
<section class="detail" id="lt(byte,byte)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(char,char)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(char&nbsp;b0,
 char&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(short,short)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(int,int)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(long,long)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(float,float)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(float&nbsp;b0,
 float&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lt(double,double)">
<h3>lt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lt</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="ltAny(java.lang.Object,java.lang.Object)">
<h3>ltAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ltAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&lt;</code> operator applied to Object values.</div>
</section>
</li>
<li>
<section class="detail" id="le(boolean,boolean)">
<h3>le</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">le</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to boolean values.</div>
</section>
</li>
<li>
<section class="detail" id="le(java.lang.String,java.lang.String)">
<h3>le</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">le</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="le(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>le</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">le</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="le(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>le</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">le</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to ByteString values.</div>
</section>
</li>
<li>
<section class="detail" id="le(java.math.BigDecimal,java.math.BigDecimal)">
<h3>le</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">le</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="leAny(java.lang.Object,java.lang.Object)">
<h3>leAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">leAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&le;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</section>
</li>
<li>
<section class="detail" id="gt(boolean,boolean)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to boolean values.</div>
</section>
</li>
<li>
<section class="detail" id="gt(java.lang.String,java.lang.String)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="gt(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="gt(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to ByteString values.</div>
</section>
</li>
<li>
<section class="detail" id="gt(java.math.BigDecimal,java.math.BigDecimal)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="gtNullable(T,T)">
<h3 id="gtNullable(java.lang.Comparable,java.lang.Comparable)">gtNullable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gtNullable</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">Returns whether <code>b0</code> is greater than <code>b1</code>
 (or <code>b1</code> is null). Helper for <code>ARG_MAX</code>.</div>
</section>
</li>
<li>
<section class="detail" id="gt(byte,byte)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(char,char)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(char&nbsp;b0,
 char&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(short,short)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(int,int)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(long,long)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(float,float)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(float&nbsp;b0,
 float&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gt(double,double)">
<h3>gt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gt</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="gtAny(java.lang.Object,java.lang.Object)">
<h3>gtAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">gtAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&gt;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</section>
</li>
<li>
<section class="detail" id="ge(boolean,boolean)">
<h3>ge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ge</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to boolean values.</div>
</section>
</li>
<li>
<section class="detail" id="ge(java.lang.String,java.lang.String)">
<h3>ge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ge</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="ge(java.lang.String,java.lang.String,java.util.Comparator)">
<h3>ge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ge</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;b1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Comparator.html" title="class or interface in java.util" class="external-link">Comparator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;comparator)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to String values.</div>
</section>
</li>
<li>
<section class="detail" id="ge(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>ge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ge</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to ByteString values.</div>
</section>
</li>
<li>
<section class="detail" id="ge(java.math.BigDecimal,java.math.BigDecimal)">
<h3>ge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ge</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="geAny(java.lang.Object,java.lang.Object)">
<h3>geAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">geAny</span><wbr><span class="parameters">(<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>&nbsp;b0,
 <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>&ge;</code> operator applied to Object values (at least one
 operand has ANY type; neither may be null).</div>
</section>
</li>
<li>
<section class="detail" id="plus(int,int)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="plus(java.lang.Integer,int)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to int values; left side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="plus(int,java.lang.Integer)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to int values; right side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="plus(java.lang.Integer,java.lang.Integer)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to nullable int values.</div>
</section>
</li>
<li>
<section class="detail" id="plus(java.lang.Long,java.lang.Integer)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to nullable long and int values.</div>
</section>
</li>
<li>
<section class="detail" id="plus(java.lang.Integer,java.lang.Long)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to nullable int and long values.</div>
</section>
</li>
<li>
<section class="detail" id="plus(java.math.BigDecimal,java.math.BigDecimal)">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">plus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="plusAny(java.lang.Object,java.lang.Object)">
<h3>plusAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <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>&nbsp;<span class="element-name">plusAny</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>+</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</section>
</li>
<li>
<section class="detail" id="minus(int,int)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="minus(java.lang.Integer,int)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to int values; left side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="minus(int,java.lang.Integer)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to int values; right side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="minus(java.lang.Integer,java.lang.Integer)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to nullable int values.</div>
</section>
</li>
<li>
<section class="detail" id="minus(java.lang.Long,java.lang.Integer)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to nullable long and int values.</div>
</section>
</li>
<li>
<section class="detail" id="minus(java.lang.Integer,java.lang.Long)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to nullable int and long values.</div>
</section>
</li>
<li>
<section class="detail" id="minus(java.math.BigDecimal,java.math.BigDecimal)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to nullable BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="minusAny(java.lang.Object,java.lang.Object)">
<h3>minusAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <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>&nbsp;<span class="element-name">minusAny</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>-</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</section>
</li>
<li>
<section class="detail" id="divide(int,int)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="divide(java.lang.Integer,int)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to int values; left side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="divide(int,java.lang.Integer)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to int values; right side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="divide(java.lang.Integer,java.lang.Integer)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to nullable int values.</div>
</section>
</li>
<li>
<section class="detail" id="divide(java.lang.Long,java.lang.Integer)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to nullable long and int values.</div>
</section>
</li>
<li>
<section class="detail" id="divide(java.lang.Integer,java.lang.Long)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to nullable int and long values.</div>
</section>
</li>
<li>
<section class="detail" id="divide(java.math.BigDecimal,java.math.BigDecimal)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="divideAny(java.lang.Object,java.lang.Object)">
<h3>divideAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <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>&nbsp;<span class="element-name">divideAny</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>/</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</section>
</li>
<li>
<section class="detail" id="divide(int,java.math.BigDecimal)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="divide(long,java.math.BigDecimal)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(long&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="multiply(int,int)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(java.lang.Integer,int)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to int values; left side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(int,java.lang.Integer)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(int&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to int values; right side may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(java.lang.Integer,java.lang.Integer)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to nullable int values.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(java.lang.Long,java.lang.Integer)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to nullable long and int values.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(java.lang.Integer,java.lang.Long)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to nullable int and long values.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(java.math.BigDecimal,java.math.BigDecimal)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to nullable BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAny(java.lang.Object,java.lang.Object)">
<h3>multiplyAny</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <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>&nbsp;<span class="element-name">multiplyAny</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;b0,
 @PolyNull <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>&nbsp;b1)</span></div>
<div class="block">SQL <code>*</code> operator applied to Object values (at least one operand
 has ANY type; either may be null).</div>
</section>
</li>
<li>
<section class="detail" id="bitAnd(long,long)">
<h3>bitAnd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">bitAnd</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_AND</code> applied to integer values.</div>
</section>
</li>
<li>
<section class="detail" id="bitAnd(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>bitAnd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">bitAnd</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_AND</code> applied to binary values.</div>
</section>
</li>
<li>
<section class="detail" id="bitOr(long,long)">
<h3>bitOr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">bitOr</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_OR</code> applied to integer values.</div>
</section>
</li>
<li>
<section class="detail" id="bitOr(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>bitOr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">bitOr</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_OR</code> applied to binary values.</div>
</section>
</li>
<li>
<section class="detail" id="bitXor(long,long)">
<h3>bitXor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">bitXor</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_XOR</code> applied to integer values.</div>
</section>
</li>
<li>
<section class="detail" id="bitXor(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>bitXor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">bitXor</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;b0,
 org.apache.calcite.avatica.util.ByteString&nbsp;b1)</span></div>
<div class="block">Bitwise function <code>BIT_XOR</code> applied to binary values.</div>
</section>
</li>
<li>
<section class="detail" id="exp(double)">
<h3>exp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">exp</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>EXP</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="exp(java.math.BigDecimal)">
<h3>exp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">exp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="power(double,double)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
<div class="block">SQL <code>POWER</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="power(double,java.math.BigDecimal)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(double&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="power(java.math.BigDecimal,double)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 double&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="power(java.math.BigDecimal,java.math.BigDecimal)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="ln(double)">
<h3>ln</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">ln</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">SQL <code>LN(number)</code> function applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="ln(java.math.BigDecimal)">
<h3>ln</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">ln</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;d)</span></div>
<div class="block">SQL <code>LN(number)</code> function applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="log10(double)">
<h3>log10</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">log10</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>LOG10(numeric)</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="log10(java.math.BigDecimal)">
<h3>log10</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">log10</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;d)</span></div>
<div class="block">SQL <code>LOG10(number)</code> function applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="mod(byte,byte)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
<div class="block">SQL <code>MOD</code> operator applied to byte values.</div>
</section>
</li>
<li>
<section class="detail" id="mod(short,short)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
<div class="block">SQL <code>MOD</code> operator applied to short values.</div>
</section>
</li>
<li>
<section class="detail" id="mod(int,int)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>MOD</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="mod(long,long)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">SQL <code>MOD</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="mod(java.math.BigDecimal,int)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="mod(int,java.math.BigDecimal)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="mod(java.math.BigDecimal,java.math.BigDecimal)">
<h3>mod</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">mod</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(double)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(float)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(float&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(java.math.BigDecimal)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(byte,byte)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
<div class="block">SQL <code>FLOOR</code> operator applied to byte values.</div>
</section>
</li>
<li>
<section class="detail" id="floor(short,short)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
<div class="block">SQL <code>FLOOR</code> operator applied to short values.</div>
</section>
</li>
<li>
<section class="detail" id="floor(int,int)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>FLOOR</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="floor(long,long)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">SQL <code>FLOOR</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="floor(java.math.BigDecimal,int)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(int,java.math.BigDecimal)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="floor(java.math.BigDecimal,java.math.BigDecimal)">
<h3>floor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">floor</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(double)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(float)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(float&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(java.math.BigDecimal)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(byte,byte)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
<div class="block">SQL <code>CEIL</code> operator applied to byte values.</div>
</section>
</li>
<li>
<section class="detail" id="ceil(short,short)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
<div class="block">SQL <code>CEIL</code> operator applied to short values.</div>
</section>
</li>
<li>
<section class="detail" id="ceil(int,int)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>CEIL</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="ceil(long,long)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
<div class="block">SQL <code>CEIL</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="ceil(java.math.BigDecimal,int)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(int,java.math.BigDecimal)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(int&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="ceil(java.math.BigDecimal,java.math.BigDecimal)">
<h3>ceil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">ceil</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="abs(byte)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(byte&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to byte values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(short)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(short&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to short values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(int)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(int&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(long)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(long&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(float)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(float&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to float values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(double)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="abs(java.math.BigDecimal)">
<h3>abs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">abs</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>ABS</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="acos(java.math.BigDecimal)">
<h3>acos</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">acos</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>ACOS</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="acos(double)">
<h3>acos</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">acos</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>ACOS</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="asin(java.math.BigDecimal)">
<h3>asin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">asin</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>ASIN</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="asin(double)">
<h3>asin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">asin</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>ASIN</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="atan(java.math.BigDecimal)">
<h3>atan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>ATAN</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="atan(double)">
<h3>atan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>ATAN</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="atan2(double,java.math.BigDecimal)">
<h3>atan2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan2</span><wbr><span class="parameters">(double&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>ATAN2</code> operator applied to double/BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="atan2(java.math.BigDecimal,double)">
<h3>atan2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan2</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 double&nbsp;b1)</span></div>
<div class="block">SQL <code>ATAN2</code> operator applied to BigDecimal/double values.</div>
</section>
</li>
<li>
<section class="detail" id="atan2(java.math.BigDecimal,java.math.BigDecimal)">
<h3>atan2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan2</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b1)</span></div>
<div class="block">SQL <code>ATAN2</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="atan2(double,double)">
<h3>atan2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">atan2</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
<div class="block">SQL <code>ATAN2</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="cbrt(java.math.BigDecimal)">
<h3>cbrt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cbrt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</span></div>
<div class="block">SQL <code>CBRT</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="cbrt(double)">
<h3>cbrt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cbrt</span><wbr><span class="parameters">(double&nbsp;b)</span></div>
<div class="block">SQL <code>CBRT</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="cos(java.math.BigDecimal)">
<h3>cos</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cos</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>COS</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="cos(double)">
<h3>cos</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cos</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>COS</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="cosh(java.math.BigDecimal)">
<h3>cosh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cosh</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</span></div>
<div class="block">SQL <code>COSH</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="cosh(double)">
<h3>cosh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cosh</span><wbr><span class="parameters">(double&nbsp;b)</span></div>
<div class="block">SQL <code>COSH</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="cot(java.math.BigDecimal)">
<h3>cot</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cot</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>COT</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="cot(double)">
<h3>cot</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">cot</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>COT</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="degrees(java.math.BigDecimal)">
<h3>degrees</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">degrees</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>DEGREES</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="degrees(double)">
<h3>degrees</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">degrees</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>DEGREES</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="radians(java.math.BigDecimal)">
<h3>radians</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">radians</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>RADIANS</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="radians(double)">
<h3>radians</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">radians</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>RADIANS</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(int)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(int&nbsp;b0)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(int,int)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(long)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(long&nbsp;b0)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(long,int)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(long&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(java.math.BigDecimal)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(java.math.BigDecimal,int)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(double)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="sround(double,int)">
<h3>sround</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sround</span><wbr><span class="parameters">(double&nbsp;b0,
 int&nbsp;b1)</span></div>
<div class="block">SQL <code>ROUND</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="struncate(int)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(int&nbsp;b0)</span></div>
<div class="block">SQL <code>TRUNCATE</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="struncate(int,int)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="struncate(long)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(long&nbsp;b0)</span></div>
<div class="block">SQL <code>TRUNCATE</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="struncate(long,int)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(long&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="struncate(java.math.BigDecimal)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>TRUNCATE</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="struncate(java.math.BigDecimal,int)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="struncate(double)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>TRUNCATE</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="struncate(double,int)">
<h3>struncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">struncate</span><wbr><span class="parameters">(double&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="sign(int)">
<h3>sign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">sign</span><wbr><span class="parameters">(int&nbsp;b0)</span></div>
<div class="block">SQL <code>SIGN</code> operator applied to int values.</div>
</section>
</li>
<li>
<section class="detail" id="sign(long)">
<h3>sign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sign</span><wbr><span class="parameters">(long&nbsp;b0)</span></div>
<div class="block">SQL <code>SIGN</code> operator applied to long values.</div>
</section>
</li>
<li>
<section class="detail" id="sign(java.math.BigDecimal)">
<h3>sign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">sign</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>SIGN</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="sign(double)">
<h3>sign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sign</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>SIGN</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="sin(java.math.BigDecimal)">
<h3>sin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sin</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>SIN</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="sin(double)">
<h3>sin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sin</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>SIN</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="sinh(java.math.BigDecimal)">
<h3>sinh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sinh</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</span></div>
<div class="block">SQL <code>SINH</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="sinh(double)">
<h3>sinh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">sinh</span><wbr><span class="parameters">(double&nbsp;b)</span></div>
<div class="block">SQL <code>SINH</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="tan(java.math.BigDecimal)">
<h3>tan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">tan</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b0)</span></div>
<div class="block">SQL <code>TAN</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="tan(double)">
<h3>tan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">tan</span><wbr><span class="parameters">(double&nbsp;b0)</span></div>
<div class="block">SQL <code>TAN</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="tanh(java.math.BigDecimal)">
<h3>tanh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">tanh</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;b)</span></div>
<div class="block">SQL <code>TANH</code> operator applied to BigDecimal values.</div>
</section>
</li>
<li>
<section class="detail" id="tanh(double)">
<h3>tanh</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">tanh</span><wbr><span class="parameters">(double&nbsp;b)</span></div>
<div class="block">SQL <code>TANH</code> operator applied to double values.</div>
</section>
</li>
<li>
<section class="detail" id="lesser(T,T)">
<h3 id="lesser(java.lang.Comparable,java.lang.Comparable)">lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">Helper for implementing MIN. Somewhat similar to LEAST operator.</div>
</section>
</li>
<li>
<section class="detail" id="least(T,T)">
<h3 id="least(java.lang.Comparable,java.lang.Comparable)">least</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">least</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">LEAST operator.</div>
</section>
</li>
<li>
<section class="detail" id="greater(boolean,boolean)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(boolean,boolean)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(boolean&nbsp;b0,
 boolean&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(byte,byte)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(byte,byte)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(byte&nbsp;b0,
 byte&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(char,char)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(char&nbsp;b0,
 char&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(char,char)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(char&nbsp;b0,
 char&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(short,short)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(short,short)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(short&nbsp;b0,
 short&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(int,int)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(int,int)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(int&nbsp;b0,
 int&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(long,long)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(long,long)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(long&nbsp;b0,
 long&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(float,float)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(float&nbsp;b0,
 float&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(float,float)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(float&nbsp;b0,
 float&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(double,double)">
<h3>greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="lesser(double,double)">
<h3>lesser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">lesser</span><wbr><span class="parameters">(double&nbsp;b0,
 double&nbsp;b1)</span></div>
</section>
</li>
<li>
<section class="detail" id="greater(T,T)">
<h3 id="greater(java.lang.Comparable,java.lang.Comparable)">greater</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">greater</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">Helper for implementing MAX. Somewhat similar to GREATEST operator.</div>
</section>
</li>
<li>
<section class="detail" id="greatest(T,T)">
<h3 id="greatest(java.lang.Comparable,java.lang.Comparable)">greatest</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">greatest</span><wbr><span class="parameters">(T&nbsp;b0,
 T&nbsp;b1)</span></div>
<div class="block">GREATEST operator.</div>
</section>
</li>
<li>
<section class="detail" id="toString(float)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(float&nbsp;x)</span></div>
<div class="block">CAST(FLOAT AS VARCHAR).</div>
</section>
</li>
<li>
<section class="detail" id="toString(double)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(double&nbsp;x)</span></div>
<div class="block">CAST(DOUBLE AS VARCHAR).</div>
</section>
</li>
<li>
<section class="detail" id="toString(java.math.BigDecimal)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x)</span></div>
<div class="block">CAST(DECIMAL AS VARCHAR).</div>
</section>
</li>
<li>
<section class="detail" id="toString(boolean)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(boolean&nbsp;x)</span></div>
<div class="block">CAST(BOOLEAN AS VARCHAR).</div>
</section>
</li>
<li>
<section class="detail" id="toBoolean(java.lang.String)">
<h3>toBoolean</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">toBoolean</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">CAST(VARCHAR AS BOOLEAN).</div>
</section>
</li>
<li>
<section class="detail" id="toBoolean(java.lang.Number)">
<h3>toBoolean</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">toBoolean</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toBoolean(java.lang.Object)">
<h3>toBoolean</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">toBoolean</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toByte(java.lang.Object)">
<h3>toByte</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">toByte</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toByte(java.lang.Number)">
<h3>toByte</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">toByte</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toChar(java.lang.String)">
<h3>toChar</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">toChar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toCharBoxed(java.lang.String)">
<h3>toCharBoxed</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a></span>&nbsp;<span class="element-name">toCharBoxed</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toShort(java.lang.String)">
<h3>toShort</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">toShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toShort(java.lang.Number)">
<h3>toShort</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">toShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toShort(java.lang.Object)">
<h3>toShort</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">toShort</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toInt(java.sql.Date)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v)</span></div>
<div class="block">Converts a SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <code>int</code>)
 in the local time zone.

 <p>Since a time zone is not available, the date is converted to represent
 the same date as a Unix date in UTC as the <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a> value in
 the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toInt(java.sql.Date,java.util.TimeZone)"><code>toInt(java.sql.Date, TimeZone)</code></a></li>
<li><a href="#internalToDate(int)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toInt(java.sql.Date,java.util.TimeZone)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
<div class="block">Converts a SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <code>int</code>).

 <p>The <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a> class uses the standard Gregorian calendar
 which switches from the Julian calendar to the Gregorian calendar in
 October 1582. For compatibility with ISO-8601, the internal representation
 is converted to use the proleptic Gregorian calendar.

 <p>If the date contains a partial day, it will be rounded to a full day
 depending on the milliseconds value. If the milliseconds value is positive,
 it will be rounded down to the closest full day. If the milliseconds value
 is negative, it will be rounded up to the closest full day.</div>
</section>
</li>
<li>
<section class="detail" id="toIntOptional(java.sql.Date)">
<h3>toIntOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toIntOptional</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>)
 in the local time zone.

 <p>Since a time zone is not available, the date is converted to represent
 the same date as a Unix date in UTC as the <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a> value in
 the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toInt(java.sql.Date,java.util.TimeZone)"><code>toInt(java.sql.Date, TimeZone)</code></a></li>
<li><a href="#internalToDate(java.lang.Integer)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toIntOptional(java.sql.Date,java.util.TimeZone)">
<h3>toIntOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toIntOptional</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
<div class="block">Converts a nullable SQL DATE value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of days since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toInt(java.sql.Date,java.util.TimeZone)"><code>toInt(java.sql.Date, TimeZone)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toInt(java.sql.Time)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a>&nbsp;v)</span></div>
<div class="block">Converts a SQL TIME value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>int</code>)
 in the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#toIntOptional(java.lang.Object)"><code>toIntOptional(java.sql.Time)</code></a></li>
<li><a href="#internalToTime(int)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toIntOptional(java.sql.Time)">
<h3>toIntOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toIntOptional</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL TIME value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#toInt(java.lang.Object)"><code>toInt(java.sql.Time)</code></a></li>
<li><a href="#internalToTime(java.lang.Integer)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toInt(java.lang.String)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toInt(java.lang.Number)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toInt(java.lang.Object)">
<h3>toInt</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">toInt</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toIntOptional(java.lang.Object)">
<h3>toIntOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toIntOptional</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toLong(java.util.Date)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;v)</span></div>
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link"><code>Date</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).

 <p>Since a time zone is not available, converts the timestamp to represent
 the same date and time as a Unix timestamp in UTC as the
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link"><code>Date</code></a> value in the local time zone.

 <p>The <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link"><code>Date</code></a> class uses the standard Gregorian calendar
 which switches from the Julian calendar to the Gregorian calendar in
 October 1582. For compatibility with ISO-8601, converts the internal
 representation to use the proleptic Gregorian calendar.</div>
</section>
</li>
<li>
<section class="detail" id="toLong(java.sql.Timestamp)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v)</span></div>
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).

 <p>Since a time zone is not available, converts the timestamp to represent
 the same date and time as a Unix timestamp in UTC as the
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a> value in the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)"><code>toLong(Timestamp, TimeZone)</code></a></li>
<li><a href="#internalToTimestamp(java.lang.Long)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toLong(java.sql.Timestamp,java.util.TimeZone)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
<div class="block">Converts a SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <code>long</code>).

 <p>For backwards compatibility, time zone offsets are calculated in
 relation to the local time zone instead of UTC. Providing the default time
 zone or <code>null</code> will return the timestamp unmodified.

 <p>The <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a> class uses the standard Gregorian calendar which
 switches from the Julian calendar to the Gregorian calendar in
 October 1582. For compatibility with ISO-8601, the internal representation
 is converted to use the proleptic Gregorian calendar.</div>
</section>
</li>
<li>
<section class="detail" id="toLongOptional(java.sql.Timestamp)">
<h3>toLongOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">toLongOptional</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a>)
 in the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)"><code>toLong(Timestamp, TimeZone)</code></a></li>
<li><a href="#internalToTimestamp(java.lang.Long)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toLongOptional(java.sql.Timestamp,java.util.TimeZone)">
<h3>toLongOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">toLongOptional</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
<div class="block">Converts a nullable SQL TIMESTAMP value from the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>) to the internal representation type
 (number of milliseconds since January 1st, 1970 as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)"><code>toLong(Timestamp, TimeZone)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toLong(java.lang.String)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toLong(java.lang.Number)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toLong(java.lang.Object)">
<h3>toLong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">toLong</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toLongOptional(java.lang.Object)">
<h3>toLongOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">toLongOptional</span><wbr><span class="parameters">(@PolyNull <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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toFloat(java.lang.String)">
<h3>toFloat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">toFloat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toFloat(java.lang.Number)">
<h3>toFloat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">toFloat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toFloat(java.lang.Object)">
<h3>toFloat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">toFloat</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toDouble(java.lang.String)">
<h3>toDouble</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">toDouble</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toDouble(java.lang.Number)">
<h3>toDouble</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">toDouble</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toDouble(java.lang.Object)">
<h3>toDouble</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">toDouble</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toBigDecimal(java.lang.String)">
<h3>toBigDecimal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">toBigDecimal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toBigDecimal(java.lang.Number)">
<h3>toBigDecimal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">toBigDecimal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link">Number</a>&nbsp;number)</span></div>
</section>
</li>
<li>
<section class="detail" id="toBigDecimal(java.lang.Object)">
<h3>toBigDecimal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a></span>&nbsp;<span class="element-name">toBigDecimal</span><wbr><span class="parameters">(<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>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="internalToDate(int)">
<h3>internalToDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a></span>&nbsp;<span class="element-name">internalToDate</span><wbr><span class="parameters">(int&nbsp;v)</span></div>
<div class="block">Converts a SQL DATE value from the internal representation type
 (number of days since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>).

 <p>Since a time zone is not available, converts the date to represent the
 same date as a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a> in the local time zone as the Unix
 date in UTC.

 <p>The Unix date should be the number of days since January 1st, 1970
 using the proleptic Gregorian calendar as defined by ISO-8601. The
 returned <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a> object will use the standard Gregorian
 calendar which switches from the Julian calendar to the Gregorian calendar
 in October 1582.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#internalToDate(java.lang.Integer)"><code>internalToDate(Integer)</code></a></li>
<li><a href="#toInt(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="internalToDate(java.lang.Integer)">
<h3>internalToDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link">Date</a></span>&nbsp;<span class="element-name">internalToDate</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL DATE value from the internal representation type
 (number of days since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Date.html" title="class or interface in java.sql" class="external-link"><code>Date</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#internalToDate(int)"><code>internalToDate(int)</code></a></li>
<li><a href="#toIntOptional(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="internalToTime(int)">
<h3>internalToTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a></span>&nbsp;<span class="element-name">internalToTime</span><wbr><span class="parameters">(int&nbsp;v)</span></div>
<div class="block">Converts a SQL TIME value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#internalToTime(java.lang.Integer)"><code>internalToTime(Integer)</code></a></li>
<li><a href="#toInt(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="internalToTime(java.lang.Integer)">
<h3>internalToTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link">Time</a></span>&nbsp;<span class="element-name">internalToTime</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL TIME value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Time.html" title="class or interface in java.sql" class="external-link"><code>Time</code></a>).</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#internalToTime(java.lang.Integer)"><code>internalToTime(Integer)</code></a></li>
<li><a href="#toIntOptional(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toTimeWithLocalTimeZone(java.lang.String)">
<h3>toTimeWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toTimeWithLocalTimeZone</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="toTimeWithLocalTimeZone(java.lang.String,java.util.TimeZone)">
<h3>toTimeWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">toTimeWithLocalTimeZone</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timeWithLocalTimeZoneToTime(int,java.util.TimeZone)">
<h3>timeWithLocalTimeZoneToTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timeWithLocalTimeZoneToTime</span><wbr><span class="parameters">(int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timeWithLocalTimeZoneToTimestamp(java.lang.String,int,java.util.TimeZone)">
<h3>timeWithLocalTimeZoneToTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timeWithLocalTimeZoneToTimestamp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;date,
 int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timeWithLocalTimeZoneToTimestampWithLocalTimeZone(java.lang.String,int)">
<h3>timeWithLocalTimeZoneToTimestampWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timeWithLocalTimeZoneToTimestampWithLocalTimeZone</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;date,
 int&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="timeWithLocalTimeZoneToString(int,java.util.TimeZone)">
<h3>timeWithLocalTimeZoneToString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">timeWithLocalTimeZoneToString</span><wbr><span class="parameters">(int&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="internalToTimestamp(long)">
<h3>internalToTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a></span>&nbsp;<span class="element-name">internalToTimestamp</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">Converts a SQL TIMESTAMP value from the internal representation type
 (number of milliseconds since January 1st, 1970) to the Java Type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>)
 in the local time zone.

 <p>Since a time zone is not available, the timestamp is converted to
 represent the same timestamp as a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a> in the local time zone
 as the Unix timestamp in UTC.

 <p>The Unix timestamp should be the number of milliseconds since
 January 1st, 1970 using the proleptic Gregorian calendar as defined by
 ISO-8601. The returned <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a> object will use the standard
 Gregorian calendar which switches from the Julian calendar to the
 Gregorian calendar in October 1582.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#internalToTimestamp(java.lang.Long)"><code>internalToTimestamp(Long)</code></a></li>
<li><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)"><code>toLong(Timestamp, TimeZone)</code></a></li>
<li><a href="#toLongOptional(java.lang.Object)"><code>toLongOptional(Timestamp)</code></a></li>
<li><a href="#toLongOptional(java.sql.Timestamp,java.util.TimeZone)"><code>toLongOptional(Timestamp, TimeZone)</code></a></li>
<li><a href="#toLong(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="internalToTimestamp(java.lang.Long)">
<h3>internalToTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a></span>&nbsp;<span class="element-name">internalToTimestamp</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;v)</span></div>
<div class="block">Converts a nullable SQL TIMESTAMP value from the internal representation
 type (number of milliseconds since January 1st, 1970) to the Java Type
 (<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link"><code>Timestamp</code></a>)
 in the local time zone.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#internalToTimestamp(long)"><code>internalToTimestamp(long)</code></a></li>
<li><a href="#toLong(java.lang.Object)"><code>toLong(Timestamp)</code></a></li>
<li><a href="#toLong(java.sql.Timestamp,java.util.TimeZone)"><code>toLong(Timestamp, TimeZone)</code></a></li>
<li><a href="#toLongOptional(java.sql.Timestamp,java.util.TimeZone)"><code>toLongOptional(Timestamp, TimeZone)</code></a></li>
<li><a href="#toLongOptional(java.lang.Object)"><code>converse method</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="timestampWithLocalTimeZoneToDate(long,java.util.TimeZone)">
<h3>timestampWithLocalTimeZoneToDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timestampWithLocalTimeZoneToDate</span><wbr><span class="parameters">(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timestampWithLocalTimeZoneToTime(long,java.util.TimeZone)">
<h3>timestampWithLocalTimeZoneToTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timestampWithLocalTimeZoneToTime</span><wbr><span class="parameters">(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timestampWithLocalTimeZoneToTimestamp(long,java.util.TimeZone)">
<h3>timestampWithLocalTimeZoneToTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestampWithLocalTimeZoneToTimestamp</span><wbr><span class="parameters">(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timestampWithLocalTimeZoneToString(long,java.util.TimeZone)">
<h3>timestampWithLocalTimeZoneToString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">timestampWithLocalTimeZoneToString</span><wbr><span class="parameters">(long&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="timestampWithLocalTimeZoneToTimeWithLocalTimeZone(long)">
<h3>timestampWithLocalTimeZoneToTimeWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timestampWithLocalTimeZoneToTimeWithLocalTimeZone</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="timestampSeconds(long)">
<h3>timestampSeconds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestampSeconds</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_SECONDS"><code>SqlLibraryOperators.TIMESTAMP_SECONDS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="timestampMillis(long)">
<h3>timestampMillis</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestampMillis</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_MILLIS"><code>SqlLibraryOperators.TIMESTAMP_MILLIS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="timestampMicros(long)">
<h3>timestampMicros</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestampMicros</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#TIMESTAMP_MICROS"><code>SqlLibraryOperators.TIMESTAMP_MICROS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="unixSeconds(long)">
<h3>unixSeconds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">unixSeconds</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_SECONDS"><code>SqlLibraryOperators.UNIX_SECONDS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="unixMillis(long)">
<h3>unixMillis</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">unixMillis</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_MILLIS"><code>SqlLibraryOperators.UNIX_MILLIS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="unixMicros(long)">
<h3>unixMicros</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">unixMicros</span><wbr><span class="parameters">(long&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_MICROS"><code>SqlLibraryOperators.UNIX_MICROS</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="dateFromUnixDate(int)">
<h3>dateFromUnixDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">dateFromUnixDate</span><wbr><span class="parameters">(int&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#DATE_FROM_UNIX_DATE"><code>SqlLibraryOperators.DATE_FROM_UNIX_DATE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="unixDate(int)">
<h3>unixDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">unixDate</span><wbr><span class="parameters">(int&nbsp;v)</span></div>
<div class="block">For <a href="../sql/fun/SqlLibraryOperators.html#UNIX_DATE"><code>SqlLibraryOperators.UNIX_DATE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="date(int,int,int)">
<h3>date</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">date</span><wbr><span class="parameters">(int&nbsp;year,
 int&nbsp;month,
 int&nbsp;day)</span></div>
<div class="block">SQL <code>DATE(year, month, day)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="date(long)">
<h3>date</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">date</span><wbr><span class="parameters">(long&nbsp;timestampMillis)</span></div>
<div class="block">SQL <code>DATE(TIMESTAMP)</code> and
 <code>DATE(TIMESTAMP WITH LOCAL TIME ZONE)</code> functions.</div>
</section>
</li>
<li>
<section class="detail" id="date(long,java.lang.String)">
<h3>date</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">date</span><wbr><span class="parameters">(long&nbsp;timestampMillis,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>DATE(TIMESTAMP WITH LOCAL TIME, timeZone)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="datetime(int,int,int,int,int,int)">
<h3>datetime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">datetime</span><wbr><span class="parameters">(int&nbsp;year,
 int&nbsp;month,
 int&nbsp;day,
 int&nbsp;hour,
 int&nbsp;minute,
 int&nbsp;second)</span></div>
<div class="block">SQL <code>DATETIME(&lt;year&gt;, &lt;month&gt;, &lt;day&gt;, &lt;hour&gt;, &lt;minute&gt;, &lt;second&gt;)</code>
 function.</div>
</section>
</li>
<li>
<section class="detail" id="datetime(int)">
<h3>datetime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">datetime</span><wbr><span class="parameters">(int&nbsp;daysSinceEpoch)</span></div>
<div class="block">SQL <code>DATETIME(DATE)</code> function; returns a Calcite TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="datetime(int,int)">
<h3>datetime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">datetime</span><wbr><span class="parameters">(int&nbsp;daysSinceEpoch,
 int&nbsp;millisSinceMidnight)</span></div>
<div class="block">SQL <code>DATETIME(DATE, TIME)</code> function; returns a Calcite TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="datetime(long)">
<h3>datetime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">datetime</span><wbr><span class="parameters">(long&nbsp;millisSinceEpoch)</span></div>
<div class="block">SQL <code>DATETIME(TIMESTAMP WITH LOCAL TIME ZONE)</code> function;
 returns a Calcite TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="datetime(long,java.lang.String)">
<h3>datetime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">datetime</span><wbr><span class="parameters">(long&nbsp;millisSinceEpoch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>DATETIME(TIMESTAMP, timeZone)</code> function;
 returns a Calcite TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(java.lang.String)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;string&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(java.lang.String,java.lang.String)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;string&gt;, &lt;timeZone&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(int)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(int&nbsp;days)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;date&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(int,java.lang.String)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(int&nbsp;days,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;date&gt;, &lt;timeZone&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(long)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(long&nbsp;millisSinceEpoch)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;timestamp&gt;)</code> function; returns a TIMESTAMP WITH
 LOCAL TIME ZONE.</div>
</section>
</li>
<li>
<section class="detail" id="timestamp(long,java.lang.String)">
<h3>timestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timestamp</span><wbr><span class="parameters">(long&nbsp;millisSinceEpoch,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>TIMESTAMP(&lt;timestamp&gt;, &lt;timeZone&gt;)</code> function; returns a
 TIMESTAMP WITH LOCAL TIME ZONE.</div>
</section>
</li>
<li>
<section class="detail" id="time(int,int,int)">
<h3>time</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">time</span><wbr><span class="parameters">(int&nbsp;hour,
 int&nbsp;minute,
 int&nbsp;second)</span></div>
<div class="block">SQL <code>TIME(&lt;hour&gt;, &lt;minute&gt;, &lt;second&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="time(long)">
<h3>time</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">time</span><wbr><span class="parameters">(long&nbsp;timestampMillis)</span></div>
<div class="block">SQL <code>TIME(&lt;timestamp&gt;)</code> and <code>TIME(&lt;timestampLtz&gt;)</code>
 functions.</div>
</section>
</li>
<li>
<section class="detail" id="time(long,java.lang.String)">
<h3>time</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">time</span><wbr><span class="parameters">(long&nbsp;timestampMillis,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeZone)</span></div>
<div class="block">SQL <code>TIME(&lt;timestampLtz&gt;, &lt;timeZone&gt;)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="toTimestampWithLocalTimeZone(java.lang.String)">
<h3>toTimestampWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">toTimestampWithLocalTimeZone</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v)</span></div>
</section>
</li>
<li>
<section class="detail" id="toTimestampWithLocalTimeZone(java.lang.String,java.util.TimeZone)">
<h3>toTimestampWithLocalTimeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">toTimestampWithLocalTimeZone</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;v,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;timeZone)</span></div>
</section>
</li>
<li>
<section class="detail" id="truncate(java.lang.String,int)">
<h3>truncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">truncate</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;maxLength)</span></div>
<div class="block">Helper for CAST(... AS VARCHAR(maxLength)).</div>
</section>
</li>
<li>
<section class="detail" id="truncateOrPad(java.lang.String,int)">
<h3>truncateOrPad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">truncateOrPad</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;maxLength)</span></div>
<div class="block">Helper for CAST(... AS CHAR(maxLength)).</div>
</section>
</li>
<li>
<section class="detail" id="truncate(org.apache.calcite.avatica.util.ByteString,int)">
<h3>truncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">truncate</span><wbr><span class="parameters">(@PolyNull org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;maxLength)</span></div>
<div class="block">Helper for CAST(... AS VARBINARY(maxLength)).</div>
</section>
</li>
<li>
<section class="detail" id="truncateOrPad(org.apache.calcite.avatica.util.ByteString,int)">
<h3>truncateOrPad</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">truncateOrPad</span><wbr><span class="parameters">(@PolyNull org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;maxLength)</span></div>
<div class="block">Helper for CAST(... AS BINARY(maxLength)).</div>
</section>
</li>
<li>
<section class="detail" id="position(java.lang.String,java.lang.String)">
<h3>position</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">position</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">SQL <code>POSITION(seek IN string)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="position(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString)">
<h3>position</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">position</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;seek,
 org.apache.calcite.avatica.util.ByteString&nbsp;s)</span></div>
<div class="block">SQL <code>POSITION(seek IN string)</code> function for byte strings.</div>
</section>
</li>
<li>
<section class="detail" id="position(java.lang.String,java.lang.String,int)">
<h3>position</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">position</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;from)</span></div>
<div class="block">SQL <code>POSITION(seek IN string FROM integer)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="position(org.apache.calcite.avatica.util.ByteString,org.apache.calcite.avatica.util.ByteString,int)">
<h3>position</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">position</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;seek,
 org.apache.calcite.avatica.util.ByteString&nbsp;s,
 int&nbsp;from)</span></div>
<div class="block">SQL <code>POSITION(seek IN string FROM integer)</code> function for byte
 strings.</div>
</section>
</li>
<li>
<section class="detail" id="round(long,long)">
<h3>round</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">round</span><wbr><span class="parameters">(long&nbsp;v,
 long&nbsp;x)</span></div>
<div class="block">Helper for rounding. Truncate(12345, 1000) returns 12000.</div>
</section>
</li>
<li>
<section class="detail" id="truncate(long,long)">
<h3>truncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">truncate</span><wbr><span class="parameters">(long&nbsp;v,
 long&nbsp;x)</span></div>
<div class="block">Helper for rounding. Truncate(12345, 1000) returns 12000.</div>
</section>
</li>
<li>
<section class="detail" id="round(int,int)">
<h3>round</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">round</span><wbr><span class="parameters">(int&nbsp;v,
 int&nbsp;x)</span></div>
<div class="block">Helper for rounding. Truncate(12345, 1000) returns 12000.</div>
</section>
</li>
<li>
<section class="detail" id="truncate(int,int)">
<h3>truncate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">truncate</span><wbr><span class="parameters">(int&nbsp;v,
 int&nbsp;x)</span></div>
<div class="block">Helper for rounding. Truncate(12345, 1000) returns 12000.</div>
</section>
</li>
<li>
<section class="detail" id="dayNameWithTimestamp(long,java.util.Locale)">
<h3>dayNameWithTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">dayNameWithTimestamp</span><wbr><span class="parameters">(long&nbsp;timestamp,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</span></div>
<div class="block">SQL <code>DAYNAME</code> function, applied to a TIMESTAMP argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timestamp</code> - Milliseconds from epoch</dd>
<dd><code>locale</code> - Locale</dd>
<dt>Returns:</dt>
<dd>Name of the weekday in the given locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dayNameWithDate(int,java.util.Locale)">
<h3>dayNameWithDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">dayNameWithDate</span><wbr><span class="parameters">(int&nbsp;date,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</span></div>
<div class="block">SQL <code>DAYNAME</code> function, applied to a DATE argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>date</code> - Days since epoch</dd>
<dd><code>locale</code> - Locale</dd>
<dt>Returns:</dt>
<dd>Name of the weekday in the given locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="monthNameWithTimestamp(long,java.util.Locale)">
<h3>monthNameWithTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">monthNameWithTimestamp</span><wbr><span class="parameters">(long&nbsp;timestamp,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</span></div>
<div class="block">SQL <code>MONTHNAME</code> function, applied to a TIMESTAMP argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timestamp</code> - Milliseconds from epoch</dd>
<dd><code>locale</code> - Locale</dd>
<dt>Returns:</dt>
<dd>Name of the month in the given locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="monthNameWithDate(int,java.util.Locale)">
<h3>monthNameWithDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">monthNameWithDate</span><wbr><span class="parameters">(int&nbsp;date,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a>&nbsp;locale)</span></div>
<div class="block">SQL <code>MONTHNAME</code> function, applied to a DATE argument.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>date</code> - Days from epoch</dd>
<dd><code>locale</code> - Locale</dd>
<dt>Returns:</dt>
<dd>Name of the month in the given locale</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="timestampToDate(long)">
<h3>timestampToDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timestampToDate</span><wbr><span class="parameters">(long&nbsp;timestamp)</span></div>
<div class="block">Converts a timestamp (milliseconds since epoch)
 to a date (days since epoch).</div>
</section>
</li>
<li>
<section class="detail" id="timestampToTime(long)">
<h3>timestampToTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">timestampToTime</span><wbr><span class="parameters">(long&nbsp;timestamp)</span></div>
<div class="block">Converts a timestamp (milliseconds since epoch)
 to a time (milliseconds since midnight).</div>
</section>
</li>
<li>
<section class="detail" id="currentTimestamp(org.apache.calcite.DataContext)">
<h3>currentTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">currentTimestamp</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>CURRENT_TIMESTAMP</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="currentTime(org.apache.calcite.DataContext)">
<h3>currentTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">currentTime</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>CURRENT_TIME</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="currentDate(org.apache.calcite.DataContext)">
<h3>currentDate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">currentDate</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>CURRENT_DATE</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="localTimestamp(org.apache.calcite.DataContext)">
<h3>localTimestamp</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">localTimestamp</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>LOCAL_TIMESTAMP</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="localTime(org.apache.calcite.DataContext)">
<h3>localTime</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">localTime</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>LOCAL_TIME</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="timeZone(org.apache.calcite.DataContext)">
<h3>timeZone</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a></span>&nbsp;<span class="element-name">timeZone</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
</section>
</li>
<li>
<section class="detail" id="user(org.apache.calcite.DataContext)">
<h3>user</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">user</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="systemUser(org.apache.calcite.DataContext)">
<h3>systemUser</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">systemUser</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
<div class="block">SQL <code>SYSTEM_USER</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="locale(org.apache.calcite.DataContext)">
<h3>locale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></span>&nbsp;<span class="element-name">locale</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root)</span></div>
</section>
</li>
<li>
<section class="detail" id="customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)">
<h3>customDateAdd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">customDateAdd</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;interval,
 int&nbsp;date)</span></div>
<div class="block">SQL <code>DATEADD</code> function applied to a custom time frame.

 <p>Custom time frames are created as part of a <a href="../rel/type/TimeFrameSet.html" title="class in org.apache.calcite.rel.type"><code>TimeFrameSet</code></a>.
 This method retrieves the session's time frame set from the
 <a href="../DataContext.Variable.html#TIME_FRAME_SET"><code>DataContext.Variable.TIME_FRAME_SET</code></a> variable, then looks up the
 time frame by name.</div>
</section>
</li>
<li>
<section class="detail" id="customTimestampAdd(org.apache.calcite.DataContext,java.lang.String,long,long)">
<h3>customTimestampAdd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">customTimestampAdd</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;interval,
 long&nbsp;timestamp)</span></div>
<div class="block">SQL <code>TIMESTAMPADD</code> function applied to a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customDateDiff(org.apache.calcite.DataContext,java.lang.String,int,int)">
<h3>customDateDiff</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">customDateDiff</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date,
 int&nbsp;date2)</span></div>
<div class="block">SQL <code>DATEDIFF</code> function applied to a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customTimestampDiff(org.apache.calcite.DataContext,java.lang.String,long,long)">
<h3>customTimestampDiff</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">customTimestampDiff</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp,
 long&nbsp;timestamp2)</span></div>
<div class="block">SQL <code>TIMESTAMPDIFF</code> function applied to a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customDateFloor(org.apache.calcite.DataContext,java.lang.String,int)">
<h3>customDateFloor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">customDateFloor</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date)</span></div>
<div class="block">SQL <code>FLOOR</code> function applied to a <code>DATE</code> value
 and a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customDateCeil(org.apache.calcite.DataContext,java.lang.String,int)">
<h3>customDateCeil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">customDateCeil</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 int&nbsp;date)</span></div>
<div class="block">SQL <code>CEIL</code> function applied to a <code>DATE</code> value
 and a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customTimestampFloor(org.apache.calcite.DataContext,java.lang.String,long)">
<h3>customTimestampFloor</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">customTimestampFloor</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp)</span></div>
<div class="block">SQL <code>FLOOR</code> function applied to a <code>TIMESTAMP</code> value
 and a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="customTimestampCeil(org.apache.calcite.DataContext,java.lang.String,long)">
<h3>customTimestampCeil</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">customTimestampCeil</span><wbr><span class="parameters">(<a href="../DataContext.html" title="interface in org.apache.calcite">DataContext</a>&nbsp;root,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;timeFrameName,
 long&nbsp;timestamp)</span></div>
<div class="block">SQL <code>CEIL</code> function applied to a <code>TIMESTAMP</code> value
 and a custom time frame.

 <p>Custom time frames are created and accessed as described in
 <a href="#customDateAdd(org.apache.calcite.DataContext,java.lang.String,int,int)"><code>customDateAdd(org.apache.calcite.DataContext, java.lang.String, int, int)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="translate3(java.lang.String,java.lang.String,java.lang.String)">
<h3>translate3</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">translate3</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;search,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</span></div>
<div class="block">SQL <code>TRANSLATE(string, search_chars, replacement_chars)</code>
 function.</div>
</section>
</li>
<li>
<section class="detail" id="replace(java.lang.String,java.lang.String,java.lang.String)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;search,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replacement)</span></div>
<div class="block">SQL <code>REPLACE(string, search, replacement)</code> function.</div>
</section>
</li>
<li>
<section class="detail" id="arrayItem(java.util.List,int)">
<h3>arrayItem</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">arrayItem</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list,
 int&nbsp;item)</span></div>
<div class="block">Helper for "array element reference". Caller has already ensured that
 array and index are not null. Index is 1-based, per SQL.</div>
</section>
</li>
<li>
<section class="detail" id="mapItem(java.util.Map,java.lang.Object)">
<h3>mapItem</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">mapItem</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&nbsp;map,
 <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>&nbsp;item)</span></div>
<div class="block">Helper for "map element reference". Caller has already ensured that
 array and index are not null. Index is 1-based, per SQL.</div>
</section>
</li>
<li>
<section class="detail" id="item(java.lang.Object,java.lang.Object)">
<h3>item</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">item</span><wbr><span class="parameters">(<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>&nbsp;object,
 <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>&nbsp;index)</span></div>
<div class="block">Implements the <code>[ ... ]</code> operator on an object whose type is not
 known until runtime.</div>
</section>
</li>
<li>
<section class="detail" id="arrayItemOptional(java.util.List,int)">
<h3>arrayItemOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">arrayItemOptional</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list,
 int&nbsp;item)</span></div>
<div class="block">As <a href="#arrayItem(java.util.List,int)"><code>arrayItem(java.util.List, int)</code></a> method, but allows array to be nullable.</div>
</section>
</li>
<li>
<section class="detail" id="mapItemOptional(java.util.Map,java.lang.Object)">
<h3>mapItemOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">mapItemOptional</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&nbsp;map,
 <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>&nbsp;item)</span></div>
<div class="block">As <a href="#mapItem(java.util.Map,java.lang.Object)"><code>mapItem(java.util.Map, java.lang.Object)</code></a> method, but allows map to be nullable.</div>
</section>
</li>
<li>
<section class="detail" id="itemOptional(java.lang.Object,java.lang.Object)">
<h3>itemOptional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">itemOptional</span><wbr><span class="parameters">(@Nullable <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>&nbsp;object,
 <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>&nbsp;index)</span></div>
<div class="block">As <a href="#item(java.lang.Object,java.lang.Object)"><code>item(java.lang.Object, java.lang.Object)</code></a> method, but allows object to be nullable.</div>
</section>
</li>
<li>
<section class="detail" id="isTrue(java.lang.Boolean)">
<h3>isTrue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isTrue</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</span></div>
<div class="block">NULL &rarr; FALSE, FALSE &rarr; FALSE, TRUE &rarr; TRUE.</div>
</section>
</li>
<li>
<section class="detail" id="isFalse(java.lang.Boolean)">
<h3>isFalse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isFalse</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</span></div>
<div class="block">NULL &rarr; FALSE, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</section>
</li>
<li>
<section class="detail" id="isNotTrue(java.lang.Boolean)">
<h3>isNotTrue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isNotTrue</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</span></div>
<div class="block">NULL &rarr; TRUE, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</section>
</li>
<li>
<section class="detail" id="isNotFalse(java.lang.Boolean)">
<h3>isNotFalse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isNotFalse</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</span></div>
<div class="block">NULL &rarr; TRUE, FALSE &rarr; FALSE, TRUE &rarr; TRUE.</div>
</section>
</li>
<li>
<section class="detail" id="not(java.lang.Boolean)">
<h3>not</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a></span>&nbsp;<span class="element-name">not</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;b)</span></div>
<div class="block">NULL &rarr; NULL, FALSE &rarr; TRUE, TRUE &rarr; FALSE.</div>
</section>
</li>
<li>
<section class="detail" id="arrayToList(java.sql.Array)">
<h3>arrayToList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></span>&nbsp;<span class="element-name">arrayToList</span><wbr><span class="parameters">(@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Array.html" title="class or interface in java.sql" class="external-link">Array</a>&nbsp;a)</span></div>
<div class="block">Converts a JDBC array to a list.</div>
</section>
</li>
<li>
<section class="detail" id="sequenceCurrentValue(java.lang.String)">
<h3>sequenceCurrentValue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sequenceCurrentValue</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">Support the <code>CURRENT VALUE OF sequence</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="sequenceNextValue(java.lang.String)">
<h3>sequenceNextValue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sequenceNextValue</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</span></div>
<div class="block">Support the <code>NEXT VALUE OF sequence</code> operator.</div>
</section>
</li>
<li>
<section class="detail" id="slice(java.util.List)">
<h3>slice</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></span>&nbsp;<span class="element-name">slice</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</span></div>
<div class="block">Support the SLICE function.</div>
</section>
</li>
<li>
<section class="detail" id="element(java.util.List)">
<h3>element</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">element</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</span></div>
<div class="block">Support the ELEMENT function.</div>
</section>
</li>
<li>
<section class="detail" id="memberOf(java.lang.Object,java.util.Collection)">
<h3>memberOf</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">memberOf</span><wbr><span class="parameters">(@Nullable <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>&nbsp;object,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection)</span></div>
<div class="block">Support the MEMBER OF function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetIntersectDistinct(java.util.Collection,java.util.Collection)">
<h3>multisetIntersectDistinct</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</span>&nbsp;<span class="element-name">multisetIntersectDistinct</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</span></div>
<div class="block">Support the MULTISET INTERSECT DISTINCT function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetIntersectAll(java.util.Collection,java.util.Collection)">
<h3>multisetIntersectAll</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</span>&nbsp;<span class="element-name">multisetIntersectAll</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</span></div>
<div class="block">Support the MULTISET INTERSECT ALL function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetExceptAll(java.util.Collection,java.util.Collection)">
<h3>multisetExceptAll</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</span>&nbsp;<span class="element-name">multisetExceptAll</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</span></div>
<div class="block">Support the MULTISET EXCEPT ALL function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetExceptDistinct(java.util.Collection,java.util.Collection)">
<h3>multisetExceptDistinct</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</span>&nbsp;<span class="element-name">multisetExceptDistinct</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c2)</span></div>
<div class="block">Support the MULTISET EXCEPT DISTINCT function.</div>
</section>
</li>
<li>
<section class="detail" id="isASet(java.util.Collection)">
<h3>isASet</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isASet</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection)</span></div>
<div class="block">Support the IS A SET function.</div>
</section>
</li>
<li>
<section class="detail" id="submultisetOf(java.util.Collection,java.util.Collection)">
<h3>submultisetOf</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">submultisetOf</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;possibleSubMultiset,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;multiset)</span></div>
<div class="block">Support the SUBMULTISET OF function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetUnionDistinct(java.util.Collection,java.util.Collection)">
<h3>multisetUnionDistinct</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a></span>&nbsp;<span class="element-name">multisetUnionDistinct</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection2)</span></div>
<div class="block">Support the MULTISET UNION function.</div>
</section>
</li>
<li>
<section class="detail" id="multisetUnionAll(java.util.Collection,java.util.Collection)">
<h3>multisetUnionAll</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a></span>&nbsp;<span class="element-name">multisetUnionAll</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&nbsp;collection2)</span></div>
<div class="block">Support the MULTISET UNION ALL function.</div>
</section>
</li>
<li>
<section class="detail" id="reverse(java.util.List)">
<h3>reverse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a></span>&nbsp;<span class="element-name">reverse</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&nbsp;list)</span></div>
<div class="block">Support the ARRAY_REVERSE function.</div>
</section>
</li>
<li>
<section class="detail" id="flatList()">
<h3>flatList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../linq4j/function/Function1.html" title="interface in org.apache.calcite.linq4j.function">Function1</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<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>&gt;,<wbr><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<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>&gt;&gt;</span>&nbsp;<span class="element-name">flatList</span>()</div>
<div class="block">Function that, given a certain List containing single-item structs (i.e. arrays / lists with
 a single item), builds an Enumerable that returns those single items inside the structs.</div>
</section>
</li>
<li>
<section class="detail" id="flatProduct(int[],boolean,org.apache.calcite.runtime.SqlFunctions.FlatProductInputType[])">
<h3>flatProduct</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../linq4j/function/Function1.html" title="interface in org.apache.calcite.linq4j.function">Function1</a>&lt;<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>,<wbr><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime">FlatLists.ComparableList</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&gt;&gt;&gt;</span>&nbsp;<span class="element-name">flatProduct</span><wbr><span class="parameters">(int[]&nbsp;fieldCounts,
 boolean&nbsp;withOrdinality,
 <a href="SqlFunctions.FlatProductInputType.html" title="enum in org.apache.calcite.runtime">SqlFunctions.FlatProductInputType</a>[]&nbsp;inputTypes)</span></div>
</section>
</li>
<li>
<section class="detail" id="array(java.lang.Object...)">
<h3>array</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><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>&nbsp;<span class="element-name">array</span><wbr><span class="parameters">(<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>...&nbsp;args)</span></div>
</section>
</li>
<li>
<section class="detail" id="product(java.util.List,int,boolean)">
<h3>product</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&gt;</span>
<span class="return-type"><a href="../linq4j/Enumerable.html" title="interface in org.apache.calcite.linq4j">Enumerable</a>&lt;<a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime">FlatLists.ComparableList</a>&lt;E&gt;&gt;</span>&nbsp;<span class="element-name">product</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../linq4j/Enumerator.html" title="interface in org.apache.calcite.linq4j">Enumerator</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;&gt;&nbsp;enumerators,
 int&nbsp;fieldCount,
 boolean&nbsp;withOrdinality)</span></div>
<div class="block">Similar to <a href="../linq4j/Linq4j.html#product(java.lang.Iterable)"><code>Linq4j.product(Iterable)</code></a> but each resulting list
 implements <a href="FlatLists.ComparableList.html" title="interface in org.apache.calcite.runtime"><code>FlatLists.ComparableList</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="structAccess(java.lang.Object,int,java.lang.String)">
<h3>structAccess</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <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>&nbsp;<span class="element-name">structAccess</span><wbr><span class="parameters">(@Nullable <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>&nbsp;structObject,
 int&nbsp;index,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;fieldName)</span></div>
<div class="block">Implements the <code>.</code> (field access) operator on an object
 whose type is not known until runtime.

 <p>A struct object can be represented in various ways by the
 runtime and depends on the
 <a href="../adapter/enumerable/JavaRowFormat.html" title="enum in org.apache.calcite.adapter.enumerable"><code>JavaRowFormat</code></a>.</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>
