<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ReturnTypes (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: ReturnTypes">
<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 ReturnTypes" class="title">Class ReturnTypes</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql.type.ReturnTypes</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">ReturnTypes</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">A collection of return-type inference strategies.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#AGG_SUM" class="member-name-link">AGG_SUM</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy for SUM aggregate function inferred from the
 operand type, and nullable if the call occurs within a "GROUP BY ()"
 query.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#AGG_SUM_EMPTY_IS_ZERO" class="member-name-link">AGG_SUM_EMPTY_IS_ZERO</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy for $SUM0 aggregate function inferred from the
 operand type.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG0" class="member-name-link">ARG0</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG0_FORCE_NULLABLE" class="member-name-link">ARG0_FORCE_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based), with nulls always allowed.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG0_INTERVAL" class="member-name-link">ARG0_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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG0_INTERVAL_NULLABLE" class="member-name-link">ARG0_INTERVAL_NULLABLE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG0_NULLABLE" class="member-name-link">ARG0_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG0_NULLABLE_IF_EMPTY" class="member-name-link">ARG0_NULLABLE_IF_EMPTY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based), and nullable if the call occurs within a
 "GROUP BY ()" query.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG0_NULLABLE_VARYING" class="member-name-link">ARG0_NULLABLE_VARYING</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is VARYING the
 type of the first argument.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG0_OR_EXACT_NO_SCALE" class="member-name-link">ARG0_OR_EXACT_NO_SCALE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_SCALE0"><code>DECIMAL_SCALE0</code></a> with a fallback to <a href="#ARG0"><code>ARG0</code></a> This rule
 is used for floor, ceiling.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG1" class="member-name-link">ARG1</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #1 (0-based).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG1_NULLABLE" class="member-name-link">ARG1_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #1 (0-based).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#ARG2" class="member-name-link">ARG2</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 operand #2 (0-based).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#ARG2_NULLABLE" class="member-name-link">ARG2_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 operand #2 (0-based).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#AVG_AGG_FUNCTION" class="member-name-link">AVG_AGG_FUNCTION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BIGINT" class="member-name-link">BIGINT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a BIGINT.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#BIGINT_FORCE_NULLABLE" class="member-name-link">BIGINT_FORCE_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 BIGINT.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BIGINT_NULLABLE" class="member-name-link">BIGINT_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a BIGINT
 with nulls allowed if any of the operands allow nulls.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</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">
<div class="block">Type-inference strategy whereby the result type of a call is Boolean.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BOOLEAN_FORCE_NULLABLE" class="member-name-link">BOOLEAN_FORCE_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 Boolean.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#BOOLEAN_NOT_NULL" class="member-name-link">BOOLEAN_NOT_NULL</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is BOOLEAN
 NOT NULL.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#BOOLEAN_NULLABLE" class="member-name-link">BOOLEAN_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is Boolean,
 with nulls allowed if any of the operands allow nulls.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#BOOLEAN_NULLABLE_OPTIMIZED" class="member-name-link">BOOLEAN_NULLABLE_OPTIMIZED</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy with similar effect to <a href="#BOOLEAN_NULLABLE"><code>BOOLEAN_NULLABLE</code></a>,
 which is more efficient, but can only be used if all arguments are
 BOOLEAN.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CHAR" class="member-name-link">CHAR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a Char.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#CHAR_FORCE_NULLABLE" class="member-name-link">CHAR_FORCE_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 CHAR(1).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#COLUMN_LIST" class="member-name-link">COLUMN_LIST</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy that always returns "COLUMN_LIST".</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#COVAR_REGR_FUNCTION" class="member-name-link">COVAR_REGR_FUNCTION</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CURSOR" class="member-name-link">CURSOR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy that always returns "CURSOR".</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</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">
<div class="block">Type-inference strategy whereby the result type of a call is DATE.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DATE_NULLABLE" class="member-name-link">DATE_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 DATE.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DECIMAL_MOD" class="member-name-link">DECIMAL_MOD</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DECIMAL_MOD_NULLABLE" class="member-name-link">DECIMAL_MOD_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 modulus of two exact numeric operands where at least one of the operands is a
 decimal.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DECIMAL_PRODUCT" class="member-name-link">DECIMAL_PRODUCT</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 product of two exact numeric operands where at least one of the operands
 is a decimal.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DECIMAL_PRODUCT_NULLABLE" class="member-name-link">DECIMAL_PRODUCT_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Same as <a href="#DECIMAL_PRODUCT"><code>DECIMAL_PRODUCT</code></a> but returns with nullability if any of
 the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DECIMAL_QUOTIENT" class="member-name-link">DECIMAL_QUOTIENT</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 quotient of two exact numeric operands where at least one of the operands
 is a decimal.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DECIMAL_QUOTIENT_NULLABLE" class="member-name-link">DECIMAL_QUOTIENT_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Same as <a href="#DECIMAL_QUOTIENT"><code>DECIMAL_QUOTIENT</code></a> but returns with nullability if any of
 the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DECIMAL_SCALE0" class="member-name-link">DECIMAL_SCALE0</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy for a call where the first argument is a decimal.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DECIMAL_SUM" class="member-name-link">DECIMAL_SUM</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 sum of two exact numeric operands where at least one of the operands is a
 decimal.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DECIMAL_SUM_NULLABLE" class="member-name-link">DECIMAL_SUM_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Same as <a href="#DECIMAL_SUM"><code>DECIMAL_SUM</code></a> but returns with nullability if any
 of the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DOUBLE" class="member-name-link">DOUBLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is Double.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DOUBLE_NULLABLE" class="member-name-link">DOUBLE_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is Double with
 nulls allowed if any of the operands allow nulls.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DYADIC_STRING_SUM_PRECISION" class="member-name-link">DYADIC_STRING_SUM_PRECISION</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy for concatenating two string arguments.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#DYADIC_STRING_SUM_PRECISION_NULLABLE" class="member-name-link">DYADIC_STRING_SUM_PRECISION_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Same as <a href="#DYADIC_STRING_SUM_PRECISION"><code>DYADIC_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DYADIC_STRING_SUM_PRECISION_NULLABLE_VARYING" class="member-name-link">DYADIC_STRING_SUM_PRECISION_NULLABLE_VARYING</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Same as <a href="#DYADIC_STRING_SUM_PRECISION"><code>DYADIC_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>,
 <a href="SqlTypeTransforms.html#TO_VARYING"><code>SqlTypeTransforms.TO_VARYING</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#FRACTIONAL_RANK" class="member-name-link">FRACTIONAL_RANK</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy for the <code>CUME_DIST</code> and <code>PERCENT_RANK</code>
 aggregate functions.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#HISTOGRAM" class="member-name-link">HISTOGRAM</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy for Histogram agg support.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTEGER" class="member-name-link">INTEGER</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is an Integer.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INTEGER_NULLABLE" class="member-name-link">INTEGER_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is an Integer
 with nulls allowed if any of the operands allow nulls.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#INTEGER_QUOTIENT_NULLABLE" class="member-name-link">INTEGER_QUOTIENT_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a> and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#LEAST_RESTRICTIVE" class="member-name-link">LEAST_RESTRICTIVE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is using its
 operands biggest type, using the SQL:1999 rules described in "Data types
 of results of aggregations".</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET" class="member-name-link">MULTISET</a></code></div>
<div class="col-last even-row-color">
<div class="block">Returns the same type as the multiset carries.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_ELEMENT_NULLABLE" class="member-name-link">MULTISET_ELEMENT_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the element type of a MULTISET.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_NULLABLE" class="member-name-link">MULTISET_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Same as <a href="#MULTISET"><code>MULTISET</code></a> but returns with nullability if any of the
 operands is nullable.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_PROJECT_ONLY" class="member-name-link">MULTISET_PROJECT_ONLY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the type of the only column of a multiset.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTISET_PROJECT0" class="member-name-link">MULTISET_PROJECT0</a></code></div>
<div class="col-last even-row-color">
<div class="block">Returns a multiset of column #0 of a multiset.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTISET_RECORD" class="member-name-link">MULTISET_RECORD</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns a multiset of the first column of a multiset.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#MULTIVALENT_STRING_SUM_PRECISION" class="member-name-link">MULTIVALENT_STRING_SUM_PRECISION</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy for String concatenation.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MULTIVALENT_STRING_SUM_PRECISION_NULLABLE" class="member-name-link">MULTIVALENT_STRING_SUM_PRECISION_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Same as <a href="#MULTIVALENT_STRING_SUM_PRECISION"><code>MULTIVALENT_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#NULLABLE_MOD" class="member-name-link">NULLABLE_MOD</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_MOD_NULLABLE"><code>DECIMAL_MOD_NULLABLE</code></a> with a fallback to <a href="#ARG1_NULLABLE"><code>ARG1_NULLABLE</code></a>
 These rules are used for modulus.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#NULLABLE_SUM" class="member-name-link">NULLABLE_SUM</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_SUM_NULLABLE"><code>DECIMAL_SUM_NULLABLE</code></a> with a fallback to <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>
 These rules are used for addition and subtraction.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#PRODUCT_NULLABLE" class="member-name-link">PRODUCT_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_PRODUCT_NULLABLE"><code>DECIMAL_PRODUCT_NULLABLE</code></a> with a fallback to
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a>
 and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#QUOTIENT_NULLABLE" class="member-name-link">QUOTIENT_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_QUOTIENT_NULLABLE"><code>DECIMAL_QUOTIENT_NULLABLE</code></a> with a fallback to
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a> and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#RANK" class="member-name-link">RANK</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy for the <code>NTILE</code>, <code>RANK</code>,
 <code>DENSE_RANK</code>, and <code>ROW_NUMBER</code> aggregate functions.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#RECORD_TO_SCALAR" class="member-name-link">RECORD_TO_SCALAR</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the field type of a structured type which has only one field.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#SCOPE" class="member-name-link">SCOPE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy where the expression is assumed to be registered
 as a <a href="../validate/SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidatorNamespace</code></a>, and
 therefore the result type of the call is the type of that namespace.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIME" class="member-name-link">TIME</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is TIME(0).</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIME_NULLABLE" class="member-name-link">TIME_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 TIME(0).</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TIMESTAMP" class="member-name-link">TIMESTAMP</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is TIMESTAMP.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#TIMESTAMP_NULLABLE" class="member-name-link">TIMESTAMP_NULLABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 TIMESTAMP.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TO_ARRAY" class="member-name-link">TO_ARRAY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns an ARRAY type.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#TO_MAP" class="member-name-link">TO_MAP</a></code></div>
<div class="col-last even-row-color">
<div class="block">Returns a MAP type.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#TO_MULTISET" class="member-name-link">TO_MULTISET</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Returns a MULTISET type.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#VARCHAR_2000" class="member-name-link">VARCHAR_2000</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy that always returns "VARCHAR(2000)".</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#VARCHAR_2000_NULLABLE" class="member-name-link">VARCHAR_2000_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy that always returns "VARCHAR(2000)" with nulls
 allowed if any of the operands allow nulls.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color"><code><a href="#VARCHAR_4" class="member-name-link">VARCHAR_4</a></code></div>
<div class="col-last even-row-color">
<div class="block">Type-inference strategy that always returns "VARCHAR(4)".</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second odd-row-color"><code><a href="#VARCHAR_4_NULLABLE" class="member-name-link">VARCHAR_4_NULLABLE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Type-inference strategy that always returns "VARCHAR(4)" with nulls
 allowed if any of the operands allow nulls.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andThen(java.util.function.UnaryOperator,org.apache.calcite.sql.type.SqlReturnTypeInference)" class="member-name-link">andThen</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a>&gt;&nbsp;bindingTransform,
 <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a>&nbsp;typeInference)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a return-type inference that first transforms a binding and
 then applies an inference.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlTypeTransformCascade.html" title="class in org.apache.calcite.sql.type">SqlTypeTransformCascade</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cascade(org.apache.calcite.sql.type.SqlReturnTypeInference,org.apache.calcite.sql.type.SqlTypeTransform...)" class="member-name-link">cascade</a><wbr>(<a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a>&nbsp;rule,
 <a href="SqlTypeTransform.html" title="interface in org.apache.calcite.sql.type">SqlTypeTransform</a>...&nbsp;transforms)</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 return-type inference that applies a rule then a sequence of
 transforms.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlReturnTypeInferenceChain.html" title="class in org.apache.calcite.sql.type">SqlReturnTypeInferenceChain</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#chain(org.apache.calcite.sql.type.SqlReturnTypeInference...)" class="member-name-link">chain</a><wbr>(<a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</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 return-type inference that applies a rule then a sequence of
 rules, returning the first non-null result.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#explicit(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">explicit</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</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 inference rule which returns a copy of a given data type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#explicit(org.apache.calcite.rel.type.RelProtoDataType)" class="member-name-link">explicit</a><wbr>(<a href="../../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</a>&nbsp;protoType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#explicit(org.apache.calcite.sql.type.SqlTypeName)" class="member-name-link">explicit</a><wbr>(<a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type">SqlTypeName</a>&nbsp;typeName)</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 inference rule which returns a type with no precision or scale,
 such as <code>DATE</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#explicit(org.apache.calcite.sql.type.SqlTypeName,int)" class="member-name-link">explicit</a><wbr>(<a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type">SqlTypeName</a>&nbsp;typeName,
 int&nbsp;precision)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an inference rule which returns a type with precision but no scale,
 such as <code>VARCHAR(100)</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#stripOrderBy(org.apache.calcite.sql.SqlCall)" class="member-name-link">stripOrderBy</a><wbr>(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#stripOrderBy(org.apache.calcite.sql.SqlOperatorBinding)" class="member-name-link">stripOrderBy</a><wbr>(<a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a>&nbsp;operatorBinding)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a binding of <code>FOO(x, y ORDER BY z)</code>
 or <code>FOO(x, y ORDER BY z SEPARATOR s)</code>
 to a binding of <code>FOO(x, y)</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#stripSeparator(org.apache.calcite.sql.SqlCall)" class="member-name-link">stripSeparator</a><wbr>(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&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/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="ARG0">
<h3>ARG0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based).</div>
</section>
</li>
<li>
<section class="detail" id="ARG0_NULLABLE_VARYING">
<h3>ARG0_NULLABLE_VARYING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_NULLABLE_VARYING</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is VARYING the
 type of the first argument. The length returned is the same as length of
 the first argument. If any of the other operands are nullable the
 returned type will also be nullable. First Arg must be of string type.</div>
</section>
</li>
<li>
<section class="detail" id="ARG0_NULLABLE">
<h3>ARG0_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based). If any of the other operands are nullable the
 returned type will also be nullable.</div>
</section>
</li>
<li>
<section class="detail" id="ARG0_FORCE_NULLABLE">
<h3>ARG0_FORCE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_FORCE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based), with nulls always allowed.</div>
</section>
</li>
<li>
<section class="detail" id="ARG0_INTERVAL">
<h3>ARG0_INTERVAL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_INTERVAL</span></div>
</section>
</li>
<li>
<section class="detail" id="ARG0_INTERVAL_NULLABLE">
<h3>ARG0_INTERVAL_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_INTERVAL_NULLABLE</span></div>
</section>
</li>
<li>
<section class="detail" id="ARG0_NULLABLE_IF_EMPTY">
<h3>ARG0_NULLABLE_IF_EMPTY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_NULLABLE_IF_EMPTY</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #0 (0-based), and nullable if the call occurs within a
 "GROUP BY ()" query. E.g. in "select sum(1) as s from empty", s may be
 null.</div>
</section>
</li>
<li>
<section class="detail" id="ARG1">
<h3>ARG1</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG1</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #1 (0-based).</div>
</section>
</li>
<li>
<section class="detail" id="ARG1_NULLABLE">
<h3>ARG1_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG1_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 the operand #1 (0-based). If any of the other operands are nullable the
 returned type will also be nullable.</div>
</section>
</li>
<li>
<section class="detail" id="ARG2">
<h3>ARG2</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG2</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 operand #2 (0-based).</div>
</section>
</li>
<li>
<section class="detail" id="ARG2_NULLABLE">
<h3>ARG2_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG2_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the type of
 operand #2 (0-based). If any of the other operands are nullable the
 returned type will also be nullable.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BOOLEAN</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is Boolean.</div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_NULLABLE">
<h3>BOOLEAN_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BOOLEAN_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is Boolean,
 with nulls allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_NULLABLE_OPTIMIZED">
<h3>BOOLEAN_NULLABLE_OPTIMIZED</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BOOLEAN_NULLABLE_OPTIMIZED</span></div>
<div class="block">Type-inference strategy with similar effect to <a href="#BOOLEAN_NULLABLE"><code>BOOLEAN_NULLABLE</code></a>,
 which is more efficient, but can only be used if all arguments are
 BOOLEAN.</div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_FORCE_NULLABLE">
<h3>BOOLEAN_FORCE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BOOLEAN_FORCE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 Boolean.</div>
</section>
</li>
<li>
<section class="detail" id="BOOLEAN_NOT_NULL">
<h3>BOOLEAN_NOT_NULL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BOOLEAN_NOT_NULL</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is BOOLEAN
 NOT NULL.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DATE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is DATE.</div>
</section>
</li>
<li>
<section class="detail" id="DATE_NULLABLE">
<h3>DATE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DATE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 DATE.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TIME</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is TIME(0).</div>
</section>
</li>
<li>
<section class="detail" id="TIME_NULLABLE">
<h3>TIME_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TIME_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 TIME(0).</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TIMESTAMP</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="TIMESTAMP_NULLABLE">
<h3>TIMESTAMP_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TIMESTAMP_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is nullable
 TIMESTAMP.</div>
</section>
</li>
<li>
<section class="detail" id="DOUBLE">
<h3>DOUBLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DOUBLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is Double.</div>
</section>
</li>
<li>
<section class="detail" id="DOUBLE_NULLABLE">
<h3>DOUBLE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DOUBLE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is Double with
 nulls allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="CHAR">
<h3>CHAR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">CHAR</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a Char.</div>
</section>
</li>
<li>
<section class="detail" id="CHAR_FORCE_NULLABLE">
<h3>CHAR_FORCE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">CHAR_FORCE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 CHAR(1).</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">INTEGER</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is an Integer.</div>
</section>
</li>
<li>
<section class="detail" id="INTEGER_NULLABLE">
<h3>INTEGER_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">INTEGER_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is an Integer
 with nulls allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="BIGINT">
<h3>BIGINT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BIGINT</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a BIGINT.</div>
</section>
</li>
<li>
<section class="detail" id="BIGINT_FORCE_NULLABLE">
<h3>BIGINT_FORCE_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BIGINT_FORCE_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a nullable
 BIGINT.</div>
</section>
</li>
<li>
<section class="detail" id="BIGINT_NULLABLE">
<h3>BIGINT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">BIGINT_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is a BIGINT
 with nulls allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="VARCHAR_4">
<h3>VARCHAR_4</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">VARCHAR_4</span></div>
<div class="block">Type-inference strategy that always returns "VARCHAR(4)".</div>
</section>
</li>
<li>
<section class="detail" id="VARCHAR_4_NULLABLE">
<h3>VARCHAR_4_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">VARCHAR_4_NULLABLE</span></div>
<div class="block">Type-inference strategy that always returns "VARCHAR(4)" with nulls
 allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="VARCHAR_2000">
<h3>VARCHAR_2000</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">VARCHAR_2000</span></div>
<div class="block">Type-inference strategy that always returns "VARCHAR(2000)".</div>
</section>
</li>
<li>
<section class="detail" id="VARCHAR_2000_NULLABLE">
<h3>VARCHAR_2000_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">VARCHAR_2000_NULLABLE</span></div>
<div class="block">Type-inference strategy that always returns "VARCHAR(2000)" with nulls
 allowed if any of the operands allow nulls.</div>
</section>
</li>
<li>
<section class="detail" id="HISTOGRAM">
<h3>HISTOGRAM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">HISTOGRAM</span></div>
<div class="block">Type-inference strategy for Histogram agg support.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">CURSOR</span></div>
<div class="block">Type-inference strategy that always returns "CURSOR".</div>
</section>
</li>
<li>
<section class="detail" id="COLUMN_LIST">
<h3>COLUMN_LIST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">COLUMN_LIST</span></div>
<div class="block">Type-inference strategy that always returns "COLUMN_LIST".</div>
</section>
</li>
<li>
<section class="detail" id="LEAST_RESTRICTIVE">
<h3>LEAST_RESTRICTIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">LEAST_RESTRICTIVE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is using its
 operands biggest type, using the SQL:1999 rules described in "Data types
 of results of aggregations". These rules are used in union, except,
 intersect, case and other places.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../util/Glossary.html#SQL99"><code>SQL:1999 Part 2 Section 9.3</code></a></li>
</ul>
</dd>
</dl>
</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET</span></div>
<div class="block">Returns the same type as the multiset carries. The multiset type returned
 is the least restrictive of the call's multiset operands</div>
</section>
</li>
<li>
<section class="detail" id="TO_MULTISET">
<h3>TO_MULTISET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TO_MULTISET</span></div>
<div class="block">Returns a MULTISET type.

 <p>For example, given <code>INTEGER</code>, returns
 <code>INTEGER MULTISET</code>.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_ELEMENT_NULLABLE">
<h3>MULTISET_ELEMENT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET_ELEMENT_NULLABLE</span></div>
<div class="block">Returns the element type of a MULTISET.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_NULLABLE">
<h3>MULTISET_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET_NULLABLE</span></div>
<div class="block">Same as <a href="#MULTISET"><code>MULTISET</code></a> but returns with nullability if any of the
 operands is nullable.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_PROJECT_ONLY">
<h3>MULTISET_PROJECT_ONLY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET_PROJECT_ONLY</span></div>
<div class="block">Returns the type of the only column of a multiset.

 <p>For example, given <code>RECORD(x INTEGER) MULTISET</code>, returns
 <code>INTEGER MULTISET</code>.</div>
</section>
</li>
<li>
<section class="detail" id="TO_ARRAY">
<h3>TO_ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TO_ARRAY</span></div>
<div class="block">Returns an ARRAY type.

 <p>For example, given <code>INTEGER</code>, returns
 <code>INTEGER ARRAY</code>.</div>
</section>
</li>
<li>
<section class="detail" id="TO_MAP">
<h3>TO_MAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">TO_MAP</span></div>
<div class="block">Returns a MAP type.

 <p>For example, given <code>Record(f0: INTEGER, f1: DATE)</code>, returns
 <code>(INTEGER, DATE) MAP</code>.</div>
</section>
</li>
<li>
<section class="detail" id="INTEGER_QUOTIENT_NULLABLE">
<h3>INTEGER_QUOTIENT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">INTEGER_QUOTIENT_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a> and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>. These rules
 are used for integer division.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_SCALE0">
<h3>DECIMAL_SCALE0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_SCALE0</span></div>
<div class="block">Type-inference strategy for a call where the first argument is a decimal.
 The result type of a call is a decimal with a scale of 0, and the same
 precision and nullability as the first argument.</div>
</section>
</li>
<li>
<section class="detail" id="ARG0_OR_EXACT_NO_SCALE">
<h3>ARG0_OR_EXACT_NO_SCALE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">ARG0_OR_EXACT_NO_SCALE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_SCALE0"><code>DECIMAL_SCALE0</code></a> with a fallback to <a href="#ARG0"><code>ARG0</code></a> This rule
 is used for floor, ceiling.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_PRODUCT">
<h3>DECIMAL_PRODUCT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_PRODUCT</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 product of two exact numeric operands where at least one of the operands
 is a decimal.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_PRODUCT_NULLABLE">
<h3>DECIMAL_PRODUCT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_PRODUCT_NULLABLE</span></div>
<div class="block">Same as <a href="#DECIMAL_PRODUCT"><code>DECIMAL_PRODUCT</code></a> but returns with nullability if any of
 the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="PRODUCT_NULLABLE">
<h3>PRODUCT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">PRODUCT_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_PRODUCT_NULLABLE"><code>DECIMAL_PRODUCT_NULLABLE</code></a> with a fallback to
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a>
 and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>.
 These rules are used for multiplication.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_QUOTIENT">
<h3>DECIMAL_QUOTIENT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_QUOTIENT</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 quotient of two exact numeric operands where at least one of the operands
 is a decimal.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_QUOTIENT_NULLABLE">
<h3>DECIMAL_QUOTIENT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_QUOTIENT_NULLABLE</span></div>
<div class="block">Same as <a href="#DECIMAL_QUOTIENT"><code>DECIMAL_QUOTIENT</code></a> but returns with nullability if any of
 the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="QUOTIENT_NULLABLE">
<h3>QUOTIENT_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">QUOTIENT_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_QUOTIENT_NULLABLE"><code>DECIMAL_QUOTIENT_NULLABLE</code></a> with a fallback to
 <a href="#ARG0_INTERVAL_NULLABLE"><code>ARG0_INTERVAL_NULLABLE</code></a> and <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>. These rules
 are used for division.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_SUM">
<h3>DECIMAL_SUM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_SUM</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 sum of two exact numeric operands where at least one of the operands is a
 decimal.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_SUM_NULLABLE">
<h3>DECIMAL_SUM_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_SUM_NULLABLE</span></div>
<div class="block">Same as <a href="#DECIMAL_SUM"><code>DECIMAL_SUM</code></a> but returns with nullability if any
 of the operands is nullable by using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="NULLABLE_SUM">
<h3>NULLABLE_SUM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">NULLABLE_SUM</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_SUM_NULLABLE"><code>DECIMAL_SUM_NULLABLE</code></a> with a fallback to <a href="#LEAST_RESTRICTIVE"><code>LEAST_RESTRICTIVE</code></a>
 These rules are used for addition and subtraction.</div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_MOD">
<h3>DECIMAL_MOD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_MOD</span></div>
</section>
</li>
<li>
<section class="detail" id="DECIMAL_MOD_NULLABLE">
<h3>DECIMAL_MOD_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DECIMAL_MOD_NULLABLE</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is the decimal
 modulus of two exact numeric operands where at least one of the operands is a
 decimal.</div>
</section>
</li>
<li>
<section class="detail" id="NULLABLE_MOD">
<h3>NULLABLE_MOD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">NULLABLE_MOD</span></div>
<div class="block">Type-inference strategy whereby the result type of a call is
 <a href="#DECIMAL_MOD_NULLABLE"><code>DECIMAL_MOD_NULLABLE</code></a> with a fallback to <a href="#ARG1_NULLABLE"><code>ARG1_NULLABLE</code></a>
 These rules are used for modulus.</div>
</section>
</li>
<li>
<section class="detail" id="DYADIC_STRING_SUM_PRECISION">
<h3>DYADIC_STRING_SUM_PRECISION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DYADIC_STRING_SUM_PRECISION</span></div>
<div class="block">Type-inference strategy for concatenating two string arguments. The result
 type of a call is:

 <ul>
 <li>the same type as the input types but with the combined length of the
 two first types</li>
 <li>if types are of char type the type with the highest coercibility will
 be used</li>
 <li>result is varying if either input is; otherwise fixed
 </ul>

 <p>Pre-requisites:

 <ul>
 <li>input types must be of the same string type
 <li>types must be comparable without casting
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="MULTIVALENT_STRING_SUM_PRECISION">
<h3>MULTIVALENT_STRING_SUM_PRECISION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTIVALENT_STRING_SUM_PRECISION</span></div>
<div class="block">Type-inference strategy for String concatenation.
 Result is varying if either input is; otherwise fixed.
 For example,

 <p>concat(cast('a' as varchar(2)), cast('b' as varchar(3)),cast('c' as varchar(2)))
 returns varchar(7).</p>

 <p>concat(cast('a' as varchar), cast('b' as varchar(2), cast('c' as varchar(2))))
 returns varchar.</p>

 <p>concat(cast('a' as varchar(65535)), cast('b' as varchar(2)), cast('c' as varchar(2)))
 returns varchar.</p></div>
</section>
</li>
<li>
<section class="detail" id="MULTIVALENT_STRING_SUM_PRECISION_NULLABLE">
<h3>MULTIVALENT_STRING_SUM_PRECISION_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTIVALENT_STRING_SUM_PRECISION_NULLABLE</span></div>
<div class="block">Same as <a href="#MULTIVALENT_STRING_SUM_PRECISION"><code>MULTIVALENT_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DYADIC_STRING_SUM_PRECISION_NULLABLE_VARYING">
<h3>DYADIC_STRING_SUM_PRECISION_NULLABLE_VARYING</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DYADIC_STRING_SUM_PRECISION_NULLABLE_VARYING</span></div>
<div class="block">Same as <a href="#DYADIC_STRING_SUM_PRECISION"><code>DYADIC_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>,
 <a href="SqlTypeTransforms.html#TO_VARYING"><code>SqlTypeTransforms.TO_VARYING</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DYADIC_STRING_SUM_PRECISION_NULLABLE">
<h3>DYADIC_STRING_SUM_PRECISION_NULLABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">DYADIC_STRING_SUM_PRECISION_NULLABLE</span></div>
<div class="block">Same as <a href="#DYADIC_STRING_SUM_PRECISION"><code>DYADIC_STRING_SUM_PRECISION</code></a> and using
 <a href="SqlTypeTransforms.html#TO_NULLABLE"><code>SqlTypeTransforms.TO_NULLABLE</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="SCOPE">
<h3>SCOPE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">SCOPE</span></div>
<div class="block">Type-inference strategy where the expression is assumed to be registered
 as a <a href="../validate/SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidatorNamespace</code></a>, and
 therefore the result type of the call is the type of that namespace.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_PROJECT0">
<h3>MULTISET_PROJECT0</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET_PROJECT0</span></div>
<div class="block">Returns a multiset of column #0 of a multiset. For example, given
 <code>RECORD(x INTEGER, y DATE) MULTISET</code>, returns <code>INTEGER
 MULTISET</code>.</div>
</section>
</li>
<li>
<section class="detail" id="MULTISET_RECORD">
<h3>MULTISET_RECORD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">MULTISET_RECORD</span></div>
<div class="block">Returns a multiset of the first column of a multiset. For example, given
 <code>INTEGER MULTISET</code>, returns <code>RECORD(x INTEGER)
 MULTISET</code>.</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="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">RECORD_TO_SCALAR</span></div>
<div class="block">Returns the field type of a structured type which has only one field. For
 example, given <code>RECORD(x INTEGER)</code> returns <code>INTEGER</code>.</div>
</section>
</li>
<li>
<section class="detail" id="AGG_SUM">
<h3>AGG_SUM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">AGG_SUM</span></div>
<div class="block">Type-inference strategy for SUM aggregate function inferred from the
 operand type, and nullable if the call occurs within a "GROUP BY ()"
 query. E.g. in "select sum(x) as s from empty", s may be null. Also,
 with the default implementation of RelDataTypeSystem, s has the same
 type name as x.</div>
</section>
</li>
<li>
<section class="detail" id="AGG_SUM_EMPTY_IS_ZERO">
<h3>AGG_SUM_EMPTY_IS_ZERO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">AGG_SUM_EMPTY_IS_ZERO</span></div>
<div class="block">Type-inference strategy for $SUM0 aggregate function inferred from the
 operand type. By default the inferred type is identical to the operand
 type. E.g. in "select $sum0(x) as s from empty", s has the same type as
 x.</div>
</section>
</li>
<li>
<section class="detail" id="FRACTIONAL_RANK">
<h3>FRACTIONAL_RANK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">FRACTIONAL_RANK</span></div>
<div class="block">Type-inference strategy for the <code>CUME_DIST</code> and <code>PERCENT_RANK</code>
 aggregate functions.</div>
</section>
</li>
<li>
<section class="detail" id="RANK">
<h3>RANK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">RANK</span></div>
<div class="block">Type-inference strategy for the <code>NTILE</code>, <code>RANK</code>,
 <code>DENSE_RANK</code>, and <code>ROW_NUMBER</code> aggregate functions.</div>
</section>
</li>
<li>
<section class="detail" id="AVG_AGG_FUNCTION">
<h3>AVG_AGG_FUNCTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">AVG_AGG_FUNCTION</span></div>
</section>
</li>
<li>
<section class="detail" id="COVAR_REGR_FUNCTION">
<h3>COVAR_REGR_FUNCTION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">COVAR_REGR_FUNCTION</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="chain(org.apache.calcite.sql.type.SqlReturnTypeInference...)">
<h3>chain</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInferenceChain.html" title="class in org.apache.calcite.sql.type">SqlReturnTypeInferenceChain</a></span>&nbsp;<span class="element-name">chain</span><wbr><span class="parameters">(<a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a>...&nbsp;rules)</span></div>
<div class="block">Creates a return-type inference that applies a rule then a sequence of
 rules, returning the first non-null result.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="SqlReturnTypeInference.html#orElse(org.apache.calcite.sql.type.SqlReturnTypeInference)"><code>SqlReturnTypeInference.orElse(SqlReturnTypeInference)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="cascade(org.apache.calcite.sql.type.SqlReturnTypeInference,org.apache.calcite.sql.type.SqlTypeTransform...)">
<h3>cascade</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlTypeTransformCascade.html" title="class in org.apache.calcite.sql.type">SqlTypeTransformCascade</a></span>&nbsp;<span class="element-name">cascade</span><wbr><span class="parameters">(<a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a>&nbsp;rule,
 <a href="SqlTypeTransform.html" title="interface in org.apache.calcite.sql.type">SqlTypeTransform</a>...&nbsp;transforms)</span></div>
<div class="block">Creates a return-type inference that applies a rule then a sequence of
 transforms.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="SqlReturnTypeInference.html#andThen(org.apache.calcite.sql.type.SqlTypeTransform)"><code>SqlReturnTypeInference.andThen(SqlTypeTransform)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="explicit(org.apache.calcite.rel.type.RelProtoDataType)">
<h3>explicit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></span>&nbsp;<span class="element-name">explicit</span><wbr><span class="parameters">(<a href="../../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</a>&nbsp;protoType)</span></div>
</section>
</li>
<li>
<section class="detail" id="explicit(org.apache.calcite.rel.type.RelDataType)">
<h3>explicit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></span>&nbsp;<span class="element-name">explicit</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</span></div>
<div class="block">Creates an inference rule which returns a copy of a given data type.</div>
</section>
</li>
<li>
<section class="detail" id="explicit(org.apache.calcite.sql.type.SqlTypeName)">
<h3>explicit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></span>&nbsp;<span class="element-name">explicit</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 an inference rule which returns a type with no precision or scale,
 such as <code>DATE</code>.</div>
</section>
</li>
<li>
<section class="detail" id="explicit(org.apache.calcite.sql.type.SqlTypeName,int)">
<h3>explicit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ExplicitReturnTypeInference.html" title="class in org.apache.calcite.sql.type">ExplicitReturnTypeInference</a></span>&nbsp;<span class="element-name">explicit</span><wbr><span class="parameters">(<a href="SqlTypeName.html" title="enum in org.apache.calcite.sql.type">SqlTypeName</a>&nbsp;typeName,
 int&nbsp;precision)</span></div>
<div class="block">Creates an inference rule which returns a type with precision but no scale,
 such as <code>VARCHAR(100)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="andThen(java.util.function.UnaryOperator,org.apache.calcite.sql.type.SqlReturnTypeInference)">
<h3>andThen</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a></span>&nbsp;<span class="element-name">andThen</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a>&gt;&nbsp;bindingTransform,
 <a href="SqlReturnTypeInference.html" title="interface in org.apache.calcite.sql.type">SqlReturnTypeInference</a>&nbsp;typeInference)</span></div>
<div class="block">Returns a return-type inference that first transforms a binding and
 then applies an inference.

 <p><a href="#stripOrderBy(org.apache.calcite.sql.SqlOperatorBinding)"><code>stripOrderBy(org.apache.calcite.sql.SqlOperatorBinding)</code></a> is an example of <code>bindingTransform</code>.</div>
</section>
</li>
<li>
<section class="detail" id="stripOrderBy(org.apache.calcite.sql.SqlOperatorBinding)">
<h3>stripOrderBy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a></span>&nbsp;<span class="element-name">stripOrderBy</span><wbr><span class="parameters">(<a href="../SqlOperatorBinding.html" title="class in org.apache.calcite.sql">SqlOperatorBinding</a>&nbsp;operatorBinding)</span></div>
<div class="block">Converts a binding of <code>FOO(x, y ORDER BY z)</code>
 or <code>FOO(x, y ORDER BY z SEPARATOR s)</code>
 to a binding of <code>FOO(x, y)</code>.
 Used for <code>STRING_AGG</code> and <code>GROUP_CONCAT</code>.</div>
</section>
</li>
<li>
<section class="detail" id="stripOrderBy(org.apache.calcite.sql.SqlCall)">
<h3>stripOrderBy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></span>&nbsp;<span class="element-name">stripOrderBy</span><wbr><span class="parameters">(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
</section>
</li>
<li>
<section class="detail" id="stripSeparator(org.apache.calcite.sql.SqlCall)">
<h3>stripSeparator</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a></span>&nbsp;<span class="element-name">stripSeparator</span><wbr><span class="parameters">(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
