<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>OperandTypes (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.sql.type, class: OperandTypes">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql.type</a></div>
<h1 title="Class OperandTypes" class="title">Class OperandTypes</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql.type.OperandTypes</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">OperandTypes</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">Strategies for checking operand types.

 <p>This class defines singleton instances of strategy objects for operand
 type-checking. <a href="ReturnTypes.html" title="class in org.apache.calcite.sql.type"><code>ReturnTypes</code></a>
 and <a href="InferTypes.html" title="class in org.apache.calcite.sql.type"><code>InferTypes</code></a> provide similar strategies
 for operand type inference and operator return type inference.

 <p>Note to developers: avoid anonymous inner classes here except for unique,
 non-generalizable strategies; anything else belongs in a reusable top-level
 class. If you find yourself copying and pasting an existing strategy's
 anonymous inner class, you're making a mistake.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type"><code>SqlOperandTypeChecker</code></a></li>
<li><a href="ReturnTypes.html" title="class in org.apache.calcite.sql.type"><code>ReturnTypes</code></a></li>
<li><a href="InferTypes.html" title="class in org.apache.calcite.sql.type"><code>InferTypes</code></a></li>
</ul>
</dd>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#ANY" class="member-name-link">ANY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ANY_ANY" class="member-name-link">ANY_ANY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#ANY_COMPARABLE" class="member-name-link">ANY_COMPARABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy used by <code>ARG_MIN(value, comp)</code> and
 similar functions, where the first operand can have any type and the second
 must be comparable.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ANY_IGNORE" class="member-name-link">ANY_IGNORE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#ANY_NUMERIC" class="member-name-link">ANY_NUMERIC</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ANY_NUMERIC_ANY" class="member-name-link">ANY_NUMERIC_ANY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#ANY_STRING_STRING" class="member-name-link">ANY_STRING_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARRAY" class="member-name-link">ARRAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#AT_LEAST_ONE_SAME_VARIADIC" class="member-name-link">AT_LEAST_ONE_SAME_VARIADIC</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where any positive number of operands must all be
 in the same type family.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BINARY" class="member-name-link">BINARY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#BOOLEAN" class="member-name-link">BOOLEAN</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BOOLEAN_BOOLEAN" class="member-name-link">BOOLEAN_BOOLEAN</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#CBSTRING_INTEGER" class="member-name-link">CBSTRING_INTEGER</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where the first operand is a character or
 binary string (CHAR, VARCHAR, BINARY or VARBINARY), and the second operand
 is INTEGER.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CHARACTER" class="member-name-link">CHARACTER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#CHARACTER_CHARACTER" class="member-name-link">CHARACTER_CHARACTER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CHARACTER_CHARACTER_DATETIME" class="member-name-link">CHARACTER_CHARACTER_DATETIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#COLLECTION" class="member-name-link">COLLECTION</a></code></div>
<div class="col-last even-row-color">
<div class="block">Checks that returns whether a value is a multiset or an array.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COLLECTION_OR_MAP" class="member-name-link">COLLECTION_OR_MAP</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#COMPARABLE_ORDERED" class="member-name-link">COMPARABLE_ORDERED</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where operand type must allow ordered
 comparisons.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COMPARABLE_ORDERED_COMPARABLE_ORDERED" class="member-name-link">COMPARABLE_ORDERED_COMPARABLE_ORDERED</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy where operand types must allow ordered
 comparisons.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#COMPARABLE_UNORDERED_COMPARABLE_UNORDERED" class="member-name-link">COMPARABLE_UNORDERED_COMPARABLE_UNORDERED</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where operand types must allow unordered
 comparisons.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURSOR" class="member-name-link">CURSOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATE" class="member-name-link">DATE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE_CHARACTER" class="member-name-link">DATE_CHARACTER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATE_INTERVAL" class="member-name-link">DATE_INTERVAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE_TIME" class="member-name-link">DATE_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATETIME" class="member-name-link">DATETIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATETIME_INTERVAL" class="member-name-link">DATETIME_INTERVAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATETIME_INTERVAL_INTERVAL" class="member-name-link">DATETIME_INTERVAL_INTERVAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATETIME_INTERVAL_INTERVAL_TIME" class="member-name-link">DATETIME_INTERVAL_INTERVAL_TIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#DATETIME_INTERVAL_TIME" class="member-name-link">DATETIME_INTERVAL_TIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DIVISION_OPERATOR" class="member-name-link">DIVISION_OPERATOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-checking strategy for the "/" operator.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#EXACT_NUMERIC" class="member-name-link">EXACT_NUMERIC</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXACT_NUMERIC_EXACT_NUMERIC" class="member-name-link">EXACT_NUMERIC_EXACT_NUMERIC</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#IGNORE_ANY" class="member-name-link">IGNORE_ANY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTEGER" class="member-name-link">INTEGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTERVAL" class="member-name-link">INTERVAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTERVAL_DATETIME" class="member-name-link">INTERVAL_DATETIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTERVAL_INTERVAL" class="member-name-link">INTERVAL_INTERVAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTERVAL_NUMERIC" class="member-name-link">INTERVAL_NUMERIC</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTERVAL_SAME_SAME" class="member-name-link">INTERVAL_SAME_SAME</a></code></div>
<div class="col-last even-row-color">
<div class="block">Parameter type-checking strategy where type must a nullable time interval,
 nullable time interval.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTERVALINTERVAL_INTERVALDATETIME" class="member-name-link">INTERVALINTERVAL_INTERVALDATETIME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#LITERAL" class="member-name-link">LITERAL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy type must be a non-NULL literal.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MEASURE" class="member-name-link">MEASURE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#MINUS_DATE_OPERATOR" class="member-name-link">MINUS_DATE_OPERATOR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MINUS_OPERATOR" class="member-name-link">MINUS_OPERATOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTIPLY_OPERATOR" class="member-name-link">MULTIPLY_OPERATOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-checking strategy for the "*" operator.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET" class="member-name-link">MULTISET</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_MULTISET" class="member-name-link">MULTISET_MULTISET</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NILADIC" class="member-name-link">NILADIC</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy for an operator which takes no operands.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#NULLABLE_LITERAL" class="member-name-link">NULLABLE_LITERAL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where type must be a literal or NULL.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NUMERIC" class="member-name-link">NUMERIC</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#NUMERIC_INTEGER" class="member-name-link">NUMERIC_INTEGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NUMERIC_INTERVAL" class="member-name-link">NUMERIC_INTERVAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#NUMERIC_NUMERIC" class="member-name-link">NUMERIC_NUMERIC</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NUMERIC_OPTIONAL_INTEGER" class="member-name-link">NUMERIC_OPTIONAL_INTEGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#NUMERIC_OR_INTERVAL" class="member-name-link">NUMERIC_OR_INTERVAL</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NUMERIC_OR_STRING" class="member-name-link">NUMERIC_OR_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#ONE_OR_MORE" class="member-name-link">ONE_OR_MORE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy that allows one or more operands.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PERIOD" class="member-name-link">PERIOD</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#PERIOD_OR_DATETIME" class="member-name-link">PERIOD_OR_DATETIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#PLUS_OPERATOR" class="member-name-link">PLUS_OPERATOR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#POSITIVE_INTEGER_LITERAL" class="member-name-link">POSITIVE_INTEGER_LITERAL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy type must be a positive integer non-NULL
 literal.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RECORD_COLLECTION" class="member-name-link">RECORD_COLLECTION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Checker that returns whether a value is a multiset of records or an
 array of records.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#RECORD_TO_SCALAR" class="member-name-link">RECORD_TO_SCALAR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SAME_SAME" class="member-name-link">SAME_SAME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy where two operands must both be in the
 same type family.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#SAME_SAME_INTEGER" class="member-name-link">SAME_SAME_INTEGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SAME_SAME_SAME" class="member-name-link">SAME_SAME_SAME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy where three operands must all be in the
 same type family.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#SAME_VARIADIC" class="member-name-link">SAME_VARIADIC</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where any number of operands must all be
 in the same type family.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SCALAR_OR_RECORD_COLLECTION" class="member-name-link">SCALAR_OR_RECORD_COLLECTION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Checker that returns whether a value is a collection (multiset or array)
 of scalar or record values.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#SCALAR_OR_RECORD_COLLECTION_OR_MAP" class="member-name-link">SCALAR_OR_RECORD_COLLECTION_OR_MAP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#SET_OP" class="member-name-link">SET_OP</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy for a set operator (UNION, INTERSECT,
 EXCEPT).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING" class="member-name-link">STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_INTEGER" class="member-name-link">STRING_INTEGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_INTEGER_INTEGER" class="member-name-link">STRING_INTEGER_INTEGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_INTEGER_OPTIONAL_INTEGER" class="member-name-link">STRING_INTEGER_OPTIONAL_INTEGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_NUMERIC" class="member-name-link">STRING_NUMERIC</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_NUMERIC_NUMERIC" class="member-name-link">STRING_NUMERIC_NUMERIC</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_NUMERIC_OPTIONAL_STRING" class="member-name-link">STRING_NUMERIC_OPTIONAL_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_SAME_SAME" class="member-name-link">STRING_SAME_SAME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy where two operands must both be in the
 same string type family.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_SAME_SAME_INTEGER" class="member-name-link">STRING_SAME_SAME_INTEGER</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where two operands must both be in the
 same string type family and last type is INTEGER.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_SAME_SAME_OR_ARRAY_SAME_SAME" class="member-name-link">STRING_SAME_SAME_OR_ARRAY_SAME_SAME</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_SAME_SAME_SAME" class="member-name-link">STRING_SAME_SAME_SAME</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy where three operands must all be in the
 same string type family.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_STRING" class="member-name-link">STRING_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_STRING_INTEGER" class="member-name-link">STRING_STRING_INTEGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_STRING_INTEGER_INTEGER" class="member-name-link">STRING_STRING_INTEGER_INTEGER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_STRING_OPTIONAL_STRING" class="member-name-link">STRING_STRING_OPTIONAL_STRING</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#STRING_STRING_STRING" class="member-name-link">STRING_STRING_STRING</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIME" class="member-name-link">TIME</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIME_INTERVAL" class="member-name-link">TIME_INTERVAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP" class="member-name-link">TIMESTAMP</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_INTERVAL" class="member-name-link">TIMESTAMP_INTERVAL</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_LTZ" class="member-name-link">TIMESTAMP_LTZ</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-checker that matches "TIMESTAMP WITH LOCAL TIME ZONE" but not other
 members of the "TIMESTAMP" family (e.g.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP_NTZ" class="member-name-link">TIMESTAMP_NTZ</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-checker that matches "TIMESTAMP" but not other members of the
 "TIMESTAMP" family (e.g.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color"><code><a href="#UNIT_INTERVAL_NUMERIC_LITERAL" class="member-name-link">UNIT_INTERVAL_NUMERIC_LITERAL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Operand type-checking strategy type must be a numeric non-NULL
 literal in the range 0 and 1 inclusive.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color"><code><a href="#VARIADIC" class="member-name-link">VARIADIC</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Operand type-checking strategy for an operator with no restrictions on
 number or type of operands.</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 <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#and(org.apache.calcite.sql.type.SqlOperandTypeChecker...)" class="member-name-link">and</a><wbr>(<a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if all of the rules pass.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#and(org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)" class="member-name-link">and</a><wbr>(<a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a single-operand checker that passes if all of the rules
 pass.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dateInterval()" class="member-name-link">dateInterval</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker for DATE intervals (YEAR, WEEK, ISOWEEK,
 WEEK_WEDNESDAY, etc.)</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#family(java.util.List)" class="member-name-link">family</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#family(java.util.List,java.util.function.Predicate)" class="member-name-link">family</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;<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>&gt;&nbsp;optional)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family, and allows specified parameters to be optional.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#family(org.apache.calcite.sql.type.SqlTypeFamily...)" class="member-name-link">family</a><wbr>(<a href="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>...&nbsp;families)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#interval(java.lang.Iterable)" class="member-name-link">interval</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;org.apache.calcite.avatica.util.TimeUnitRange&gt;&nbsp;ranges)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if the operand is an interval appropriate for
 a given date/time type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#nth(int,int,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker)" class="member-name-link">nth</a><wbr>(int&nbsp;ordinal,
 int&nbsp;operandCount,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>&nbsp;rule)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an operand checker that applies a single-operand checker to
 the <code>ordinal</code>th operand.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlOperandMetadata.html" title="interface in org.apache.calcite.sql.type">SqlOperandMetadata</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#operandMetadata(java.util.List,java.util.function.Function,java.util.function.IntFunction,java.util.function.Predicate)" class="member-name-link">operandMetadata</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</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="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;&gt;&nbsp;typesFactory,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/IntFunction.html" title="class or interface in java.util.function" class="external-link">IntFunction</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;operandName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;<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>&gt;&nbsp;optional)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker for user-defined functions (including user-defined
 aggregate functions, table functions, and table macros).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#or(org.apache.calcite.sql.type.SqlOperandTypeChecker...)" class="member-name-link">or</a><wbr>(<a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if any one of the rules passes.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#or(org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)" class="member-name-link">or</a><wbr>(<a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a single-operand checker that passes if any one of the rules
 passes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</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(org.apache.calcite.sql.SqlOperandCountRange,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)" class="member-name-link">repeat</a><wbr>(<a href="../SqlOperandCountRange.html" title="interface in org.apache.calcite.sql">SqlOperandCountRange</a>&nbsp;range,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker that passes if all of the rules pass for each operand,
 using a given operand count strategy.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#same(int,int...)" class="member-name-link">same</a><wbr>(int&nbsp;operandCount,
 int...&nbsp;ordinals)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Operand type-checking strategy where a given list of operands must all
 have the same type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sequence(java.lang.String,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)" class="member-name-link">sequence</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;allowedSignatures,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an operand checker from a sequence of single-operand checkers.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timeInterval()" class="member-name-link">timeInterval</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker for TIME intervals (HOUR, SECOND, etc.)</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#timestampInterval()" class="member-name-link">timestampInterval</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a checker for TIMESTAMP intervals (YEAR, WEEK, ISOWEEK,
 WEEK_WEDNESDAY, HOUR, SECOND, etc.)</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#typeName(org.apache.calcite.sql.type.SqlTypeName)" class="member-name-link">typeName</a><wbr>(<a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type">SqlTypeName</a>&nbsp;typeName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a single-operand checker that passes if the operand's type has a
 particular <a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type"><code>SqlTypeName</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="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#variadic(org.apache.calcite.sql.SqlOperandCountRange)" class="member-name-link">variadic</a><wbr>(<a href="../SqlOperandCountRange.html" title="interface in org.apache.calcite.sql">SqlOperandCountRange</a>&nbsp;range)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</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">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="NILADIC">
<h3>NILADIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NILADIC</span></div>
<div class="block">Operand type-checking strategy for an operator which takes no operands.</div>
</section>
</li>
<li>
<section class="detail" id="VARIADIC">
<h3>VARIADIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">VARIADIC</span></div>
<div class="block">Operand type-checking strategy for an operator with no restrictions on
 number or type of operands.</div>
</section>
</li>
<li>
<section class="detail" id="ONE_OR_MORE">
<h3>ONE_OR_MORE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">ONE_OR_MORE</span></div>
<div class="block">Operand type-checking strategy that allows one or more operands.</div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN">
<h3>BOOLEAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">BOOLEAN</span></div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_BOOLEAN">
<h3>BOOLEAN_BOOLEAN</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">BOOLEAN_BOOLEAN</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC">
<h3>NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="INTEGER">
<h3>INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_OPTIONAL_INTEGER">
<h3>NUMERIC_OPTIONAL_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_OPTIONAL_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_INTEGER">
<h3>NUMERIC_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_NUMERIC">
<h3>NUMERIC_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="EXACT_NUMERIC">
<h3>EXACT_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">EXACT_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="EXACT_NUMERIC_EXACT_NUMERIC">
<h3>EXACT_NUMERIC_EXACT_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">EXACT_NUMERIC_EXACT_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="BINARY">
<h3>BINARY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">BINARY</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING">
<h3>STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_STRING">
<h3>STRING_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_STRING_STRING">
<h3>STRING_STRING_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_STRING_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_STRING_OPTIONAL_STRING">
<h3>STRING_STRING_OPTIONAL_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_STRING_OPTIONAL_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_NUMERIC_OPTIONAL_STRING">
<h3>STRING_NUMERIC_OPTIONAL_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_NUMERIC_OPTIONAL_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="CHARACTER">
<h3>CHARACTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">CHARACTER</span></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME">
<h3>DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATETIME</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE">
<h3>DATE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATE</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME">
<h3>TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP">
<h3>TIMESTAMP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIMESTAMP</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_LTZ">
<h3>TIMESTAMP_LTZ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIMESTAMP_LTZ</span></div>
<div class="block">Type-checker that matches "TIMESTAMP WITH LOCAL TIME ZONE" but not other
 members of the "TIMESTAMP" family (e.g. "TIMESTAMP").</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_NTZ">
<h3>TIMESTAMP_NTZ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIMESTAMP_NTZ</span></div>
<div class="block">Type-checker that matches "TIMESTAMP" but not other members of the
 "TIMESTAMP" family (e.g. "TIMESTAMP WITH LOCAL TIME ZONE").</div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL">
<h3>INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="CHARACTER_CHARACTER">
<h3>CHARACTER_CHARACTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">CHARACTER_CHARACTER</span></div>
</section>
</li>
<li>
<section class="detail" id="CHARACTER_CHARACTER_DATETIME">
<h3>CHARACTER_CHARACTER_DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">CHARACTER_CHARACTER_DATETIME</span></div>
</section>
</li>
<li>
<section class="detail" id="PERIOD">
<h3>PERIOD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">PERIOD</span></div>
</section>
</li>
<li>
<section class="detail" id="PERIOD_OR_DATETIME">
<h3>PERIOD_OR_DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">PERIOD_OR_DATETIME</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_INTERVAL">
<h3>INTERVAL_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVAL_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET">
<h3>MULTISET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">MULTISET</span></div>
</section>
</li>
<li>
<section class="detail" id="ARRAY">
<h3>ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ARRAY</span></div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION">
<h3>COLLECTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">COLLECTION</span></div>
<div class="block">Checks that returns whether a value is a multiset or an array.
 Cf Java, where list and set are collections but a map is not.</div>
</section>
</li>
<li>
<section class="detail" id="COLLECTION_OR_MAP">
<h3>COLLECTION_OR_MAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">COLLECTION_OR_MAP</span></div>
</section>
</li>
<li>
<section class="detail" id="NULLABLE_LITERAL">
<h3>NULLABLE_LITERAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NULLABLE_LITERAL</span></div>
<div class="block">Operand type-checking strategy where type must be a literal or NULL.</div>
</section>
</li>
<li>
<section class="detail" id="LITERAL">
<h3>LITERAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">LITERAL</span></div>
<div class="block">Operand type-checking strategy type must be a non-NULL literal.</div>
</section>
</li>
<li>
<section class="detail" id="POSITIVE_INTEGER_LITERAL">
<h3>POSITIVE_INTEGER_LITERAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">POSITIVE_INTEGER_LITERAL</span></div>
<div class="block">Operand type-checking strategy type must be a positive integer non-NULL
 literal.</div>
</section>
</li>
<li>
<section class="detail" id="UNIT_INTERVAL_NUMERIC_LITERAL">
<h3>UNIT_INTERVAL_NUMERIC_LITERAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">UNIT_INTERVAL_NUMERIC_LITERAL</span></div>
<div class="block">Operand type-checking strategy type must be a numeric non-NULL
 literal in the range 0 and 1 inclusive.</div>
</section>
</li>
<li>
<section class="detail" id="SAME_SAME">
<h3>SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">SAME_SAME</span></div>
<div class="block">Operand type-checking strategy where two operands must both be in the
 same type family.</div>
</section>
</li>
<li>
<section class="detail" id="SAME_SAME_INTEGER">
<h3>SAME_SAME_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">SAME_SAME_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="SAME_SAME_SAME">
<h3>SAME_SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">SAME_SAME_SAME</span></div>
<div class="block">Operand type-checking strategy where three operands must all be in the
 same type family.</div>
</section>
</li>
<li>
<section class="detail" id="SAME_VARIADIC">
<h3>SAME_VARIADIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">SAME_VARIADIC</span></div>
<div class="block">Operand type-checking strategy where any number of operands must all be
 in the same type family.</div>
</section>
</li>
<li>
<section class="detail" id="AT_LEAST_ONE_SAME_VARIADIC">
<h3>AT_LEAST_ONE_SAME_VARIADIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">AT_LEAST_ONE_SAME_VARIADIC</span></div>
<div class="block">Operand type-checking strategy where any positive number of operands must all be
 in the same type family.</div>
</section>
</li>
<li>
<section class="detail" id="COMPARABLE_ORDERED_COMPARABLE_ORDERED">
<h3>COMPARABLE_ORDERED_COMPARABLE_ORDERED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">COMPARABLE_ORDERED_COMPARABLE_ORDERED</span></div>
<div class="block">Operand type-checking strategy where operand types must allow ordered
 comparisons.</div>
</section>
</li>
<li>
<section class="detail" id="COMPARABLE_ORDERED">
<h3>COMPARABLE_ORDERED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">COMPARABLE_ORDERED</span></div>
<div class="block">Operand type-checking strategy where operand type must allow ordered
 comparisons. Used when instance comparisons are made on single operand
 functions</div>
</section>
</li>
<li>
<section class="detail" id="COMPARABLE_UNORDERED_COMPARABLE_UNORDERED">
<h3>COMPARABLE_UNORDERED_COMPARABLE_UNORDERED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">COMPARABLE_UNORDERED_COMPARABLE_UNORDERED</span></div>
<div class="block">Operand type-checking strategy where operand types must allow unordered
 comparisons.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_SAME_SAME">
<h3>STRING_SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_SAME_SAME</span></div>
<div class="block">Operand type-checking strategy where two operands must both be in the
 same string type family.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_SAME_SAME_SAME">
<h3>STRING_SAME_SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_SAME_SAME_SAME</span></div>
<div class="block">Operand type-checking strategy where three operands must all be in the
 same string type family.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_STRING_INTEGER">
<h3>STRING_STRING_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_STRING_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_STRING_INTEGER_INTEGER">
<h3>STRING_STRING_INTEGER_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_STRING_INTEGER_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_INTEGER">
<h3>STRING_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_INTEGER_INTEGER">
<h3>STRING_INTEGER_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_INTEGER_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_INTEGER_OPTIONAL_INTEGER">
<h3>STRING_INTEGER_OPTIONAL_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_INTEGER_OPTIONAL_INTEGER</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_NUMERIC">
<h3>STRING_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_NUMERIC_NUMERIC">
<h3>STRING_NUMERIC_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_NUMERIC_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="CBSTRING_INTEGER">
<h3>CBSTRING_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">CBSTRING_INTEGER</span></div>
<div class="block">Operand type-checking strategy where the first operand is a character or
 binary string (CHAR, VARCHAR, BINARY or VARBINARY), and the second operand
 is INTEGER.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_SAME_SAME_INTEGER">
<h3>STRING_SAME_SAME_INTEGER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_SAME_SAME_INTEGER</span></div>
<div class="block">Operand type-checking strategy where two operands must both be in the
 same string type family and last type is INTEGER.</div>
</section>
</li>
<li>
<section class="detail" id="STRING_SAME_SAME_OR_ARRAY_SAME_SAME">
<h3>STRING_SAME_SAME_OR_ARRAY_SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">STRING_SAME_SAME_OR_ARRAY_SAME_SAME</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY">
<h3>ANY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_ANY">
<h3>ANY_ANY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_ANY</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_IGNORE">
<h3>ANY_IGNORE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_IGNORE</span></div>
</section>
</li>
<li>
<section class="detail" id="IGNORE_ANY">
<h3>IGNORE_ANY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">IGNORE_ANY</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_NUMERIC">
<h3>ANY_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_NUMERIC_ANY">
<h3>ANY_NUMERIC_ANY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_NUMERIC_ANY</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_STRING_STRING">
<h3>ANY_STRING_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_STRING_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="ANY_COMPARABLE">
<h3>ANY_COMPARABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">ANY_COMPARABLE</span></div>
<div class="block">Operand type-checking strategy used by <code>ARG_MIN(value, comp)</code> and
 similar functions, where the first operand can have any type and the second
 must be comparable.</div>
</section>
</li>
<li>
<section class="detail" id="CURSOR">
<h3>CURSOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">CURSOR</span></div>
</section>
</li>
<li>
<section class="detail" id="MEASURE">
<h3>MEASURE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">MEASURE</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_SAME_SAME">
<h3>INTERVAL_SAME_SAME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVAL_SAME_SAME</span></div>
<div class="block">Parameter type-checking strategy where type must a nullable time interval,
 nullable time interval.</div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_INTERVAL">
<h3>NUMERIC_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_NUMERIC">
<h3>INTERVAL_NUMERIC</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVAL_NUMERIC</span></div>
</section>
</li>
<li>
<section class="detail" id="TIME_INTERVAL">
<h3>TIME_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIME_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_INTERVAL">
<h3>TIMESTAMP_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">TIMESTAMP_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_INTERVAL">
<h3>DATE_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATE_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_CHARACTER">
<h3>DATE_CHARACTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATE_CHARACTER</span></div>
</section>
</li>
<li>
<section class="detail" id="DATE_TIME">
<h3>DATE_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATE_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME_INTERVAL">
<h3>DATETIME_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATETIME_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME_INTERVAL_INTERVAL">
<h3>DATETIME_INTERVAL_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATETIME_INTERVAL_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME_INTERVAL_INTERVAL_TIME">
<h3>DATETIME_INTERVAL_INTERVAL_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATETIME_INTERVAL_INTERVAL_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="DATETIME_INTERVAL_TIME">
<h3>DATETIME_INTERVAL_TIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DATETIME_INTERVAL_TIME</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVAL_DATETIME">
<h3>INTERVAL_DATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVAL_DATETIME</span></div>
</section>
</li>
<li>
<section class="detail" id="INTERVALINTERVAL_INTERVALDATETIME">
<h3>INTERVALINTERVAL_INTERVALDATETIME</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">INTERVALINTERVAL_INTERVALDATETIME</span></div>
</section>
</li>
<li>
<section class="detail" id="PLUS_OPERATOR">
<h3>PLUS_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">PLUS_OPERATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTIPLY_OPERATOR">
<h3>MULTIPLY_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">MULTIPLY_OPERATOR</span></div>
<div class="block">Type-checking strategy for the "*" operator.</div>
</section>
</li>
<li>
<section class="detail" id="DIVISION_OPERATOR">
<h3>DIVISION_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">DIVISION_OPERATOR</span></div>
<div class="block">Type-checking strategy for the "/" operator.</div>
</section>
</li>
<li>
<section class="detail" id="MINUS_OPERATOR">
<h3>MINUS_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">MINUS_OPERATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="MINUS_DATE_OPERATOR">
<h3>MINUS_DATE_OPERATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">MINUS_DATE_OPERATOR</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_OR_INTERVAL">
<h3>NUMERIC_OR_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_OR_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="NUMERIC_OR_STRING">
<h3>NUMERIC_OR_STRING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">NUMERIC_OR_STRING</span></div>
</section>
</li>
<li>
<section class="detail" id="RECORD_COLLECTION">
<h3>RECORD_COLLECTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">RECORD_COLLECTION</span></div>
<div class="block">Checker that returns whether a value is a multiset of records or an
 array of records.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#COLLECTION"><code>COLLECTION</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="SCALAR_OR_RECORD_COLLECTION">
<h3>SCALAR_OR_RECORD_COLLECTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">SCALAR_OR_RECORD_COLLECTION</span></div>
<div class="block">Checker that returns whether a value is a collection (multiset or array)
 of scalar or record values.</div>
</section>
</li>
<li>
<section class="detail" id="SCALAR_OR_RECORD_COLLECTION_OR_MAP">
<h3>SCALAR_OR_RECORD_COLLECTION_OR_MAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">SCALAR_OR_RECORD_COLLECTION_OR_MAP</span></div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_MULTISET">
<h3>MULTISET_MULTISET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">MULTISET_MULTISET</span></div>
</section>
</li>
<li>
<section class="detail" id="SET_OP">
<h3>SET_OP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">SET_OP</span></div>
<div class="block">Operand type-checking strategy for a set operator (UNION, INTERSECT,
 EXCEPT).</div>
</section>
</li>
<li>
<section class="detail" id="RECORD_TO_SCALAR">
<h3>RECORD_TO_SCALAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">RECORD_TO_SCALAR</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="family(org.apache.calcite.sql.type.SqlTypeFamily...)">
<h3>family</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">family</span><wbr><span class="parameters">(<a href="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>...&nbsp;families)</span></div>
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family.</div>
</section>
</li>
<li>
<section class="detail" id="family(java.util.List,java.util.function.Predicate)">
<h3>family</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">family</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;<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>&gt;&nbsp;optional)</span></div>
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family, and allows specified parameters to be optional.</div>
</section>
</li>
<li>
<section class="detail" id="family(java.util.List)">
<h3>family</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="FamilyOperandTypeChecker.html" title="class in org.apache.calcite.sql.type">FamilyOperandTypeChecker</a></span>&nbsp;<span class="element-name">family</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families)</span></div>
<div class="block">Creates a checker that passes if each operand is a member of a
 corresponding family.</div>
</section>
</li>
<li>
<section class="detail" id="typeName(org.apache.calcite.sql.type.SqlTypeName)">
<h3>typeName</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">typeName</span><wbr><span class="parameters">(<a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type">SqlTypeName</a>&nbsp;typeName)</span></div>
<div class="block">Creates a single-operand checker that passes if the operand's type has a
 particular <a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type"><code>SqlTypeName</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="interval(java.lang.Iterable)">
<h3>interval</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">interval</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;org.apache.calcite.avatica.util.TimeUnitRange&gt;&nbsp;ranges)</span></div>
<div class="block">Creates a checker that passes if the operand is an interval appropriate for
 a given date/time type. For example, the time frame HOUR is appropriate for
 type TIMESTAMP or DATE but not TIME.</div>
</section>
</li>
<li>
<section class="detail" id="dateInterval()">
<h3>dateInterval</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">dateInterval</span>()</div>
<div class="block">Creates a checker for DATE intervals (YEAR, WEEK, ISOWEEK,
 WEEK_WEDNESDAY, etc.)</div>
</section>
</li>
<li>
<section class="detail" id="timeInterval()">
<h3>timeInterval</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">timeInterval</span>()</div>
<div class="block">Creates a checker for TIME intervals (HOUR, SECOND, etc.)</div>
</section>
</li>
<li>
<section class="detail" id="timestampInterval()">
<h3>timestampInterval</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">timestampInterval</span>()</div>
<div class="block">Creates a checker for TIMESTAMP intervals (YEAR, WEEK, ISOWEEK,
 WEEK_WEDNESDAY, HOUR, SECOND, etc.)</div>
</section>
</li>
<li>
<section class="detail" id="operandMetadata(java.util.List,java.util.function.Function,java.util.function.IntFunction,java.util.function.Predicate)">
<h3>operandMetadata</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandMetadata.html" title="interface in org.apache.calcite.sql.type">SqlOperandMetadata</a></span>&nbsp;<span class="element-name">operandMetadata</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="SqlTypeFamily.html" title="enum in org.apache.calcite.sql.type">SqlTypeFamily</a>&gt;&nbsp;families,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;<a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</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="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;&gt;&nbsp;typesFactory,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/IntFunction.html" title="class or interface in java.util.function" class="external-link">IntFunction</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;operandName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;<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>&gt;&nbsp;optional)</span></div>
<div class="block">Creates a checker for user-defined functions (including user-defined
 aggregate functions, table functions, and table macros).

 <p>Unlike built-in functions, there is a fixed number of parameters,
 and the parameters have names. You can ask for the type of a parameter
 without providing a particular call (and with it actual arguments) but you
 do need to provide a type factory, and therefore the types are only good
 for the duration of the current statement.</div>
</section>
</li>
<li>
<section class="detail" id="or(org.apache.calcite.sql.type.SqlOperandTypeChecker...)">
<h3>or</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">or</span><wbr><span class="parameters">(<a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates a checker that passes if any one of the rules passes.</div>
</section>
</li>
<li>
<section class="detail" id="and(org.apache.calcite.sql.type.SqlOperandTypeChecker...)">
<h3>and</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">and</span><wbr><span class="parameters">(<a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates a checker that passes if all of the rules pass.</div>
</section>
</li>
<li>
<section class="detail" id="or(org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)">
<h3>or</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">or</span><wbr><span class="parameters">(<a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates a single-operand checker that passes if any one of the rules
 passes.</div>
</section>
</li>
<li>
<section class="detail" id="and(org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)">
<h3>and</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">and</span><wbr><span class="parameters">(<a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates a single-operand checker that passes if all of the rules
 pass.</div>
</section>
</li>
<li>
<section class="detail" id="sequence(java.lang.String,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)">
<h3>sequence</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">sequence</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;allowedSignatures,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates an operand checker from a sequence of single-operand checkers.</div>
</section>
</li>
<li>
<section class="detail" id="repeat(org.apache.calcite.sql.SqlOperandCountRange,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker...)">
<h3>repeat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">repeat</span><wbr><span class="parameters">(<a href="../SqlOperandCountRange.html" title="interface in org.apache.calcite.sql">SqlOperandCountRange</a>&nbsp;range,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>...&nbsp;rules)</span></div>
<div class="block">Creates a checker that passes if all of the rules pass for each operand,
 using a given operand count strategy.</div>
</section>
</li>
<li>
<section class="detail" id="nth(int,int,org.apache.calcite.sql.type.SqlSingleOperandTypeChecker)">
<h3>nth</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">nth</span><wbr><span class="parameters">(int&nbsp;ordinal,
 int&nbsp;operandCount,
 <a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a>&nbsp;rule)</span></div>
<div class="block">Creates an operand checker that applies a single-operand checker to
 the <code>ordinal</code>th operand.</div>
</section>
</li>
<li>
<section class="detail" id="variadic(org.apache.calcite.sql.SqlOperandCountRange)">
<h3>variadic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlOperandTypeChecker</a></span>&nbsp;<span class="element-name">variadic</span><wbr><span class="parameters">(<a href="../SqlOperandCountRange.html" title="interface in org.apache.calcite.sql">SqlOperandCountRange</a>&nbsp;range)</span></div>
</section>
</li>
<li>
<section class="detail" id="same(int,int...)">
<h3>same</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlSingleOperandTypeChecker.html" title="interface in org.apache.calcite.sql.type">SqlSingleOperandTypeChecker</a></span>&nbsp;<span class="element-name">same</span><wbr><span class="parameters">(int&nbsp;operandCount,
 int...&nbsp;ordinals)</span></div>
<div class="block">Operand type-checking strategy where a given list of operands must all
 have the same type.</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>
