<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlToRelConverter (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.sql2rel, class: SqlToRelConverter">
<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><a href="#constructor-summary">Constr</a>&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><a href="#constructor-detail">Constr</a>&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.sql2rel</a></div>
<h1 title="Class SqlToRelConverter" class="title">Class SqlToRelConverter</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql2rel.SqlToRelConverter</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="annotations">@Enclosing
</span><span class="modifiers">public class </span><span class="element-name type-name-label">SqlToRelConverter</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Converts a SQL parse tree (consisting of
 <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> objects) into a relational algebra
 expression (consisting of <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a> objects).

 <p>The public entry points are: <a href="#convertQuery(org.apache.calcite.sql.SqlNode,boolean,boolean)"><code>convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean)</code></a>,
 <a href="#convertExpression(org.apache.calcite.sql.SqlNode)"><code>convertExpression(SqlNode)</code></a>.</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>protected class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlToRelConverter.AggConverter.html" class="type-name-link" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.AggConverter</a></code></div>
<div class="col-last even-row-color">
<div class="block">Converts expressions to aggregates.</div>
</div>
<div class="col-first odd-row-color"><code>protected class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SqlToRelConverter.Blackboard.html" class="type-name-link" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Workspace for translating an individual SELECT statement (or sub-SELECT).</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="SqlToRelConverter.Config.html" class="type-name-link" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></code></div>
<div class="col-last even-row-color">
<div class="block">Interface to define the configuration for a SqlToRelConverter.</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="SqlToRelConverter.SqlIdentifierFinder.html" class="type-name-link" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.SqlIdentifierFinder</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Visitor that looks for an SqlIdentifier inside a tree of
 <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> objects and return <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html#TRUE" title="class or interface in java.lang" class="external-link"><code>Boolean.TRUE</code></a> when it finds
 one.</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>protected final <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a></code></div>
<div class="col-second even-row-color"><code><a href="#catalogReader" class="member-name-link">catalogReader</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a></code></div>
<div class="col-second odd-row-color"><code><a href="#cluster" class="member-name-link">cluster</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>final <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></code></div>
<div class="col-second even-row-color"><code><a href="#config" class="member-name-link">config</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></code></div>
<div class="col-second odd-row-color"><code><a href="#CONFIG" class="member-name-link">CONFIG</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Default configuration.</div>
</div>
<div class="col-first even-row-color"><code>static final int</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_IN_SUB_QUERY_THRESHOLD" class="member-name-link">DEFAULT_IN_SUB_QUERY_THRESHOLD</a></code></div>
<div class="col-last even-row-color">
<div class="block">Size of the smallest IN list that will be converted to a semijoin to a
 static table.</div>
</div>
<div class="col-first odd-row-color"><code>static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_IN_SUBQUERY_THRESHOLD" class="member-name-link">DEFAULT_IN_SUBQUERY_THRESHOLD</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color"><code>protected final <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#leaves" class="member-name-link">leaves</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a></code></div>
<div class="col-second odd-row-color"><code><a href="#rexBuilder" class="member-name-link">rexBuilder</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected static final org.slf4j.Logger</code></div>
<div class="col-second even-row-color"><code><a href="#SQL2REL_LOGGER" class="member-name-link">SQL2REL_LOGGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a></code></div>
<div class="col-second odd-row-color"><code><a href="#typeFactory" class="member-name-link">typeFactory</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>final @Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a></code></div>
<div class="col-second even-row-color"><code><a href="#validator" class="member-name-link">validator</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>final <a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a></code></div>
<div class="col-second odd-row-color"><code><a href="#viewExpander" class="member-name-link">viewExpander</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.sql2rel.SqlRexConvertletTable,org.apache.calcite.sql2rel.SqlToRelConverter.Config)" class="member-name-link">SqlToRelConverter</a><wbr>(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 @Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable,
 <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a>&nbsp;config)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.sql2rel.SqlRexConvertletTable)" class="member-name-link">SqlToRelConverter</a><wbr>(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable)</code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptPlanner,org.apache.calcite.rex.RexBuilder,org.apache.calcite.sql2rel.SqlRexConvertletTable)" class="member-name-link">SqlToRelConverter</a><wbr>(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable)</code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance 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-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addConvertedNonCorrSubqs(java.util.Map)" class="member-name-link">addConvertedNonCorrSubqs</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;alreadyConvertedNonCorrSubqs)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds to the current map of non-correlated converted sub-queries the
 elements from another map that contains non-correlated sub-queries that
 have been converted by another SqlToRelConverter.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#adjustInputRef(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rex.RexInputRef)" class="member-name-link">adjustInputRef</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rex/RexInputRef.html" title="class in org.apache.calcite.rex">RexInputRef</a>&nbsp;inputRef)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adjusts the type of a reference to an input field to account for nulls
 introduced by outer joins; and adjusts the offset to match the physical
 implementation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#afterTableFunction(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlCall,org.apache.calcite.rel.logical.LogicalTableFunctionScan)" class="member-name-link">afterTableFunction</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 <a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical">LogicalTableFunctionScan</a>&nbsp;callRel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#collectInsertTargets(org.apache.calcite.sql.SqlInsert,org.apache.calcite.rex.RexNode,java.util.List,java.util.List)" class="member-name-link">collectInsertTargets</a><wbr>(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;sourceRef,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;targetColumnNames,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;columnExprs)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Given an INSERT statement, collects the list of names to be populated and
 the expressions to put in them.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#config()" class="member-name-link">config</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a default <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel"><code>SqlToRelConverter.Config</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertAgg(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,java.util.List)" class="member-name-link">convertAgg</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertCollectionTable(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlCall)" class="member-name-link">convertCollectionTable</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/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-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertColumnList(org.apache.calcite.sql.SqlInsert,org.apache.calcite.rel.RelNode)" class="member-name-link">convertColumnList</a><wbr>(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;source)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a source for an INSERT statement.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rex/RexDynamicParam.html" title="class in org.apache.calcite.rex">RexDynamicParam</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertDynamicParam(org.apache.calcite.sql.SqlDynamicParam)" class="member-name-link">convertDynamicParam</a><wbr>(<a href="../sql/SqlDynamicParam.html" title="class in org.apache.calcite.sql">SqlDynamicParam</a>&nbsp;dynamicParam)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertExpression(org.apache.calcite.sql.SqlNode)" class="member-name-link">convertExpression</a><wbr>(<a href="../sql/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-tab2 method-summary-table-tab4">
<div class="block">Converts an expression from <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> to <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex"><code>RexNode</code></a> format.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertExpression(org.apache.calcite.sql.SqlNode,java.util.Map)" class="member-name-link">convertExpression</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nameToNodeMap)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts an expression from <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> to <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex"><code>RexNode</code></a> format,
 mapping identifier references to predefined expressions.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertExtendedExpression(org.apache.calcite.sql.SqlNode,org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard)" class="member-name-link">convertExtendedExpression</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 <a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a non-standard expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertFrom(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlNode)" class="member-name-link">convertFrom</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;from)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertFrom(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlNode,java.util.List)" class="member-name-link">convertFrom</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;from,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a FROM clause into a relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertInsert(org.apache.calcite.sql.SqlInsert)" class="member-name-link">convertInsert</a><wbr>(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertMatchRecognize(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlMatchRecognize)" class="member-name-link">convertMatchRecognize</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlMatchRecognize.html" title="class in org.apache.calcite.sql">SqlMatchRecognize</a>&nbsp;matchRecognize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertOrder(org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rel.RelCollation,java.util.List,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)" class="member-name-link">convertOrder</a><wbr>(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel">RelCollation</a>&nbsp;collation,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a query's ORDER BY clause, if any.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelFieldCollation.html" title="class in org.apache.calcite.rel">RelFieldCollation</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertOrderItem(org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql.SqlNode,java.util.List,org.apache.calcite.rel.RelFieldCollation.Direction,org.apache.calcite.rel.RelFieldCollation.NullDirection)" class="member-name-link">convertOrderItem</a><wbr>(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;orderItem,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;extraExprs,
 <a href="../rel/RelFieldCollation.Direction.html" title="enum in org.apache.calcite.rel">RelFieldCollation.Direction</a>&nbsp;direction,
 <a href="../rel/RelFieldCollation.NullDirection.html" title="enum in org.apache.calcite.rel">RelFieldCollation.NullDirection</a>&nbsp;nullDirection)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertPivot(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlPivot)" class="member-name-link">convertPivot</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlPivot.html" title="class in org.apache.calcite.sql">SqlPivot</a>&nbsp;pivot)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertQuery(org.apache.calcite.sql.SqlNode,boolean,boolean)" class="member-name-link">convertQuery</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 boolean&nbsp;needsValidation,
 boolean&nbsp;top)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts an unvalidated query's parse tree into a relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertQueryRecursive(org.apache.calcite.sql.SqlNode,boolean,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">convertQueryRecursive</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 boolean&nbsp;top,
 @Nullable <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-tab2 method-summary-table-tab4">
<div class="block">Recursively converts a query to a relational expression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertSelect(org.apache.calcite.sql.SqlSelect,boolean)" class="member-name-link">convertSelect</a><wbr>(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 boolean&nbsp;top)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a SELECT statement's parse tree into a relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertSelectImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect)" class="member-name-link">convertSelectImpl</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Implementation of <a href="#convertSelect(org.apache.calcite.sql.SqlSelect,boolean)"><code>convertSelect(SqlSelect, boolean)</code></a>;
 derived class may override.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertSetOp(org.apache.calcite.sql.SqlCall)" class="member-name-link">convertSetOp</a><wbr>(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a set operation (UNION, INTERSECT, MINUS) into relational
 expressions.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertToSingleValueSubq(org.apache.calcite.sql.SqlNode,org.apache.calcite.rel.RelNode)" class="member-name-link">convertToSingleValueSubq</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;plan)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts the RelNode tree for a select statement to a select that
 produces a single value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertUnpivot(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlUnpivot)" class="member-name-link">convertUnpivot</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlUnpivot.html" title="class in org.apache.calcite.sql">SqlUnpivot</a>&nbsp;unpivot)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertValues(org.apache.calcite.sql.SqlCall,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">convertValues</a><wbr>(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;values,
 @Nullable <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-tab2 method-summary-table-tab4">
<div class="block">Converts a SELECT statement's parse tree into a relational expression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertWith(org.apache.calcite.sql.SqlWith,boolean)" class="member-name-link">convertWith</a><wbr>(<a href="../sql/SqlWith.html" title="class in org.apache.calcite.sql">SqlWith</a>&nbsp;with,
 boolean&nbsp;top)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a WITH sub-query into a relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNode,java.util.List)" class="member-name-link">createAggImpl</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="SqlToRelConverter.AggConverter.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.AggConverter</a>&nbsp;aggConverter,
 <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;selectList,
 @Nullable <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;groupList,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;having,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createAggregate(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.util.ImmutableBitSet,com.google.common.collect.ImmutableList,java.util.List)" class="member-name-link">createAggregate</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;groupSet,
 com.google.common.collect.ImmutableList&lt;<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;groupSets,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/AggregateCall.html" title="class in org.apache.calcite.rel.core">AggregateCall</a>&gt;&nbsp;aggCalls)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates an Aggregate.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createBlackboard(org.apache.calcite.sql.validate.SqlValidatorScope,java.util.Map,boolean)" class="member-name-link">createBlackboard</a><wbr>(@Nullable <a href="../sql/validate/SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nameToNodeMap,
 boolean&nbsp;top)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Factory method for creating translation workspace.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createJoin(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.JoinRelType)" class="member-name-link">createJoin</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;leftRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rightRel,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;joinCond,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#decorrelate(org.apache.calcite.sql.SqlNode,org.apache.calcite.rel.RelNode)" class="member-name-link">decorrelate</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If sub-query is correlated and decorrelation is enabled, performs
 decorrelation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#decorrelateQuery(org.apache.calcite.rel.RelNode)" class="member-name-link">decorrelateQuery</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>protected boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#enableDecorrelation()" class="member-name-link">enableDecorrelation</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#extraSelectItems(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,java.util.List,java.util.List,java.util.Collection,java.util.List)" class="member-name-link">extraSelectItems</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;aliasList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/validate/SqlMonotonicity.html" title="enum in org.apache.calcite.sql.validate">SqlMonotonicity</a>&gt;&nbsp;columnMonotonicityList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds extra select items.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#flattenTypes(org.apache.calcite.rel.RelNode,boolean)" class="member-name-link">flattenTypes</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel,
 boolean&nbsp;restructure)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#gatherOrderExprs(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql.SqlNodeList,java.util.List,java.util.List)" class="member-name-link">gatherOrderExprs</a><wbr>(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 @Nullable <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;orderList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;extraOrderExprs,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/RelFieldCollation.html" title="class in org.apache.calcite.rel">RelFieldCollation</a>&gt;&nbsp;collationList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a list of collations required to implement the ORDER BY clause,
 if there is one.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCluster()" class="member-name-link">getCluster</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the RelOptCluster in use.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDynamicParamCount()" class="member-name-link">getDynamicParamCount</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the number of dynamic parameters encountered during translation;
 this must only be called after <a href="#convertQuery(org.apache.calcite.sql.SqlNode,boolean,boolean)"><code>convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean)</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDynamicParamCountInExplain(boolean)" class="member-name-link">getDynamicParamCountInExplain</a><wbr>(boolean&nbsp;increment)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the current count of the number of dynamic parameters in an
 EXPLAIN PLAN statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDynamicParamType(int)" class="member-name-link">getDynamicParamType</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the type inferred for a dynamic parameter.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>protected int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getInSubqueryThreshold()" class="member-name-link">getInSubqueryThreshold</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMapConvertedNonCorrSubqs()" class="member-name-link">getMapConvertedNonCorrSubqs</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the mapping of non-correlated sub-queries that have been converted
 to the constants that they evaluate to.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRexBuilder()" class="member-name-link">getRexBuilder</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the row-expression builder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="https://docs.oracle.com/javase/9/docs/api/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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSystemFields()" class="member-name-link">getSystemFields</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a list of fields to be prefixed to each relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTargetTable(org.apache.calcite.sql.SqlNode)" class="member-name-link">getTargetTable</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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="#isOrdered(org.apache.calcite.sql.SqlNode)" class="member-name-link">isOrdered</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query)</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-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#isTrimUnusedFields()" class="member-name-link">isTrimUnusedFields</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 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-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#newFieldTrimmer()" class="member-name-link">newFieldTrimmer</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a RelFieldTrimmer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setDynamicParamCountInExplain(int)" class="member-name-link">setDynamicParamCountInExplain</a><wbr>(int&nbsp;explainParamCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the number of dynamic parameters in the current EXPLAIN PLAN
 statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSubQueryConverter(org.apache.calcite.sql2rel.SubQueryConverter)" class="member-name-link">setSubQueryConverter</a><wbr>(<a href="SubQueryConverter.html" title="interface in org.apache.calcite.sql2rel">SubQueryConverter</a>&nbsp;converter)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a new SubQueryConverter.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toRel(org.apache.calcite.plan.RelOptTable,java.util.List)" class="member-name-link">toRel</a><wbr>(<a href="../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&nbsp;table,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint">RelHint</a>&gt;&nbsp;hints)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimUnusedFields(boolean,org.apache.calcite.rel.RelNode)" class="member-name-link">trimUnusedFields</a><wbr>(boolean&nbsp;ordered,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Walks over a tree of relational expressions, replacing each
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a> with a 'slimmed down' relational expression that projects
 only the fields required by its consumer.</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/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="CONFIG">
<h3>CONFIG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></span>&nbsp;<span class="element-name">CONFIG</span></div>
<div class="block">Default configuration.</div>
</section>
</li>
<li>
<section class="detail" id="SQL2REL_LOGGER">
<h3>SQL2REL_LOGGER</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type">org.slf4j.Logger</span>&nbsp;<span class="element-name">SQL2REL_LOGGER</span></div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_IN_SUB_QUERY_THRESHOLD">
<h3>DEFAULT_IN_SUB_QUERY_THRESHOLD</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_IN_SUB_QUERY_THRESHOLD</span></div>
<div class="block">Size of the smallest IN list that will be converted to a semijoin to a
 static table.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUB_QUERY_THRESHOLD">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_IN_SUBQUERY_THRESHOLD">
<h3>DEFAULT_IN_SUBQUERY_THRESHOLD</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_IN_SUBQUERY_THRESHOLD</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUBQUERY_THRESHOLD">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="validator">
<h3>validator</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a></span>&nbsp;<span class="element-name">validator</span></div>
</section>
</li>
<li>
<section class="detail" id="rexBuilder">
<h3>rexBuilder</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a></span>&nbsp;<span class="element-name">rexBuilder</span></div>
</section>
</li>
<li>
<section class="detail" id="catalogReader">
<h3>catalogReader</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a></span>&nbsp;<span class="element-name">catalogReader</span></div>
</section>
</li>
<li>
<section class="detail" id="cluster">
<h3>cluster</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a></span>&nbsp;<span class="element-name">cluster</span></div>
</section>
</li>
<li>
<section class="detail" id="leaves">
<h3>leaves</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">leaves</span></div>
</section>
</li>
<li>
<section class="detail" id="typeFactory">
<h3>typeFactory</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a></span>&nbsp;<span class="element-name">typeFactory</span></div>
</section>
</li>
<li>
<section class="detail" id="config">
<h3>config</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></span>&nbsp;<span class="element-name">config</span></div>
</section>
</li>
<li>
<section class="detail" id="viewExpander">
<h3>viewExpander</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a></span>&nbsp;<span class="element-name">viewExpander</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptPlanner,org.apache.calcite.rex.RexBuilder,org.apache.calcite.sql2rel.SqlRexConvertletTable)">
<h3>SqlToRelConverter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlToRelConverter</span><wbr><span class="parameters">(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Creates a converter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>viewExpander</code> - Preparing statement</dd>
<dd><code>validator</code> - Validator</dd>
<dd><code>catalogReader</code> - Schema</dd>
<dd><code>planner</code> - Planner</dd>
<dd><code>rexBuilder</code> - Rex builder</dd>
<dd><code>convertletTable</code> - Expression converter</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.sql2rel.SqlRexConvertletTable)">
<h3>SqlToRelConverter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlToRelConverter</span><wbr><span class="parameters">(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.plan.RelOptTable.ViewExpander,org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.prepare.Prepare.CatalogReader,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.sql2rel.SqlRexConvertletTable,org.apache.calcite.sql2rel.SqlToRelConverter.Config)">
<h3>SqlToRelConverter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlToRelConverter</span><wbr><span class="parameters">(<a href="../plan/RelOptTable.ViewExpander.html" title="interface in org.apache.calcite.plan">RelOptTable.ViewExpander</a>&nbsp;viewExpander,
 @Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../prepare/Prepare.CatalogReader.html" title="interface in org.apache.calcite.prepare">Prepare.CatalogReader</a>&nbsp;catalogReader,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="SqlRexConvertletTable.html" title="interface in org.apache.calcite.sql2rel">SqlRexConvertletTable</a>&nbsp;convertletTable,
 <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a>&nbsp;config)</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="getCluster()">
<h3>getCluster</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a></span>&nbsp;<span class="element-name">getCluster</span>()</div>
<div class="block">Returns the RelOptCluster in use.</div>
</section>
</li>
<li>
<section class="detail" id="getRexBuilder()">
<h3>getRexBuilder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a></span>&nbsp;<span class="element-name">getRexBuilder</span>()</div>
<div class="block">Returns the row-expression builder.</div>
</section>
</li>
<li>
<section class="detail" id="getDynamicParamCount()">
<h3>getDynamicParamCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getDynamicParamCount</span>()</div>
<div class="block">Returns the number of dynamic parameters encountered during translation;
 this must only be called after <a href="#convertQuery(org.apache.calcite.sql.SqlNode,boolean,boolean)"><code>convertQuery(org.apache.calcite.sql.SqlNode, boolean, boolean)</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>number of dynamic parameters</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDynamicParamType(int)">
<h3>getDynamicParamType</h3>
<div class="member-signature"><span class="modifiers">public</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">getDynamicParamType</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block">Returns the type inferred for a dynamic parameter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>index</code> - 0-based index of dynamic parameter</dd>
<dt>Returns:</dt>
<dd>inferred type, never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDynamicParamCountInExplain(boolean)">
<h3>getDynamicParamCountInExplain</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getDynamicParamCountInExplain</span><wbr><span class="parameters">(boolean&nbsp;increment)</span></div>
<div class="block">Returns the current count of the number of dynamic parameters in an
 EXPLAIN PLAN statement.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>increment</code> - if true, increment the count</dd>
<dt>Returns:</dt>
<dd>the current count before the optional increment</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMapConvertedNonCorrSubqs()">
<h3>getMapConvertedNonCorrSubqs</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">getMapConvertedNonCorrSubqs</span>()</div>
<div class="block">Returns the mapping of non-correlated sub-queries that have been converted
 to the constants that they evaluate to.</div>
</section>
</li>
<li>
<section class="detail" id="addConvertedNonCorrSubqs(java.util.Map)">
<h3>addConvertedNonCorrSubqs</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addConvertedNonCorrSubqs</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;alreadyConvertedNonCorrSubqs)</span></div>
<div class="block">Adds to the current map of non-correlated converted sub-queries the
 elements from another map that contains non-correlated sub-queries that
 have been converted by another SqlToRelConverter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>alreadyConvertedNonCorrSubqs</code> - the other map</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSubQueryConverter(org.apache.calcite.sql2rel.SubQueryConverter)">
<h3>setSubQueryConverter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setSubQueryConverter</span><wbr><span class="parameters">(<a href="SubQueryConverter.html" title="interface in org.apache.calcite.sql2rel">SubQueryConverter</a>&nbsp;converter)</span></div>
<div class="block">Sets a new SubQueryConverter. To have any effect, this must be called
 before any convert method.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>converter</code> - new SubQueryConverter</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDynamicParamCountInExplain(int)">
<h3>setDynamicParamCountInExplain</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDynamicParamCountInExplain</span><wbr><span class="parameters">(int&nbsp;explainParamCount)</span></div>
<div class="block">Sets the number of dynamic parameters in the current EXPLAIN PLAN
 statement.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>explainParamCount</code> - number of dynamic parameters in the statement</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="flattenTypes(org.apache.calcite.rel.RelNode,boolean)">
<h3>flattenTypes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">flattenTypes</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel,
 boolean&nbsp;restructure)</span></div>
</section>
</li>
<li>
<section class="detail" id="decorrelate(org.apache.calcite.sql.SqlNode,org.apache.calcite.rel.RelNode)">
<h3>decorrelate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">decorrelate</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</span></div>
<div class="block">If sub-query is correlated and decorrelation is enabled, performs
 decorrelation.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - Query</dd>
<dd><code>rootRel</code> - Root relational expression</dd>
<dt>Returns:</dt>
<dd>New root relational expression after decorrelation</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trimUnusedFields(boolean,org.apache.calcite.rel.RelNode)">
<h3>trimUnusedFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">trimUnusedFields</span><wbr><span class="parameters">(boolean&nbsp;ordered,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</span></div>
<div class="block">Walks over a tree of relational expressions, replacing each
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a> with a 'slimmed down' relational expression that projects
 only the fields required by its consumer.

 <p>This may make things easier for the optimizer, by removing crud that
 would expand the search space, but is difficult for the optimizer itself
 to do it, because optimizer rules must preserve the number and type of
 fields. Hence, this transform that operates on the entire tree, similar
 to the <a href="RelStructuredTypeFlattener.html" title="class in org.apache.calcite.sql2rel"><code>type-flattening transform</code></a>.

 <p>Currently this functionality is disabled in farrago/luciddb; the
 default implementation of this method does nothing.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>ordered</code> - Whether the relational expression must produce results in
 a particular order (typically because it has an ORDER BY at top level)</dd>
<dd><code>rootRel</code> - Relational expression that is at the root of the tree</dd>
<dt>Returns:</dt>
<dd>Trimmed relational expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newFieldTrimmer()">
<h3>newFieldTrimmer</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer</a></span>&nbsp;<span class="element-name">newFieldTrimmer</span>()</div>
<div class="block">Creates a RelFieldTrimmer.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Field trimmer</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertQuery(org.apache.calcite.sql.SqlNode,boolean,boolean)">
<h3>convertQuery</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></span>&nbsp;<span class="element-name">convertQuery</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 boolean&nbsp;needsValidation,
 boolean&nbsp;top)</span></div>
<div class="block">Converts an unvalidated query's parse tree into a relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - Query to convert</dd>
<dd><code>needsValidation</code> - Whether to validate the query before converting;
                        <code>false</code> if the query has already been
                        validated.</dd>
<dd><code>top</code> - Whether the query is top-level, say if its result
                        will become a JDBC result set; <code>false</code> if
                        the query will be part of a view.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isOrdered(org.apache.calcite.sql.SqlNode)">
<h3>isOrdered</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isOrdered</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertSelect(org.apache.calcite.sql.SqlSelect,boolean)">
<h3>convertSelect</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertSelect</span><wbr><span class="parameters">(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 boolean&nbsp;top)</span></div>
<div class="block">Converts a SELECT statement's parse tree into a relational expression.</div>
</section>
</li>
<li>
<section class="detail" id="createBlackboard(org.apache.calcite.sql.validate.SqlValidatorScope,java.util.Map,boolean)">
<h3>createBlackboard</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a></span>&nbsp;<span class="element-name">createBlackboard</span><wbr><span class="parameters">(@Nullable <a href="../sql/validate/SqlValidatorScope.html" title="interface in org.apache.calcite.sql.validate">SqlValidatorScope</a>&nbsp;scope,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nameToNodeMap,
 boolean&nbsp;top)</span></div>
<div class="block">Factory method for creating translation workspace.</div>
</section>
</li>
<li>
<section class="detail" id="convertSelectImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect)">
<h3>convertSelectImpl</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertSelectImpl</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select)</span></div>
<div class="block">Implementation of <a href="#convertSelect(org.apache.calcite.sql.SqlSelect,boolean)"><code>convertSelect(SqlSelect, boolean)</code></a>;
 derived class may override.</div>
</section>
</li>
<li>
<section class="detail" id="convertOrder(org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rel.RelCollation,java.util.List,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)">
<h3>convertOrder</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertOrder</span><wbr><span class="parameters">(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rel/RelCollation.html" title="interface in org.apache.calcite.rel">RelCollation</a>&nbsp;collation,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
<div class="block">Converts a query's ORDER BY clause, if any.

 <p>Ignores the ORDER BY clause if the query is not top-level and FETCH or
 OFFSET are not present.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>select</code> - Query</dd>
<dd><code>bb</code> - Blackboard</dd>
<dd><code>collation</code> - Collation list</dd>
<dd><code>orderExprList</code> - Method populates this list with orderBy expressions
                      not present in selectList</dd>
<dd><code>offset</code> - Expression for number of rows to discard before
                      returning first row</dd>
<dd><code>fetch</code> - Expression for number of rows to fetch</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertToSingleValueSubq(org.apache.calcite.sql.SqlNode,org.apache.calcite.rel.RelNode)">
<h3>convertToSingleValueSubq</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertToSingleValueSubq</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;plan)</span></div>
<div class="block">Converts the RelNode tree for a select statement to a select that
 produces a single value.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - the query</dd>
<dd><code>plan</code> - the original RelNode tree corresponding to the statement</dd>
<dt>Returns:</dt>
<dd>the converted RelNode tree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getInSubqueryThreshold()">
<h3>getInSubqueryThreshold</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">protected</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getInSubqueryThreshold</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Gets the list size threshold under which <code>convertInToOr(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, java.util.List&lt;org.apache.calcite.rex.RexNode&gt;, org.apache.calcite.sql.SqlNodeList, org.apache.calcite.sql.fun.SqlInOperator)</code> is used.
 Lists of this size or greater will instead be converted to use a join
 against an inline table
 (<a href="../rel/logical/LogicalValues.html" title="class in org.apache.calcite.rel.logical"><code>LogicalValues</code></a>) rather than a
 predicate. A threshold of 0 forces usage of an inline table in all cases; a
 threshold of Integer.MAX_VALUE forces usage of OR in all cases</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>threshold, default <a href="#DEFAULT_IN_SUB_QUERY_THRESHOLD"><code>DEFAULT_IN_SUB_QUERY_THRESHOLD</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertExpression(org.apache.calcite.sql.SqlNode)">
<h3>convertExpression</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">convertExpression</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node)</span></div>
<div class="block">Converts an expression from <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> to <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex"><code>RexNode</code></a> format.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - Expression to translate</dd>
<dt>Returns:</dt>
<dd>Converted expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertExpression(org.apache.calcite.sql.SqlNode,java.util.Map)">
<h3>convertExpression</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">convertExpression</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nameToNodeMap)</span></div>
<div class="block">Converts an expression from <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> to <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex"><code>RexNode</code></a> format,
 mapping identifier references to predefined expressions.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - Expression to translate</dd>
<dd><code>nameToNodeMap</code> - map from String to <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex"><code>RexNode</code></a>; when an
                      <a href="../sql/SqlIdentifier.html" title="class in org.apache.calcite.sql"><code>SqlIdentifier</code></a> is encountered, it is used as a
                      key and translated to the corresponding value from
                      this map</dd>
<dt>Returns:</dt>
<dd>Converted expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertExtendedExpression(org.apache.calcite.sql.SqlNode,org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard)">
<h3>convertExtendedExpression</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">convertExtendedExpression</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 <a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb)</span></div>
<div class="block">Converts a non-standard expression.

 <p>This method is an extension-point that derived classes can override. If
 this method returns a null result, the normal expression translation
 process will proceed. The default implementation always returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - Expression</dd>
<dd><code>bb</code> - Blackboard</dd>
<dt>Returns:</dt>
<dd>null to proceed with the usual expression translation process</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertFrom(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlNode)">
<h3>convertFrom</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertFrom</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;from)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertFrom(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlNode,java.util.List)">
<h3>convertFrom</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertFrom</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;from,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</span></div>
<div class="block">Converts a FROM clause into a relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Scope within which to resolve identifiers</dd>
<dd><code>from</code> - FROM clause of a query. Examples include:

             <ul>
             <li>a single table ("SALES.EMP"),
             <li>an aliased table ("EMP AS E"),
             <li>a list of tables ("EMP, DEPT"),
             <li>an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO =
             DEPT.DEPTNO"),
             <li>a VALUES clause ("VALUES ('Fred', 20)"),
             <li>a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
             <li>or any combination of the above.
             </ul></dd>
<dd><code>fieldNames</code> - Field aliases, usually come from AS clause, or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertMatchRecognize(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlMatchRecognize)">
<h3>convertMatchRecognize</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertMatchRecognize</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlMatchRecognize.html" title="class in org.apache.calcite.sql">SqlMatchRecognize</a>&nbsp;matchRecognize)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertPivot(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlPivot)">
<h3>convertPivot</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertPivot</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlPivot.html" title="class in org.apache.calcite.sql">SqlPivot</a>&nbsp;pivot)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertUnpivot(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlUnpivot)">
<h3>convertUnpivot</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertUnpivot</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlUnpivot.html" title="class in org.apache.calcite.sql">SqlUnpivot</a>&nbsp;unpivot)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertCollectionTable(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlCall)">
<h3>convertCollectionTable</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertCollectionTable</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
</section>
</li>
<li>
<section class="detail" id="afterTableFunction(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlCall,org.apache.calcite.rel.logical.LogicalTableFunctionScan)">
<h3>afterTableFunction</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">afterTableFunction</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 <a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical">LogicalTableFunctionScan</a>&nbsp;callRel)</span></div>
</section>
</li>
<li>
<section class="detail" id="createJoin(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.JoinRelType)">
<h3>createJoin</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createJoin</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;leftRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rightRel,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;joinCond,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</span></div>
</section>
</li>
<li>
<section class="detail" id="getSystemFields()">
<h3>getSystemFields</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/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">getSystemFields</span>()</div>
<div class="block">Returns a list of fields to be prefixed to each relational expression.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>List of system fields</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertAgg(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,java.util.List)">
<h3>convertAgg</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">convertAgg</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList)</span></div>
<div class="block">Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.

 <p>This method extracts SELECT, GROUP BY and HAVING clauses, and creates
 an <a href="SqlToRelConverter.AggConverter.html" title="class in org.apache.calcite.sql2rel"><code>SqlToRelConverter.AggConverter</code></a>, then delegates to <a href="#createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNode,java.util.List)"><code>createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard, org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter, org.apache.calcite.sql.SqlNodeList, org.apache.calcite.sql.SqlNodeList, org.apache.calcite.sql.SqlNode, java.util.List&lt;org.apache.calcite.sql.SqlNode&gt;)</code></a>.
 Derived class may override this method to change any of those clauses or
 specify a different <a href="SqlToRelConverter.AggConverter.html" title="class in org.apache.calcite.sql2rel"><code>SqlToRelConverter.AggConverter</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Scope within which to resolve identifiers</dd>
<dd><code>select</code> - Query</dd>
<dd><code>orderExprList</code> - Additional expressions needed to implement ORDER BY</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createAggImpl(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql2rel.SqlToRelConverter.AggConverter,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNodeList,org.apache.calcite.sql.SqlNode,java.util.List)">
<h3>createAggImpl</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">createAggImpl</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="SqlToRelConverter.AggConverter.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.AggConverter</a>&nbsp;aggConverter,
 <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;selectList,
 @Nullable <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;groupList,
 @Nullable <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;having,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;orderExprList)</span></div>
</section>
</li>
<li>
<section class="detail" id="createAggregate(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.util.ImmutableBitSet,com.google.common.collect.ImmutableList,java.util.List)">
<h3>createAggregate</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createAggregate</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;groupSet,
 com.google.common.collect.ImmutableList&lt;<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&gt;&nbsp;groupSets,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/AggregateCall.html" title="class in org.apache.calcite.rel.core">AggregateCall</a>&gt;&nbsp;aggCalls)</span></div>
<div class="block">Creates an Aggregate.

 <p>In case the aggregate rel changes the order in which it projects
 fields, the <code>groupExprProjection</code> parameter is provided, and
 the implementation of this method may modify it.

 <p>The <code>sortedCount</code> parameter is the number of expressions
 known to be monotonic. These expressions must be on the leading edge of
 the grouping keys. The default implementation of this method ignores this
 parameter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Blackboard</dd>
<dd><code>groupSet</code> - Bit set of ordinals of grouping columns</dd>
<dd><code>groupSets</code> - Grouping sets</dd>
<dd><code>aggCalls</code> - Array of calls to aggregate functions</dd>
<dt>Returns:</dt>
<dd>LogicalAggregate</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertDynamicParam(org.apache.calcite.sql.SqlDynamicParam)">
<h3>convertDynamicParam</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rex/RexDynamicParam.html" title="class in org.apache.calcite.rex">RexDynamicParam</a></span>&nbsp;<span class="element-name">convertDynamicParam</span><wbr><span class="parameters">(<a href="../sql/SqlDynamicParam.html" title="class in org.apache.calcite.sql">SqlDynamicParam</a>&nbsp;dynamicParam)</span></div>
</section>
</li>
<li>
<section class="detail" id="gatherOrderExprs(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql.SqlNodeList,java.util.List,java.util.List)">
<h3>gatherOrderExprs</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">gatherOrderExprs</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 @Nullable <a href="../sql/SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;orderList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;extraOrderExprs,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/RelFieldCollation.html" title="class in org.apache.calcite.rel">RelFieldCollation</a>&gt;&nbsp;collationList)</span></div>
<div class="block">Creates a list of collations required to implement the ORDER BY clause,
 if there is one. Populates <code>extraOrderExprs</code> with any sort
 expressions which are not in the select clause.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Scope within which to resolve identifiers</dd>
<dd><code>select</code> - Select clause. Never null, because we invent a
                        dummy SELECT if ORDER BY is applied to a set
                        operation (UNION etc.)</dd>
<dd><code>orderList</code> - Order by clause, may be null</dd>
<dd><code>extraOrderExprs</code> - Sort expressions which are not in the select
                        clause (output)</dd>
<dd><code>collationList</code> - List of collations (output)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertOrderItem(org.apache.calcite.sql.SqlSelect,org.apache.calcite.sql.SqlNode,java.util.List,org.apache.calcite.rel.RelFieldCollation.Direction,org.apache.calcite.rel.RelFieldCollation.NullDirection)">
<h3>convertOrderItem</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelFieldCollation.html" title="class in org.apache.calcite.rel">RelFieldCollation</a></span>&nbsp;<span class="element-name">convertOrderItem</span><wbr><span class="parameters">(<a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;orderItem,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&gt;&nbsp;extraExprs,
 <a href="../rel/RelFieldCollation.Direction.html" title="enum in org.apache.calcite.rel">RelFieldCollation.Direction</a>&nbsp;direction,
 <a href="../rel/RelFieldCollation.NullDirection.html" title="enum in org.apache.calcite.rel">RelFieldCollation.NullDirection</a>&nbsp;nullDirection)</span></div>
</section>
</li>
<li>
<section class="detail" id="enableDecorrelation()">
<h3>enableDecorrelation</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">enableDecorrelation</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="decorrelateQuery(org.apache.calcite.rel.RelNode)">
<h3>decorrelateQuery</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">decorrelateQuery</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</span></div>
</section>
</li>
<li>
<section class="detail" id="isTrimUnusedFields()">
<h3>isTrimUnusedFields</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isTrimUnusedFields</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Returns whether to trim unused fields as part of the conversion process.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Whether to trim unused fields</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertQueryRecursive(org.apache.calcite.sql.SqlNode,boolean,org.apache.calcite.rel.type.RelDataType)">
<h3>convertQueryRecursive</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></span>&nbsp;<span class="element-name">convertQueryRecursive</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;query,
 boolean&nbsp;top,
 @Nullable <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType)</span></div>
<div class="block">Recursively converts a query to a relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - Query</dd>
<dd><code>top</code> - Whether this query is the top-level query of the
                      statement</dd>
<dd><code>targetRowType</code> - Target row type, or null</dd>
<dt>Returns:</dt>
<dd>Relational expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertSetOp(org.apache.calcite.sql.SqlCall)">
<h3>convertSetOp</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertSetOp</span><wbr><span class="parameters">(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
<div class="block">Converts a set operation (UNION, INTERSECT, MINUS) into relational
 expressions.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - Call to set operator</dd>
<dt>Returns:</dt>
<dd>Relational expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertInsert(org.apache.calcite.sql.SqlInsert)">
<h3>convertInsert</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertInsert</span><wbr><span class="parameters">(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call)</span></div>
</section>
</li>
<li>
<section class="detail" id="toRel(org.apache.calcite.plan.RelOptTable,java.util.List)">
<h3>toRel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">toRel</span><wbr><span class="parameters">(<a href="../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&nbsp;table,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint">RelHint</a>&gt;&nbsp;hints)</span></div>
</section>
</li>
<li>
<section class="detail" id="getTargetTable(org.apache.calcite.sql.SqlNode)">
<h3>getTargetTable</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../plan/RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a></span>&nbsp;<span class="element-name">getTargetTable</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;call)</span></div>
</section>
</li>
<li>
<section class="detail" id="convertColumnList(org.apache.calcite.sql.SqlInsert,org.apache.calcite.rel.RelNode)">
<h3>convertColumnList</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertColumnList</span><wbr><span class="parameters">(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;source)</span></div>
<div class="block">Creates a source for an INSERT statement.

 <p>If the column list is not specified, source expressions match target
 columns in order.

 <p>If the column list is specified, Source expressions are mapped to
 target columns by name via targetColumnList, and may not cover the entire
 target table. So, we'll make up a full row, using a combination of
 default values and the source expressions provided.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - Insert expression</dd>
<dd><code>source</code> - Source relational expression</dd>
<dt>Returns:</dt>
<dd>Converted INSERT statement</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="collectInsertTargets(org.apache.calcite.sql.SqlInsert,org.apache.calcite.rex.RexNode,java.util.List,java.util.List)">
<h3>collectInsertTargets</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">collectInsertTargets</span><wbr><span class="parameters">(<a href="../sql/SqlInsert.html" title="class in org.apache.calcite.sql">SqlInsert</a>&nbsp;call,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;sourceRef,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;targetColumnNames,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;columnExprs)</span></div>
<div class="block">Given an INSERT statement, collects the list of names to be populated and
 the expressions to put in them.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - Insert statement</dd>
<dd><code>sourceRef</code> - Expression representing a row from the source
                          relational expression</dd>
<dd><code>targetColumnNames</code> - List of target column names, to be populated</dd>
<dd><code>columnExprs</code> - List of expressions, to be populated</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="adjustInputRef(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.rex.RexInputRef)">
<h3>adjustInputRef</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">adjustInputRef</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../rex/RexInputRef.html" title="class in org.apache.calcite.rex">RexInputRef</a>&nbsp;inputRef)</span></div>
<div class="block">Adjusts the type of a reference to an input field to account for nulls
 introduced by outer joins; and adjusts the offset to match the physical
 implementation.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Blackboard</dd>
<dd><code>inputRef</code> - Input ref</dd>
<dt>Returns:</dt>
<dd>Adjusted input ref</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="extraSelectItems(org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard,org.apache.calcite.sql.SqlSelect,java.util.List,java.util.List,java.util.Collection,java.util.List)">
<h3>extraSelectItems</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">extraSelectItems</span><wbr><span class="parameters">(<a href="SqlToRelConverter.Blackboard.html" title="class in org.apache.calcite.sql2rel">SqlToRelConverter.Blackboard</a>&nbsp;bb,
 <a href="../sql/SqlSelect.html" title="class in org.apache.calcite.sql">SqlSelect</a>&nbsp;select,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;nameList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;aliasList,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/validate/SqlMonotonicity.html" title="enum in org.apache.calcite.sql.validate">SqlMonotonicity</a>&gt;&nbsp;columnMonotonicityList)</span></div>
<div class="block">Adds extra select items. The default implementation adds nothing; derived
 classes may add columns to exprList, nameList, aliasList and
 columnMonotonicityList.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bb</code> - Blackboard</dd>
<dd><code>select</code> - Select statement being translated</dd>
<dd><code>exprList</code> - List of expressions in select clause</dd>
<dd><code>nameList</code> - List of names, one per column</dd>
<dd><code>aliasList</code> - Collection of aliases that have been used
                               already</dd>
<dd><code>columnMonotonicityList</code> - List of monotonicity, one per column</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertWith(org.apache.calcite.sql.SqlWith,boolean)">
<h3>convertWith</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelRoot.html" title="class in org.apache.calcite.rel">RelRoot</a></span>&nbsp;<span class="element-name">convertWith</span><wbr><span class="parameters">(<a href="../sql/SqlWith.html" title="class in org.apache.calcite.sql">SqlWith</a>&nbsp;with,
 boolean&nbsp;top)</span></div>
<div class="block">Converts a WITH sub-query into a relational expression.</div>
</section>
</li>
<li>
<section class="detail" id="convertValues(org.apache.calcite.sql.SqlCall,org.apache.calcite.rel.type.RelDataType)">
<h3>convertValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">convertValues</span><wbr><span class="parameters">(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;values,
 @Nullable <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType)</span></div>
<div class="block">Converts a SELECT statement's parse tree into a relational expression.</div>
</section>
</li>
<li>
<section class="detail" id="config()">
<h3>config</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel">SqlToRelConverter.Config</a></span>&nbsp;<span class="element-name">config</span>()</div>
<div class="block">Returns a default <a href="SqlToRelConverter.Config.html" title="interface in org.apache.calcite.sql2rel"><code>SqlToRelConverter.Config</code></a>.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
