<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlValidatorUtil (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.validate, class: SqlValidatorUtil">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#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.validate</a></div>
<h1 title="Class SqlValidatorUtil" class="title">Class SqlValidatorUtil</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql.validate.SqlValidatorUtil</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">SqlValidatorUtil</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Utility methods related to validation.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlValidatorUtil.DeepCopier.html" class="type-name-link" title="class in org.apache.calcite.sql.validate">SqlValidatorUtil.DeepCopier</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SqlValidatorUtil.FlatAggregate.html" class="type-name-link" title="class in org.apache.calcite.sql.validate">SqlValidatorUtil.FlatAggregate</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Flattens any FILTER, WITHIN DISTINCT, WITHIN GROUP surrounding a call to
 an aggregate function.</div>
</div>
<div class="col-first even-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlValidatorUtil.Suggester.html" class="type-name-link" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></code></div>
<div class="col-last even-row-color">
<div class="block">Suggests candidates for unique names, given the number of attempts so far
 and the number of expressions in the project list.</div>
</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></code></div>
<div class="col-second even-row-color"><code><a href="#ATTEMPT_SUGGESTER" class="member-name-link">ATTEMPT_SUGGESTER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EXPR_SUGGESTER" class="member-name-link">EXPR_SUGGESTER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></code></div>
<div class="col-second even-row-color"><code><a href="#F_SUGGESTER" class="member-name-link">F_SUGGESTER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-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><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated 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="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAlias(org.apache.calcite.sql.SqlNode,java.lang.String)" class="member-name-link">addAlias</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;expr,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;alias)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an expression "expr" into "expr AS alias".</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#alias(org.apache.calcite.sql.SqlNode)" class="member-name-link">alias</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#alias(org.apache.calcite.sql.SqlNode,int)" class="member-name-link">alias</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 int&nbsp;ordinal)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Derives an alias for a node, and invents a mangled identifier if it
 cannot.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#analyzeGroupItem(org.apache.calcite.sql.validate.SqlValidatorScope,org.apache.calcite.sql.validate.SqlValidatorUtil.GroupAnalyzer,com.google.common.collect.ImmutableList.Builder,org.apache.calcite.sql.SqlNode)" class="member-name-link">analyzeGroupItem</a><wbr>(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 org.apache.calcite.sql.validate.SqlValidatorUtil.GroupAnalyzer&nbsp;groupAnalyzer,
 com.google.common.collect.ImmutableList.Builder&lt;com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&gt;&nbsp;topBuilder,
 <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;groupExpr)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Analyzes an expression in a GROUP BY clause.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#checkCharsetAndCollateConsistentIfCharType(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">checkCharsetAndCollateConsistentIfCharType</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 even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#containsMonotonic(org.apache.calcite.sql.validate.SqlValidatorScope)" class="member-name-link">containsMonotonic</a><wbr>(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether there are any input columns that are sorted.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createJoinType(org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,java.util.List,java.util.List)" class="member-name-link">createJoinType</a><wbr>(<a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftType,
 @Nullable <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightType,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;systemFieldList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the type the row which results when two relations are joined.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../prepare/CalciteCatalogReader.html" title="class in org.apache.calcite.prepare">CalciteCatalogReader</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createSingleTableCatalogReader(boolean,java.lang.String,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">createSingleTableCatalogReader</a><wbr>(boolean&nbsp;caseSensitive,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;tableName,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType)</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 catalog reader that contains a single <a href="../../schema/Table.html" title="interface in org.apache.calcite.schema"><code>Table</code></a> with temporary table name
 and specified <code>rowType</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="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createTypeFromProjection(org.apache.calcite.rel.type.RelDataType,java.util.List,org.apache.calcite.rel.type.RelDataTypeFactory,boolean)" class="member-name-link">createTypeFromProjection</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;columnNameList,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 boolean&nbsp;caseSensitive)</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 com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cube(java.util.List)" class="member-name-link">cube</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the cube of bit sets.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#deriveJoinRowType(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.core.JoinRelType,org.apache.calcite.rel.type.RelDataTypeFactory,java.util.List,java.util.List)" class="member-name-link">deriveJoinRowType</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftType,
 @Nullable <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightType,
 <a href="../../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;systemFieldList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Derives the type of a join relational expression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#deriveNaturalJoinColumnList(org.apache.calcite.sql.validate.SqlNameMatcher,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">deriveNaturalJoinColumnList</a><wbr>(<a href="SqlNameMatcher.html" title="interface in org.apache.calcite.sql.validate">SqlNameMatcher</a>&nbsp;nameMatcher,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftRowType,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightRowType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Derives the list of column names suitable for NATURAL JOIN.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlValidatorUtil.FlatAggregate.html" title="class in org.apache.calcite.sql.validate">SqlValidatorUtil.FlatAggregate</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#flatten(org.apache.calcite.sql.SqlCall)" class="member-name-link">flatten</a><wbr>(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Flattens an aggregate call.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getAlias(org.apache.calcite.sql.SqlNode,int)" class="member-name-link">getAlias</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 int&nbsp;ordinal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#alias(org.apache.calcite.sql.SqlNode)"><code>alias(SqlNode)</code></a> if <code>ordinal</code> is negative,
 or <a href="#alias(org.apache.calcite.sql.SqlNode,int)"><code>alias(SqlNode, int)</code></a> if <code>ordinal</code> is non-negative.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="AggregatingSelectScope.html" title="class in org.apache.calcite.sql.validate">AggregatingSelectScope</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getEnclosingAggregateSelectScope(org.apache.calcite.sql.validate.SqlValidatorScope)" class="member-name-link">getEnclosingAggregateSelectScope</a><wbr>(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="SelectScope.html" title="class in org.apache.calcite.sql.validate">SelectScope</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getEnclosingSelectScope(org.apache.calcite.sql.validate.SqlValidatorScope)" class="member-name-link">getEnclosingSelectScope</a><wbr>(@Nullable <a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getExtendedColumns(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.sql.validate.SqlValidatorTable,org.apache.calcite.sql.SqlNodeList)" class="member-name-link">getExtendedColumns</a><wbr>(<a href="SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="SqlValidatorTable.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorTable</a>&nbsp;table,
 <a href="../SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;extendedColumns)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets a list of extended columns with field indices to the underlying table.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static com.google.common.collect.ImmutableMap&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getIndexToFieldMap(java.util.List,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">getIndexToFieldMap</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sourceFields,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets a map of indexes from the source to fields in the target for the
 intersecting set of source and target fields.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMeasure(org.apache.calcite.sql.SqlNode)" class="member-name-link">getMeasure</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;selectItem)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the measure expression if a select item is a measure, null
 otherwise.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getOrdinalBitSet(org.apache.calcite.rel.type.RelDataType,java.util.Map)" class="member-name-link">getOrdinalBitSet</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceRowType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;indexToField)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the bit-set to the column ordinals in the source for columns that
 intersect in the target.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getOrdinalBitSet(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">getOrdinalBitSet</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceRowType,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets the bit-set to the column ordinals in the source for columns that intersect in the target.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getRelOptTable(org.apache.calcite.sql.validate.SqlValidatorNamespace,org.apache.calcite.prepare.Prepare.CatalogReader,java.lang.String,boolean%5B%5D)" class="member-name-link">getRelOptTable</a><wbr>(<a href="SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorNamespace</a>&nbsp;namespace,
 @Nullable <a href="../../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;datasetName,
 boolean @Nullable []&nbsp;usedDataset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a <a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidatorScope</code></a> into a <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan"><code>RelOptTable</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getSchema(org.apache.calcite.jdbc.CalciteSchema,java.lang.Iterable,org.apache.calcite.sql.validate.SqlNameMatcher)" class="member-name-link">getSchema</a><wbr>(<a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;rootSchema,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;schemaPath,
 <a href="SqlNameMatcher.html" title="interface in org.apache.calcite.sql.validate">SqlNameMatcher</a>&nbsp;nameMatcher)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Finds and returns <a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema</code></a> nested to the given rootSchema
 with specified schemaPath.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getSchemaObjectMonikers(org.apache.calcite.sql.validate.SqlValidatorCatalogReader,java.util.List,java.util.List)" class="member-name-link">getSchemaObjectMonikers</a><wbr>(<a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="SqlMoniker.html" title="interface in org.apache.calcite.sql.validate">SqlMoniker</a>&gt;&nbsp;hints)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../../jdbc/CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getTableEntry(org.apache.calcite.sql.validate.SqlValidatorCatalogReader,java.util.List)" class="member-name-link">getTableEntry</a><wbr>(<a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Finds a <a href="../../jdbc/CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TableEntry</code></a> in a
 given catalog reader whose table has the given name, possibly qualified.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getTargetField(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.sql.SqlIdentifier,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.plan.RelOptTable)" class="member-name-link">getTargetField</a><wbr>(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;id,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 @Nullable <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&nbsp;table)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Resolve a target column name in the target table.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../../jdbc/CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getTypeEntry(org.apache.calcite.jdbc.CalciteSchema,org.apache.calcite.sql.SqlIdentifier)" class="member-name-link">getTypeEntry</a><wbr>(<a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;rootSchema,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;typeName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Finds a <a href="../../jdbc/CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TypeEntry</code></a> in a
 given schema whose type has the given name, possibly qualified.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isMeasure(org.apache.calcite.sql.SqlNode)" class="member-name-link">isMeasure</a><wbr>(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;selectItem)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether a select item is a measure.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorNamespace</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lookup(org.apache.calcite.sql.validate.SqlValidatorScope,java.util.List)" class="member-name-link">lookup</a><wbr>(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Resolves a multi-part identifier such as "SCHEMA.EMP.EMPNO" to a
 namespace.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static @Nullable <a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#lookupField(boolean,org.apache.calcite.rel.type.RelDataType,java.lang.String)" class="member-name-link">lookupField</a><wbr>(boolean&nbsp;caseSensitive,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;columnName)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lookupSqlFunctionByID(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.SqlIdentifier,org.apache.calcite.sql.SqlFunctionCategory)" class="member-name-link">lookupSqlFunctionByID</a><wbr>(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;funName,
 @Nullable <a href="../SqlFunctionCategory.html" title="enum in org.apache.calcite.sql">SqlFunctionCategory</a>&nbsp;funcType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Lookup sql function by sql identifier and function category.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mapNameToIndex(java.util.List)" class="member-name-link">mapNameToIndex</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;fields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a map from field names to indexes.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="SqlValidatorWithHints.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorWithHints</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#newValidator(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.rel.type.RelDataTypeFactory)" class="member-name-link">newValidator</a><wbr>(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlValidatorWithHints.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorWithHints</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newValidator(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.sql.validate.SqlValidator.Config)" class="member-name-link">newValidator</a><wbr>(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="SqlValidator.Config.html" title="interface in org.apache.calcite.sql.validate">SqlValidator.Config</a>&nbsp;config)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Factory method for <a href="SqlValidator.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidator</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rollup(java.util.List)" class="member-name-link">rollup</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the rollup of bit sets.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#uniquify(java.lang.String,java.util.Set,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester)" class="member-name-link">uniquify</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;usedNames,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a name distinct from other names which have already been used, adds
 it to the list, and returns it.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester,boolean)" class="member-name-link">uniquify</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes sure that the names in a list are unique.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#uniquify(java.util.List)" class="member-name-link">uniquify</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#uniquify(java.util.List,boolean)" class="member-name-link">uniquify</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes sure that the names in a list are unique.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester)" class="member-name-link">uniquify</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester,boolean)"><code>uniquify(List, Suggester, boolean)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#validateExprWithRowType(boolean,org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.sql.SqlNode)" class="member-name-link">validateExprWithRowType</a><wbr>(boolean&nbsp;caseSensitive,
 <a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;operatorTable,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;expr)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Validate the sql node with specified base table row type.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="EXPR_SUGGESTER">
<h3>EXPR_SUGGESTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></span>&nbsp;<span class="element-name">EXPR_SUGGESTER</span></div>
</section>
</li>
<li>
<section class="detail" id="F_SUGGESTER">
<h3>F_SUGGESTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></span>&nbsp;<span class="element-name">F_SUGGESTER</span></div>
</section>
</li>
<li>
<section class="detail" id="ATTEMPT_SUGGESTER">
<h3>ATTEMPT_SUGGESTER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a></span>&nbsp;<span class="element-name">ATTEMPT_SUGGESTER</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="getRelOptTable(org.apache.calcite.sql.validate.SqlValidatorNamespace,org.apache.calcite.prepare.Prepare.CatalogReader,java.lang.String,boolean[])">
<h3>getRelOptTable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a></span>&nbsp;<span class="element-name">getRelOptTable</span><wbr><span class="parameters">(<a href="SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorNamespace</a>&nbsp;namespace,
 @Nullable <a href="../../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;datasetName,
 boolean @Nullable []&nbsp;usedDataset)</span></div>
<div class="block">Converts a <a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidatorScope</code></a> into a <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan"><code>RelOptTable</code></a>. This is
 only possible if the scope represents an identifier, such as "sales.emp".
 Otherwise, returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>namespace</code> - Namespace</dd>
<dd><code>catalogReader</code> - Schema</dd>
<dd><code>datasetName</code> - Name of sample dataset to substitute, or null to use
                      the regular table</dd>
<dd><code>usedDataset</code> - Output parameter which is set to true if a sample
                      dataset is found; may be null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getExtendedColumns(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.sql.validate.SqlValidatorTable,org.apache.calcite.sql.SqlNodeList)">
<h3>getExtendedColumns</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</span>&nbsp;<span class="element-name">getExtendedColumns</span><wbr><span class="parameters">(<a href="SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="SqlValidatorTable.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorTable</a>&nbsp;table,
 <a href="../SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;extendedColumns)</span></div>
<div class="block">Gets a list of extended columns with field indices to the underlying table.</div>
</section>
</li>
<li>
<section class="detail" id="getIndexToFieldMap(java.util.List,org.apache.calcite.rel.type.RelDataType)">
<h3>getIndexToFieldMap</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableMap&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</span>&nbsp;<span class="element-name">getIndexToFieldMap</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sourceFields,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetFields)</span></div>
<div class="block">Gets a map of indexes from the source to fields in the target for the
 intersecting set of source and target fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceFields</code> - The source of column names that determine indexes</dd>
<dd><code>targetFields</code> - The target fields to be indexed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getOrdinalBitSet(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType)">
<h3>getOrdinalBitSet</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></span>&nbsp;<span class="element-name">getOrdinalBitSet</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceRowType,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType)</span></div>
<div class="block">Gets the bit-set to the column ordinals in the source for columns that intersect in the target.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceRowType</code> - The source upon which to ordinate the bit set.</dd>
<dd><code>targetRowType</code> - The target to overlay on the source to create the bit set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getOrdinalBitSet(org.apache.calcite.rel.type.RelDataType,java.util.Map)">
<h3>getOrdinalBitSet</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></span>&nbsp;<span class="element-name">getOrdinalBitSet</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceRowType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;indexToField)</span></div>
<div class="block">Gets the bit-set to the column ordinals in the source for columns that
 intersect in the target.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceRowType</code> - The source upon which to ordinate the bit set.</dd>
<dd><code>indexToField</code> - The map of ordinals to target fields.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="mapNameToIndex(java.util.List)">
<h3>mapNameToIndex</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">mapNameToIndex</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;fields)</span></div>
<div class="block">Returns a map from field names to indexes.</div>
</section>
</li>
<li>
<section class="detail" id="lookupField(boolean,org.apache.calcite.rel.type.RelDataType,java.lang.String)">
<h3>lookupField</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a></span>&nbsp;<span class="element-name">lookupField</span><wbr><span class="parameters">(boolean&nbsp;caseSensitive,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;columnName)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCharsetAndCollateConsistentIfCharType(org.apache.calcite.rel.type.RelDataType)">
<h3>checkCharsetAndCollateConsistentIfCharType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCharsetAndCollateConsistentIfCharType</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>
</section>
</li>
<li>
<section class="detail" id="addAlias(org.apache.calcite.sql.SqlNode,java.lang.String)">
<h3>addAlias</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">addAlias</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;expr,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;alias)</span></div>
<div class="block">Converts an expression "expr" into "expr AS alias".</div>
</section>
</li>
<li>
<section class="detail" id="alias(org.apache.calcite.sql.SqlNode,int)">
<h3>alias</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">alias</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 int&nbsp;ordinal)</span></div>
<div class="block">Derives an alias for a node, and invents a mangled identifier if it
 cannot.

 <p>Examples:

 <ul>
 <li>Alias: "1 + 2 as foo" yields "foo"
 <li>Identifier: "foo.bar.baz" yields "baz"
 <li>Anything else yields "expr$<i>ordinal</i>"
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - Node</dd>
<dd><code>ordinal</code> - Ordinal in SELECT clause (must be &ge; 0)</dd>
<dt>Returns:</dt>
<dd>An alias, if one can be derived; or a synthetic alias
 "expr$<i>ordinal</i>"; never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="alias(org.apache.calcite.sql.SqlNode)">
<h3>alias</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">alias</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node)</span></div>
</section>
</li>
<li>
<section class="detail" id="getAlias(org.apache.calcite.sql.SqlNode,int)">
<h3>getAlias</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getAlias</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 int&nbsp;ordinal)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#alias(org.apache.calcite.sql.SqlNode)"><code>alias(SqlNode)</code></a> if <code>ordinal</code> is negative,
 or <a href="#alias(org.apache.calcite.sql.SqlNode,int)"><code>alias(SqlNode, int)</code></a> if <code>ordinal</code> is non-negative.</div>
</div>
<div class="block">Derives an alias for a node, and invents a mangled identifier if it
 cannot.</div>
</section>
</li>
<li>
<section class="detail" id="newValidator(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.sql.validate.SqlValidator.Config)">
<h3>newValidator</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlValidatorWithHints.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorWithHints</a></span>&nbsp;<span class="element-name">newValidator</span><wbr><span class="parameters">(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="SqlValidator.Config.html" title="interface in org.apache.calcite.sql.validate">SqlValidator.Config</a>&nbsp;config)</span></div>
<div class="block">Factory method for <a href="SqlValidator.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidator</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="newValidator(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.rel.type.RelDataTypeFactory)">
<h3>newValidator</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlValidatorWithHints.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorWithHints</a></span>&nbsp;<span class="element-name">newValidator</span><wbr><span class="parameters">(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Factory method for <a href="SqlValidator.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidator</code></a>, with default conformance.</div>
</section>
</li>
<li>
<section class="detail" id="uniquify(java.lang.String,java.util.Set,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester)">
<h3>uniquify</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">uniquify</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;usedNames,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester)</span></div>
<div class="block">Makes a name distinct from other names which have already been used, adds
 it to the list, and returns it.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>name</code> - Suggested name, may not be unique</dd>
<dd><code>usedNames</code> - Collection of names already used</dd>
<dd><code>suggester</code> - Base for name when input name is null</dd>
<dt>Returns:</dt>
<dd>Unique name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="uniquify(java.util.List)">
<h3>uniquify</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">uniquify</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Makes sure that the names in a list are unique.

 <p>Does not modify the input list. Returns the input list if the strings
 are unique, otherwise allocates a new list. Deprecated in favor of caseSensitive
 aware version.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nameList</code> - List of strings</dd>
<dt>Returns:</dt>
<dd>List of unique strings</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester)">
<h3>uniquify</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">uniquify</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester,boolean)"><code>uniquify(List, Suggester, boolean)</code></a></div>
</div>
<div class="block">Makes sure that the names in a list are unique.

 <p>Does not modify the input list. Returns the input list if the strings
 are unique, otherwise allocates a new list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nameList</code> - List of strings</dd>
<dd><code>suggester</code> - How to generate new names if duplicate names are found</dd>
<dt>Returns:</dt>
<dd>List of unique strings</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="uniquify(java.util.List,boolean)">
<h3>uniquify</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">uniquify</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Makes sure that the names in a list are unique.

 <p>Does not modify the input list. Returns the input list if the strings
 are unique, otherwise allocates a new list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nameList</code> - List of strings</dd>
<dd><code>caseSensitive</code> - Whether upper and lower case names are considered
     distinct</dd>
<dt>Returns:</dt>
<dd>List of unique strings</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="uniquify(java.util.List,org.apache.calcite.sql.validate.SqlValidatorUtil.Suggester,boolean)">
<h3>uniquify</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">uniquify</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="SqlValidatorUtil.Suggester.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorUtil.Suggester</a>&nbsp;suggester,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Makes sure that the names in a list are unique.

 <p>Does not modify the input list. Returns the input list if the strings
 are unique, otherwise allocates a new list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nameList</code> - List of strings</dd>
<dd><code>suggester</code> - How to generate new names if duplicate names are found</dd>
<dd><code>caseSensitive</code> - Whether upper and lower case names are considered
     distinct</dd>
<dt>Returns:</dt>
<dd>List of unique strings</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deriveJoinRowType(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.core.JoinRelType,org.apache.calcite.rel.type.RelDataTypeFactory,java.util.List,java.util.List)">
<h3>deriveJoinRowType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></span>&nbsp;<span class="element-name">deriveJoinRowType</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftType,
 @Nullable <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightType,
 <a href="../../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;systemFieldList)</span></div>
<div class="block">Derives the type of a join relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>leftType</code> - Row type of left input to join</dd>
<dd><code>rightType</code> - Row type of right input to join</dd>
<dd><code>joinType</code> - Type of join</dd>
<dd><code>typeFactory</code> - Type factory</dd>
<dd><code>fieldNameList</code> - List of names of fields; if null, field names are
                        inherited and made unique</dd>
<dd><code>systemFieldList</code> - List of system fields that will be prefixed to
                        output row type; typically empty but must not be
                        null</dd>
<dt>Returns:</dt>
<dd>join type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createJoinType(org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,java.util.List,java.util.List)">
<h3>createJoinType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></span>&nbsp;<span class="element-name">createJoinType</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftType,
 @Nullable <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightType,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;systemFieldList)</span></div>
<div class="block">Returns the type the row which results when two relations are joined.

 <p>The resulting row type consists of
 the system fields (if any), followed by
 the fields of the left type, followed by
 the fields of the right type. The field name list, if present, overrides
 the original names of the fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>typeFactory</code> - Type factory</dd>
<dd><code>leftType</code> - Type of left input to join</dd>
<dd><code>rightType</code> - Type of right input to join, or null for semi-join</dd>
<dd><code>fieldNameList</code> - If not null, overrides the original names of the
                        fields</dd>
<dd><code>systemFieldList</code> - List of system fields that will be prefixed to
                        output row type; typically empty but must not be
                        null</dd>
<dt>Returns:</dt>
<dd>type of row which results when two relations are joined</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTargetField(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.sql.SqlIdentifier,org.apache.calcite.sql.validate.SqlValidatorCatalogReader,org.apache.calcite.plan.RelOptTable)">
<h3>getTargetField</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a></span>&nbsp;<span class="element-name">getTargetField</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;id,
 <a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 @Nullable <a href="../../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&nbsp;table)</span></div>
<div class="block">Resolve a target column name in the target table.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rowType</code> - the target row type</dd>
<dd><code>id</code> - the target column identifier</dd>
<dd><code>table</code> - the target table or null if it is not a RelOptTable instance</dd>
<dt>Returns:</dt>
<dd>the target field or null if the name cannot be resolved</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="lookup(org.apache.calcite.sql.validate.SqlValidatorScope,java.util.List)">
<h3>lookup</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlValidatorNamespace.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorNamespace</a></span>&nbsp;<span class="element-name">lookup</span><wbr><span class="parameters">(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names)</span></div>
<div class="block">Resolves a multi-part identifier such as "SCHEMA.EMP.EMPNO" to a
 namespace. The returned namespace, never null, may represent a
 schema, table, column, etc.</div>
</section>
</li>
<li>
<section class="detail" id="getSchemaObjectMonikers(org.apache.calcite.sql.validate.SqlValidatorCatalogReader,java.util.List,java.util.List)">
<h3>getSchemaObjectMonikers</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">getSchemaObjectMonikers</span><wbr><span class="parameters">(<a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="SqlMoniker.html" title="interface in org.apache.calcite.sql.validate">SqlMoniker</a>&gt;&nbsp;hints)</span></div>
</section>
</li>
<li>
<section class="detail" id="getEnclosingSelectScope(org.apache.calcite.sql.validate.SqlValidatorScope)">
<h3>getEnclosingSelectScope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="SelectScope.html" title="class in org.apache.calcite.sql.validate">SelectScope</a></span>&nbsp;<span class="element-name">getEnclosingSelectScope</span><wbr><span class="parameters">(@Nullable <a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</span></div>
</section>
</li>
<li>
<section class="detail" id="getEnclosingAggregateSelectScope(org.apache.calcite.sql.validate.SqlValidatorScope)">
<h3>getEnclosingAggregateSelectScope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="AggregatingSelectScope.html" title="class in org.apache.calcite.sql.validate">AggregatingSelectScope</a></span>&nbsp;<span class="element-name">getEnclosingAggregateSelectScope</span><wbr><span class="parameters">(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</span></div>
</section>
</li>
<li>
<section class="detail" id="deriveNaturalJoinColumnList(org.apache.calcite.sql.validate.SqlNameMatcher,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType)">
<h3>deriveNaturalJoinColumnList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">deriveNaturalJoinColumnList</span><wbr><span class="parameters">(<a href="SqlNameMatcher.html" title="interface in org.apache.calcite.sql.validate">SqlNameMatcher</a>&nbsp;nameMatcher,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;leftRowType,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rightRowType)</span></div>
<div class="block">Derives the list of column names suitable for NATURAL JOIN. These are the
 columns that occur at least once each side of the join.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nameMatcher</code> - Whether matches are case-sensitive</dd>
<dd><code>leftRowType</code> - Row type of left input to the join</dd>
<dd><code>rightRowType</code> - Row type of right input to the join</dd>
<dt>Returns:</dt>
<dd>List of columns that occur once on each side</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createTypeFromProjection(org.apache.calcite.rel.type.RelDataType,java.util.List,org.apache.calcite.rel.type.RelDataTypeFactory,boolean)">
<h3>createTypeFromProjection</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></span>&nbsp;<span class="element-name">createTypeFromProjection</span><wbr><span class="parameters">(<a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;columnNameList,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 boolean&nbsp;caseSensitive)</span></div>
</section>
</li>
<li>
<section class="detail" id="analyzeGroupItem(org.apache.calcite.sql.validate.SqlValidatorScope,org.apache.calcite.sql.validate.SqlValidatorUtil.GroupAnalyzer,com.google.common.collect.ImmutableList.Builder,org.apache.calcite.sql.SqlNode)">
<h3>analyzeGroupItem</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">analyzeGroupItem</span><wbr><span class="parameters">(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 org.apache.calcite.sql.validate.SqlValidatorUtil.GroupAnalyzer&nbsp;groupAnalyzer,
 com.google.common.collect.ImmutableList.Builder&lt;com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&gt;&nbsp;topBuilder,
 <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;groupExpr)</span></div>
<div class="block">Analyzes an expression in a GROUP BY clause.

 <p>It may be an expression, an empty list (), or a call to
 <code>GROUPING SETS</code>, <code>CUBE</code>, <code>ROLLUP</code>,
 <code>TUMBLE</code>, <code>HOP</code> or <code>SESSION</code>.

 <p>Each group item produces a list of group sets, which are written to
 <code>topBuilder</code>. To find the grouping sets of the query, we will take
 the cartesian product of the group sets.</div>
</section>
</li>
<li>
<section class="detail" id="rollup(java.util.List)">
<h3>rollup</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</span>&nbsp;<span class="element-name">rollup</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</span></div>
<div class="block">Computes the rollup of bit sets.

 <p>For example, <code>rollup({0}, {1})</code>
 returns <code>({0, 1}, {0}, {})</code>.

 <p>Bit sets are not necessarily singletons:
 <code>rollup({0, 2}, {3, 5})</code>
 returns <code>({0, 2, 3, 5}, {0, 2}, {})</code>.</div>
</section>
</li>
<li>
<section class="detail" id="cube(java.util.List)">
<h3>cube</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">com.google.common.collect.ImmutableList&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;</span>&nbsp;<span class="element-name">cube</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;bitSets)</span></div>
<div class="block">Computes the cube of bit sets.

 <p>For example,  <code>rollup({0}, {1})</code>
 returns <code>({0, 1}, {0}, {})</code>.

 <p>Bit sets are not necessarily singletons:
 <code>rollup({0, 2}, {3, 5})</code>
 returns <code>({0, 2, 3, 5}, {0, 2}, {})</code>.</div>
</section>
</li>
<li>
<section class="detail" id="getTypeEntry(org.apache.calcite.jdbc.CalciteSchema,org.apache.calcite.sql.SqlIdentifier)">
<h3>getTypeEntry</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../jdbc/CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></span>&nbsp;<span class="element-name">getTypeEntry</span><wbr><span class="parameters">(<a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;rootSchema,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;typeName)</span></div>
<div class="block">Finds a <a href="../../jdbc/CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TypeEntry</code></a> in a
 given schema whose type has the given name, possibly qualified.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rootSchema</code> - root schema</dd>
<dd><code>typeName</code> - name of the type, may be qualified or fully-qualified</dd>
<dt>Returns:</dt>
<dd>TypeEntry with a table with the given name, or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTableEntry(org.apache.calcite.sql.validate.SqlValidatorCatalogReader,java.util.List)">
<h3>getTableEntry</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../jdbc/CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getTableEntry</span><wbr><span class="parameters">(<a href="SqlValidatorCatalogReader.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorCatalogReader</a>&nbsp;catalogReader,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;names)</span></div>
<div class="block">Finds a <a href="../../jdbc/CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TableEntry</code></a> in a
 given catalog reader whose table has the given name, possibly qualified.

 <p>Uses the case-sensitivity policy of the specified catalog reader.

 <p>If not found, returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>catalogReader</code> - accessor to the table metadata</dd>
<dd><code>names</code> - Name of table, may be qualified or fully-qualified</dd>
<dt>Returns:</dt>
<dd>TableEntry with a table with the given name, or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSchema(org.apache.calcite.jdbc.CalciteSchema,java.lang.Iterable,org.apache.calcite.sql.validate.SqlNameMatcher)">
<h3>getSchema</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">getSchema</span><wbr><span class="parameters">(<a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;rootSchema,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;schemaPath,
 <a href="SqlNameMatcher.html" title="interface in org.apache.calcite.sql.validate">SqlNameMatcher</a>&nbsp;nameMatcher)</span></div>
<div class="block">Finds and returns <a href="../../jdbc/CalciteSchema.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema</code></a> nested to the given rootSchema
 with specified schemaPath.

 <p>Uses the case-sensitivity policy of specified nameMatcher.

 <p>If not found, returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rootSchema</code> - root schema</dd>
<dd><code>schemaPath</code> - full schema path of required schema</dd>
<dd><code>nameMatcher</code> - name matcher</dd>
<dt>Returns:</dt>
<dd>CalciteSchema that corresponds specified schemaPath</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="containsMonotonic(org.apache.calcite.sql.validate.SqlValidatorScope)">
<h3>containsMonotonic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">containsMonotonic</span><wbr><span class="parameters">(<a href="SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope)</span></div>
<div class="block">Returns whether there are any input columns that are sorted.

 <p>If so, it can be the default ORDER BY clause for a WINDOW specification.
 (This is an extension to the SQL standard for streaming.)</div>
</section>
</li>
<li>
<section class="detail" id="lookupSqlFunctionByID(org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.sql.SqlIdentifier,org.apache.calcite.sql.SqlFunctionCategory)">
<h3>lookupSqlFunctionByID</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">lookupSqlFunctionByID</span><wbr><span class="parameters">(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;opTab,
 <a href="../SqlIdentifier.html" title="class in org.apache.calcite.sql">SqlIdentifier</a>&nbsp;funName,
 @Nullable <a href="../SqlFunctionCategory.html" title="enum in org.apache.calcite.sql">SqlFunctionCategory</a>&nbsp;funcType)</span></div>
<div class="block">Lookup sql function by sql identifier and function category.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>opTab</code> - operator table to look up</dd>
<dd><code>funName</code> - function name</dd>
<dd><code>funcType</code> - function category</dd>
<dt>Returns:</dt>
<dd>A sql function if and only if there is one operator matches, else null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="validateExprWithRowType(boolean,org.apache.calcite.sql.SqlOperatorTable,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.sql.SqlNode)">
<h3>validateExprWithRowType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;</span>&nbsp;<span class="element-name">validateExprWithRowType</span><wbr><span class="parameters">(boolean&nbsp;caseSensitive,
 <a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;operatorTable,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;expr)</span></div>
<div class="block">Validate the sql node with specified base table row type. For "base table", we mean the
 table that the sql node expression references fields with.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>caseSensitive</code> - whether to match the catalog case-sensitively</dd>
<dd><code>operatorTable</code> - operator table</dd>
<dd><code>typeFactory</code> - type factory</dd>
<dd><code>rowType</code> - the table row type that has fields referenced by the expression</dd>
<dd><code>expr</code> - the expression to validate</dd>
<dt>Returns:</dt>
<dd>pair of a validated expression sql node and its data type,
 usually a SqlUnresolvedFunction is converted to a resolved function</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createSingleTableCatalogReader(boolean,java.lang.String,org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType)">
<h3>createSingleTableCatalogReader</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../../prepare/CalciteCatalogReader.html" title="class in org.apache.calcite.prepare">CalciteCatalogReader</a></span>&nbsp;<span class="element-name">createSingleTableCatalogReader</span><wbr><span class="parameters">(boolean&nbsp;caseSensitive,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;tableName,
 <a href="../../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType)</span></div>
<div class="block">Creates a catalog reader that contains a single <a href="../../schema/Table.html" title="interface in org.apache.calcite.schema"><code>Table</code></a> with temporary table name
 and specified <code>rowType</code>.

 <p>Make this method public so that other systems can also use it.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>caseSensitive</code> - whether to match case sensitively</dd>
<dd><code>tableName</code> - table name to register with</dd>
<dd><code>typeFactory</code> - type factory</dd>
<dd><code>rowType</code> - table row type</dd>
<dt>Returns:</dt>
<dd>the <a href="../../prepare/CalciteCatalogReader.html" title="class in org.apache.calcite.prepare"><code>CalciteCatalogReader</code></a> instance</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="flatten(org.apache.calcite.sql.SqlCall)">
<h3>flatten</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlValidatorUtil.FlatAggregate.html" title="class in org.apache.calcite.sql.validate">SqlValidatorUtil.FlatAggregate</a></span>&nbsp;<span class="element-name">flatten</span><wbr><span class="parameters">(<a href="../SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
<div class="block">Flattens an aggregate call.</div>
</section>
</li>
<li>
<section class="detail" id="isMeasure(org.apache.calcite.sql.SqlNode)">
<h3>isMeasure</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isMeasure</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;selectItem)</span></div>
<div class="block">Returns whether a select item is a measure.</div>
</section>
</li>
<li>
<section class="detail" id="getMeasure(org.apache.calcite.sql.SqlNode)">
<h3>getMeasure</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">getMeasure</span><wbr><span class="parameters">(<a href="../SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;selectItem)</span></div>
<div class="block">Returns the measure expression if a select item is a measure, null
 otherwise.

 <p>For a measure, <code>selectItem</code> will have the form
 <code>AS(MEASURE(exp), alias)</code> and this method returns <code>exp</code>.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
