<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>RelOptUtil (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.plan, class: RelOptUtil">
<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.plan</a></div>
<h1 title="Class RelOptUtil" class="title">Class RelOptUtil</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.plan.RelOptUtil</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">RelOptUtil</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block"><code>RelOptUtil</code> defines static utility methods for use in optimizing
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a>s.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="RelOptUtil.Exists.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.Exists</a></code></div>
<div class="col-last even-row-color">
<div class="block">Result of calling
 <a href="#createExistsPlan(org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rex.RexLiteral,java.lang.String)"><code>createExistsPlan(org.apache.calcite.plan.RelOptCluster, org.apache.calcite.rel.RelNode, java.util.List&lt;org.apache.calcite.rex.RexNode&gt;, org.apache.calcite.rex.RexLiteral, java.lang.String)</code></a>.</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="RelOptUtil.InputFinder.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.InputFinder</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Visitor which builds a bitmap of the inputs used by an expression.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="RelOptUtil.InputReferencedVisitor.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.InputReferencedVisitor</a></code></div>
<div class="col-last even-row-color">
<div class="block">Shuttle that finds the set of inputs that are used.</div>
</div>
<div class="col-first odd-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="RelOptUtil.Logic.html" class="type-name-link" title="enum in org.apache.calcite.plan">RelOptUtil.Logic</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Policies for handling two- and three-valued boolean logic.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="RelOptUtil.RexInputConverter.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.RexInputConverter</a></code></div>
<div class="col-last even-row-color">
<div class="block">Walks an expression tree, converting the index of RexInputRefs based on
 some adjustment factor.</div>
</div>
<div class="col-first odd-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="RelOptUtil.SubQueryType.html" class="type-name-link" title="enum in org.apache.calcite.plan">RelOptUtil.SubQueryType</a></code></div>
<div class="col-last odd-row-color">
<div class="block">What kind of sub-query.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="RelOptUtil.TypeDumper.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.TypeDumper</a></code></div>
<div class="col-last even-row-color">
<div class="block">Converts types to descriptive strings.</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="RelOptUtil.VariableUsedVisitor.html" class="type-name-link" title="class in org.apache.calcite.plan">RelOptUtil.VariableUsedVisitor</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Visitor that finds all variables used in an expression.</div>
</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final com.google.common.base.Predicate&lt;<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#CALC_PREDICATE" class="member-name-link">CALC_PREDICATE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final double</code></div>
<div class="col-second odd-row-color"><code><a href="#EPSILON" class="member-name-link">EPSILON</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final com.google.common.base.Predicate&lt;<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#FILTER_PREDICATE" class="member-name-link">FILTER_PREDICATE</a></code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color"><code>static final com.google.common.base.Predicate&lt;<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#PROJECT_PREDICATE" class="member-name-link">PROJECT_PREDICATE</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</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()" class="member-name-link">RelOptUtil</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addTrait(T,org.apache.calcite.plan.RelTrait)" class="member-name-link">addTrait</a><wbr>(T&nbsp;rel,
 <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#adjustKeys(java.util.List,int)" class="member-name-link">adjustKeys</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;keys,
 int&nbsp;adjustment)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Adjusts key values in a list by some fixed amount.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#analyzeSimpleEquiJoin(org.apache.calcite.rel.logical.LogicalJoin,int%5B%5D)" class="member-name-link">analyzeSimpleEquiJoin</a><wbr>(<a href="../rel/logical/LogicalJoin.html" title="class in org.apache.calcite.rel.logical">LogicalJoin</a>&nbsp;join,
 int[]&nbsp;joinFieldOrdinals)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#andJoinFilters(org.apache.calcite.rex.RexBuilder,org.apache.calcite.rex.RexNode,org.apache.calcite.rex.RexNode)" class="member-name-link">andJoinFilters</a><wbr>(<a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;left,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;right)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Ands two sets of join filters together, either of which can be null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#areRowTypesEqual(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,boolean)" class="member-name-link">areRowTypesEqual</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType2,
 boolean&nbsp;compareNames)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#checkProjAndChildInputs(org.apache.calcite.rel.core.Project,boolean)" class="member-name-link">checkProjAndChildInputs</a><wbr>(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 boolean&nbsp;checkNames)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)" class="member-name-link">classifyFilters</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 boolean&nbsp;pushInto,
 boolean&nbsp;pushLeft,
 boolean&nbsp;pushRight,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightFilters)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Classifies filters according to where they should be processed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rel.core.JoinRelType,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)" class="member-name-link">classifyFilters</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType,
 boolean&nbsp;pushInto,
 boolean&nbsp;pushLeft,
 boolean&nbsp;pushRight,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightFilters)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use
 <a href="#classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)"><code>classifyFilters(RelNode, List, boolean, boolean, boolean, List, List, List)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#collapseExpandedIsNotDistinctFromExpr(org.apache.calcite.rex.RexCall,org.apache.calcite.rex.RexBuilder)" class="member-name-link">collapseExpandedIsNotDistinctFromExpr</a><wbr>(<a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a>&nbsp;call,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Collapses an expanded version of <code>IS NOT DISTINCT FROM</code> expression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../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-tab1 method-summary-table-tab4"><code><a href="#conjunctions(org.apache.calcite.rex.RexNode)" class="member-name-link">conjunctions</a><wbr>(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a condition decomposed by AND.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#contains(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">contains</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;ancestor,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;target)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether relational expression <code>target</code> occurs within a
 relational expression <code>ancestor</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#copyRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">copyRelHints</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#copyRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,boolean)" class="member-name-link">copyRelHints</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel,
 boolean&nbsp;filterHints)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#correlationColumns(org.apache.calcite.rel.core.CorrelationId,org.apache.calcite.rel.RelNode)" class="member-name-link">correlationColumns</a><wbr>(<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&nbsp;id,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Finds which columns of a correlation variable are used within a
 relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#countJoins(org.apache.calcite.rel.RelNode)" class="member-name-link">countJoins</a><wbr>(<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-tab1 method-summary-table-tab4">
<div class="block">Returns the number of <a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core"><code>Join</code></a> nodes in a
 tree.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#createCastRel(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType,boolean)" class="member-name-link">createCastRel</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;castRowType,
 boolean&nbsp;rename)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a projection which casts a rel's output to a desired row type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#createCastRel(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType,boolean,org.apache.calcite.rel.core.RelFactories.ProjectFactory)" class="member-name-link">createCastRel</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;castRowType,
 boolean&nbsp;rename,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a projection which casts a rel's output to a desired row type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createDistinctRel(org.apache.calcite.rel.RelNode)" class="member-name-link">createDistinctRel</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../tools/RelBuilder.html#distinct()"><code>RelBuilder.distinct()</code></a>.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createDmlRowType(org.apache.calcite.sql.SqlKind,org.apache.calcite.rel.type.RelDataTypeFactory)" class="member-name-link">createDmlRowType</a><wbr>(<a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind,
 <a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates the row type descriptor for the result of a DML operation, which
 is a single column named ROWCOUNT of type BIGINT for INSERT;
 a single column named PLAN for EXPLAIN.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#createEquiJoinCondition(org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rex.RexBuilder)" class="member-name-link">createEquiJoinCondition</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Builds an equi-join condition from a set of left and right keys.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createExistsPlan(org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rex.RexLiteral,java.lang.String)" class="member-name-link">createExistsPlan</a><wbr>(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions,
 @Nullable <a href="../rex/RexLiteral.html" title="class in org.apache.calcite.rex">RexLiteral</a>&nbsp;extraExpr,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;extraName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="RelOptUtil.Exists.html" title="class in org.apache.calcite.plan">RelOptUtil.Exists</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createExistsPlan(org.apache.calcite.rel.RelNode,org.apache.calcite.plan.RelOptUtil.SubQueryType,org.apache.calcite.plan.RelOptUtil.Logic,boolean)" class="member-name-link">createExistsPlan</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 <a href="RelOptUtil.SubQueryType.html" title="enum in org.apache.calcite.plan">RelOptUtil.SubQueryType</a>&nbsp;subQueryType,
 <a href="RelOptUtil.Logic.html" title="enum in org.apache.calcite.plan">RelOptUtil.Logic</a>&nbsp;logic,
 boolean&nbsp;notIn)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="RelOptUtil.Exists.html" title="class in org.apache.calcite.plan">RelOptUtil.Exists</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createExistsPlan(org.apache.calcite.rel.RelNode,org.apache.calcite.plan.RelOptUtil.SubQueryType,org.apache.calcite.plan.RelOptUtil.Logic,boolean,org.apache.calcite.tools.RelBuilder)" class="member-name-link">createExistsPlan</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 <a href="RelOptUtil.SubQueryType.html" title="enum in org.apache.calcite.plan">RelOptUtil.SubQueryType</a>&nbsp;subQueryType,
 <a href="RelOptUtil.Logic.html" title="enum in org.apache.calcite.plan">RelOptUtil.Logic</a>&nbsp;logic,
 boolean&nbsp;notIn,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a plan suitable for use in <code>EXISTS</code> or <code>IN</code>
 statements.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#createFilter(org.apache.calcite.rel.RelNode,java.lang.Iterable)" class="member-name-link">createFilter</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a filter, using the default filter factory,
 or returns the original relational expression if the
 condition is trivial.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/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-tab1 method-summary-table-tab4"><code><a href="#createFilter(org.apache.calcite.rel.RelNode,java.lang.Iterable,org.apache.calcite.rel.core.RelFactories.FilterFactory)" class="member-name-link">createFilter</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a filter using the default factory,
 or returns the original relational expression if the
 condition is trivial.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createFilter(org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode)" class="member-name-link">createFilter</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createFilter(org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.RelFactories.FilterFactory)" class="member-name-link">createFilter</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createNullFilter(org.apache.calcite.rel.RelNode,java.lang.Integer%5B%5D)" class="member-name-link">createNullFilter</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>[]&nbsp;fieldOrdinals)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#createProject(org.apache.calcite.rel.core.RelFactories.ProjectFactory,org.apache.calcite.rel.RelNode,java.util.List)" class="member-name-link">createProject</a><wbr>(<a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;factory,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;posList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a relational expression that projects the given fields of the
 input.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List,boolean)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 boolean&nbsp;optimize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List,boolean,org.apache.calcite.tools.RelBuilder)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 boolean&nbsp;optimize,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use
 <a href="../tools/RelBuilder.html#projectNamed(java.lang.Iterable,java.lang.Iterable,boolean)"><code>RelBuilder.projectNamed(Iterable, Iterable, boolean)</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#createProject(org.apache.calcite.rel.RelNode,java.util.List)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;posList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a relational expression that projects the given fields of the
 input.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createProject(org.apache.calcite.rel.RelNode,java.util.List,boolean)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>,<wbr>? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&gt;&nbsp;projectList,
 boolean&nbsp;optimize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#createProject(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mappings.TargetMapping)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="../rel/logical/LogicalProject.html" title="class in org.apache.calcite.rel.logical"><code>LogicalProject</code></a> that
 projects particular fields of its input, according to a mapping.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#createProject(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.rel.core.RelFactories.ProjectFactory)" class="member-name-link">createProject</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createProjectJoinRel(java.util.List,org.apache.calcite.rel.RelNode)" class="member-name-link">createProjectJoinRel</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;outputProj,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createRename(org.apache.calcite.rel.RelNode,java.util.List)" class="member-name-link">createRename</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#createRenameRel(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.RelNode)" class="member-name-link">createRenameRel</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;outputType,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#createSingleValueAggRel(org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.RelNode)" class="member-name-link">createSingleValueAggRel</a><wbr>(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a LogicalAggregate that removes all duplicates from the result of
 an underlying relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createSwappedJoinExprs(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.core.Join,boolean)" class="member-name-link">createSwappedJoinExprs</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newJoin,
 <a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;origJoin,
 boolean&nbsp;origOrder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates projection expressions reflecting the swapping of a join's input.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#decomposeConjunction(org.apache.calcite.rex.RexNode,java.util.List)" class="member-name-link">decomposeConjunction</a><wbr>(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Decomposes a predicate into a list of expressions that are AND'ed
 together.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#decomposeConjunction(org.apache.calcite.rex.RexNode,java.util.List,java.util.List)" class="member-name-link">decomposeConjunction</a><wbr>(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;notList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Decomposes a predicate into a list of expressions that are AND'ed
 together, and a list of expressions that are preceded by NOT.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#decomposeDisjunction(org.apache.calcite.rex.RexNode,java.util.List)" class="member-name-link">decomposeDisjunction</a><wbr>(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Decomposes a predicate into a list of expressions that are OR'ed
 together.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#deduplicateColumns(java.util.List,java.util.List)" class="member-name-link">deduplicateColumns</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;baseColumns,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extendedColumns)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the set of columns with unique names, with prior columns taking
 precedence over columns that appear later in the list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../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-tab1 method-summary-table-tab4"><code><a href="#disjunctions(org.apache.calcite.rex.RexNode)" class="member-name-link">disjunctions</a><wbr>(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a condition decomposed by OR.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#dumpPlan(java.lang.String,org.apache.calcite.rel.RelNode,boolean,org.apache.calcite.sql.SqlExplainLevel)" class="member-name-link">dumpPlan</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;header,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 boolean&nbsp;asXml,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dumpPlan(java.lang.String,org.apache.calcite.rel.RelNode,org.apache.calcite.sql.SqlExplainFormat,org.apache.calcite.sql.SqlExplainLevel)" class="member-name-link">dumpPlan</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;header,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../sql/SqlExplainFormat.html" title="enum in org.apache.calcite.sql">SqlExplainFormat</a>&nbsp;format,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Dumps a plan as a string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dumpType(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">dumpType</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#eq(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.Litmus)" class="member-name-link">eq</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc2,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type2,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether two types are equal using 'equals'.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#equal(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.Litmus)" class="member-name-link">equal</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc2,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type2,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether two types are equal using
 <a href="#areRowTypesEqual(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,boolean)"><code>areRowTypesEqual(RelDataType, RelDataType, boolean)</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#equalType(java.lang.String,org.apache.calcite.rel.RelNode,java.lang.String,org.apache.calcite.rel.RelNode,org.apache.calcite.util.Litmus)" class="member-name-link">equalType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc0,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel1,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether two relational expressions have the same row-type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findAllTableQualifiedNames(org.apache.calcite.rel.RelNode)" class="member-name-link">findAllTableQualifiedNames</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</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 list of all table qualified names used by this expression
 or its children.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findAllTables(org.apache.calcite.rel.RelNode)" class="member-name-link">findAllTables</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a list of all tables used by this expression or its children.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findTables(org.apache.calcite.rel.RelNode)" class="member-name-link">findTables</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</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 set of tables used by this expression or its children.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getAllFields(org.apache.calcite.rel.core.Aggregate)" class="member-name-link">getAllFields</a><wbr>(<a href="../rel/core/Aggregate.html" title="class in org.apache.calcite.rel.core">Aggregate</a>&nbsp;aggregate)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets all fields in an aggregate.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getAllFields2(org.apache.calcite.util.ImmutableBitSet,java.util.List)" class="member-name-link">getAllFields2</a><wbr>(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;groupSet,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/AggregateCall.html" title="class in org.apache.calcite.rel.core">AggregateCall</a>&gt;&nbsp;aggCallList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets all fields in an aggregate.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</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-tab1 method-summary-table-tab4"><code><a href="#getColumnConstraints(org.apache.calcite.schema.ModifiableView,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataTypeFactory)" class="member-name-link">getColumnConstraints</a><wbr>(<a href="../schema/ModifiableView.html" title="interface in org.apache.calcite.schema">ModifiableView</a>&nbsp;modifiableViewTable,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType,
 <a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a mapping of the column ordinal in the underlying table to a column
 constraint of the modifiable view.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="RelOptTable.ToRelContext.html" title="interface in org.apache.calcite.plan">RelOptTable.ToRelContext</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getContext(org.apache.calcite.plan.RelOptCluster)" class="member-name-link">getContext</a><wbr>(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getFieldTypeList(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">getFieldTypeList</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a list of the types of the fields in a given struct type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getFullTypeDifferenceString(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">getFullTypeDifferenceString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sourceDesc,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetDesc,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the detailed difference of two types.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getVariablesSet(org.apache.calcite.rel.RelNode)" class="member-name-link">getVariablesSet</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a list of variables set by a relational expression or its
 descendants.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getVariablesSetAndUsed(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">getVariablesSetAndUsed</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel0,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getVariablesUsed(org.apache.calcite.rel.RelNode)" class="member-name-link">getVariablesUsed</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a set of variables used by a relational expression or its
 descendants.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#go(org.apache.calcite.rel.RelVisitor,org.apache.calcite.rel.RelNode)" class="member-name-link">go</a><wbr>(<a href="../rel/RelVisitor.html" title="class in org.apache.calcite.rel">RelVisitor</a>&nbsp;visitor,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;p)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Sets a <a href="../rel/RelVisitor.html" title="class in org.apache.calcite.rel"><code>RelVisitor</code></a> going on a given relational expression, and
 returns the result.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#inferViewPredicates(java.util.Map,java.util.List,org.apache.calcite.rex.RexNode)" class="member-name-link">inferViewPredicates</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;projectMap,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;constraint)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Decomposes the WHERE clause of a view into predicates that constraint
 a column to a particular value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#isDistinctFrom(org.apache.calcite.rex.RexBuilder,org.apache.calcite.rex.RexNode,org.apache.calcite.rex.RexNode,boolean)" class="member-name-link">isDistinctFrom</a><wbr>(<a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;x,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;y,
 boolean&nbsp;neg)</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 translation of the <code>IS DISTINCT FROM</code> (or <code>IS
 NOT DISTINCT FROM</code>) sql operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#isEqui(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode)" class="member-name-link">isEqui</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isLimit(org.apache.calcite.rel.RelNode)" class="member-name-link">isLimit</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Whether this node contains a limit specification.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isOrder(org.apache.calcite.rel.RelNode)" class="member-name-link">isOrder</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Whether this node contains a sort specification.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isPureLimit(org.apache.calcite.rel.RelNode)" class="member-name-link">isPureLimit</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Whether this node is a limit without sort specification.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isPureOrder(org.apache.calcite.rel.RelNode)" class="member-name-link">isPureOrder</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Whether this node is a sort without limit specification.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notContainsCorrelation(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.core.CorrelationId,org.apache.calcite.util.Litmus)" class="member-name-link">notContainsCorrelation</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;r,
 <a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&nbsp;correlationId,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true, and calls <a href="../util/Litmus.html#succeed()"><code>Litmus.succeed()</code></a> if a given relational
 expression does not contain a given correlation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notContainsWindowedAgg(org.apache.calcite.rel.core.Calc)" class="member-name-link">notContainsWindowedAgg</a><wbr>(<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Predicate for if a <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core"><code>Calc</code></a> does not contain windowed aggregates.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notContainsWindowedAgg(org.apache.calcite.rel.core.Filter)" class="member-name-link">notContainsWindowedAgg</a><wbr>(<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&nbsp;filter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Predicate for if a <a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core"><code>Filter</code></a> does not windowed aggregates.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notContainsWindowedAgg(org.apache.calcite.rel.core.Project)" class="member-name-link">notContainsWindowedAgg</a><wbr>(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Predicate for if a <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> does not contain windowed aggregates.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#op(org.apache.calcite.sql.SqlKind,org.apache.calcite.sql.SqlOperator)" class="member-name-link">op</a><wbr>(<a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind,
 <a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator)</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 href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql"><code>SqlOperator</code></a> for given <a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql"><code>SqlKind</code></a> or returns <code>operator</code>
 when <a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql"><code>SqlKind</code></a> is not known.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#permutation(java.util.List,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">permutation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a permutation describing where output fields come from.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#permutationIgnoreCast(java.util.List,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">permutationIgnoreCast</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType)</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 permutation describing where output fields come from.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#permutationPushDownProject(java.util.List,org.apache.calcite.rel.type.RelDataType,int,int)" class="member-name-link">permutationPushDownProject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType,
 int&nbsp;sourceOffset,
 int&nbsp;targetOffset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a permutation describing where the Project's fields come from
 after the Project is pushed down.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/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-tab1 method-summary-table-tab4"><code><a href="#permute(org.apache.calcite.rel.RelNode,org.apache.calcite.util.Permutation,java.util.List)" class="member-name-link">permute</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/Permutation.html" title="class in org.apache.calcite.util">Permutation</a>&nbsp;permutation,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a relational expression which permutes the output fields of a
 relational expression according to a permutation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#permute(org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.mapping.Mapping)" class="member-name-link">permute</a><wbr>(<a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Permutes a record type according to a mapping.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#projectJoinInputs(org.apache.calcite.rel.RelNode%5B%5D,java.util.List,java.util.List,int,java.util.List,java.util.List,java.util.List)" class="member-name-link">projectJoinInputs</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>[]&nbsp;inputRels,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftJoinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightJoinKeys,
 int&nbsp;systemColCount,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;outputProj)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#projectMapping(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping,java.util.List,org.apache.calcite.rel.core.RelFactories.ProjectFactory)" class="member-name-link">projectMapping</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules">MultiJoin</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#projectMultiJoin(org.apache.calcite.rel.rules.MultiJoin,org.apache.calcite.rel.core.Project)" class="member-name-link">projectMultiJoin</a><wbr>(<a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules">MultiJoin</a>&nbsp;multiJoin,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a new <a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules"><code>MultiJoin</code></a> to reflect
 projection references from a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> that is on top of the
 <a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules"><code>MultiJoin</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#propagateRelHints(org.apache.calcite.rel.RelNode,boolean)" class="member-name-link">propagateRelHints</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 boolean&nbsp;reset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Propagates the relational expression hints from root node to leaf node.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/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-tab1 method-summary-table-tab4"><code><a href="#propagateRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">propagateRelHints</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;equiv)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#pushDownJoinConditions(org.apache.calcite.rel.core.Join)" class="member-name-link">pushDownJoinConditions</a><wbr>(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#pushDownJoinConditions(org.apache.calcite.rel.core.Join,org.apache.calcite.rel.core.RelFactories.ProjectFactory)" class="member-name-link">pushDownJoinConditions</a><wbr>(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#pushDownJoinConditions(org.apache.calcite.rel.core.Join,org.apache.calcite.tools.RelBuilder)" class="member-name-link">pushDownJoinConditions</a><wbr>(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Pushes down expressions in "equal" join condition.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="../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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#pushFilterPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)" class="member-name-link">pushFilterPastProject</a><wbr>(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;filter,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;projRel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#pushPastCalc(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Calc)" class="member-name-link">pushPastCalc</a><wbr>(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;node,
 <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an expression that is based on the output fields of a
 <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core"><code>Calc</code></a> to an equivalent expression on the Calc's input fields.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#pushPastProject(java.util.List,org.apache.calcite.rel.core.Project)" class="member-name-link">pushPastProject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list of expressions that are based on the output fields of a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> to equivalent expressions on the Project's
 input fields.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#pushPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)" class="member-name-link">pushPastProject</a><wbr>(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;node,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an expression that is based on the output fields of a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> to an equivalent expression on the Project's
 input fields.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#pushPastProjectUnlessBloat(java.util.List,org.apache.calcite.rel.core.Project,int)" class="member-name-link">pushPastProjectUnlessBloat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 int&nbsp;bloat)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As <a href="#pushPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)"><code>pushPastProject(org.apache.calcite.rex.RexNode, org.apache.calcite.rel.core.Project)</code></a>, but returns null if the resulting expressions
 are significantly more complex.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#registerAbstractRelationalRules(org.apache.calcite.plan.RelOptPlanner)" class="member-name-link">registerAbstractRelationalRules</a><wbr>(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#registerAbstractRels(org.apache.calcite.plan.RelOptPlanner)" class="member-name-link">registerAbstractRels</a><wbr>(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#registerAbstractRules(org.apache.calcite.plan.RelOptPlanner)" class="member-name-link">registerAbstractRules</a><wbr>(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#registerDefaultRules(org.apache.calcite.plan.RelOptPlanner,boolean,boolean)" class="member-name-link">registerDefaultRules</a><wbr>(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner,
 boolean&nbsp;enableMaterializations,
 boolean&nbsp;enableBindable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#renameIfNecessary(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType)" class="member-name-link">renameIfNecessary</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;desiredRowType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#replace(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">replace</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;find,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;replace)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Within a relational expression <code>query</code>, replaces occurrences of
 <code>find</code> with <code>replace</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../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-tab1 method-summary-table-tab4"><code><a href="#replaceInput(org.apache.calcite.rel.RelNode,int,org.apache.calcite.rel.RelNode)" class="member-name-link">replaceInput</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;parent,
 int&nbsp;ordinal,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newInput)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a shallow copy of a relational expression with a particular
 input replaced.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#simplifyJoin(org.apache.calcite.rel.RelNode,com.google.common.collect.ImmutableList,org.apache.calcite.rel.core.JoinRelType)" class="member-name-link">simplifyJoin</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 com.google.common.collect.ImmutableList&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;aboveFilters,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Simplifies outer joins if filter above would reject nulls.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="../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-tab1 method-summary-table-tab4"><code><a href="#splitCorrelatedFilterCondition(org.apache.calcite.rel.core.Filter,java.util.List,java.util.List,boolean)" class="member-name-link">splitCorrelatedFilterCondition</a><wbr>(<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys,
 boolean&nbsp;extractCorrelatedFieldAccess)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static @Nullable <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-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#splitCorrelatedFilterCondition(org.apache.calcite.rel.logical.LogicalFilter,java.util.List,java.util.List)" class="member-name-link">splitCorrelatedFilterCondition</a><wbr>(<a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical">LogicalFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexInputRef.html" title="class in org.apache.calcite.rex">RexInputRef</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @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-tab1 method-summary-table-tab4"><code><a href="#splitCorrelatedFilterCondition(org.apache.calcite.rel.logical.LogicalFilter,java.util.List,java.util.List,boolean)" class="member-name-link">splitCorrelatedFilterCondition</a><wbr>(<a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical">LogicalFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys,
 boolean&nbsp;extractCorrelatedFieldAccess)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#splitFilters(org.apache.calcite.util.ImmutableBitSet,org.apache.calcite.rex.RexNode,java.util.List,java.util.List)" class="member-name-link">splitFilters</a><wbr>(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;childBitmap,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;predicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;pushable,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;notPushable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Splits a filter into two lists, depending on whether or not the filter
 only references its child input.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#splitJoinCondition(java.util.List,java.util.List,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)" class="member-name-link">splitJoinCondition</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sysFieldList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&gt;&nbsp;inputs,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/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;&gt;&nbsp;joinKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;filterNulls,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;&nbsp;rangeOp)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Splits out the equi-join (and optionally, a single non-equi) components
 of a join condition, and returns what's left.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#splitJoinCondition(java.util.List,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List,java.util.List)" class="member-name-link">splitJoinCondition</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sysFieldList,
 <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;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftJoinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightJoinKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;filterNulls,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;&nbsp;rangeOp)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Splits out the equi-join (and optionally, a single non-equi) components
 of a join condition, and returns what's left.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <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-tab1 method-summary-table-tab4"><code><a href="#splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)" class="member-name-link">splitJoinCondition</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;&nbsp;filterNulls)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Splits out the equi-join components of a join condition, and returns
 what's left.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List,java.util.List)" class="member-name-link">splitJoinCondition</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;&nbsp;filterNulls,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nonEquiList)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As
 <a href="#splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)"><code>splitJoinCondition(RelNode, RelNode, RexNode, List, List, List)</code></a>,
 but writes non-equi conditions to a conjunctive list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(org.apache.calcite.rel.RelNode,org.apache.calcite.sql.SqlExplainLevel)" class="member-name-link">toString</a><wbr>(@PolyNull <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a relational expression to a string;
 returns null if and only if <code>rel</code> is null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(org.apache.calcite.rel.RelNode)" class="member-name-link">toString</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a relational expression to a string, showing just basic
 attributes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#validateValueAgainstConstraint(org.apache.calcite.sql.SqlNode,org.apache.calcite.rex.RexNode,java.util.function.Supplier)" class="member-name-link">validateValueAgainstConstraint</a><wbr>(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;sourceValue,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;targetConstraint,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;<a href="../runtime/CalciteContextException.html" title="class in org.apache.calcite.runtime">CalciteContextException</a>&gt;&nbsp;errorSupplier)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Ensures that a source value does not violate the constraint of the target
 column.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#verifyTypeEquivalence(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,java.lang.Object)" class="member-name-link">verifyTypeEquivalence</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;equivalenceClass)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Verifies that a row type being added to an equivalence class matches the
 existing type, raising an assertion if this is not the case.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="EPSILON">
<h3>EPSILON</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">EPSILON</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.calcite.plan.RelOptUtil.EPSILON">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="FILTER_PREDICATE">
<h3>FILTER_PREDICATE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type">com.google.common.base.Predicate&lt;<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&gt;</span>&nbsp;<span class="element-name">FILTER_PREDICATE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="PROJECT_PREDICATE">
<h3>PROJECT_PREDICATE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type">com.google.common.base.Predicate&lt;<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&gt;</span>&nbsp;<span class="element-name">PROJECT_PREDICATE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="CALC_PREDICATE">
<h3>CALC_PREDICATE</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static final</span>&nbsp;<span class="return-type">com.google.common.base.Predicate&lt;<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&gt;</span>&nbsp;<span class="element-name">CALC_PREDICATE</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</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;()">
<h3>RelOptUtil</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">RelOptUtil</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="isPureLimit(org.apache.calcite.rel.RelNode)">
<h3>isPureLimit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isPureLimit</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Whether this node is a limit without sort specification.</div>
</section>
</li>
<li>
<section class="detail" id="isPureOrder(org.apache.calcite.rel.RelNode)">
<h3>isPureOrder</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isPureOrder</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Whether this node is a sort without limit specification.</div>
</section>
</li>
<li>
<section class="detail" id="isLimit(org.apache.calcite.rel.RelNode)">
<h3>isLimit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isLimit</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Whether this node contains a limit specification.</div>
</section>
</li>
<li>
<section class="detail" id="isOrder(org.apache.calcite.rel.RelNode)">
<h3>isOrder</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isOrder</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Whether this node contains a sort specification.</div>
</section>
</li>
<li>
<section class="detail" id="findTables(org.apache.calcite.rel.RelNode)">
<h3>findTables</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&gt;</span>&nbsp;<span class="element-name">findTables</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Returns a set of tables used by this expression or its children.</div>
</section>
</li>
<li>
<section class="detail" id="findAllTables(org.apache.calcite.rel.RelNode)">
<h3>findAllTables</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="RelOptTable.html" title="interface in org.apache.calcite.plan">RelOptTable</a>&gt;</span>&nbsp;<span class="element-name">findAllTables</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Returns a list of all tables used by this expression or its children.</div>
</section>
</li>
<li>
<section class="detail" id="findAllTableQualifiedNames(org.apache.calcite.rel.RelNode)">
<h3>findAllTableQualifiedNames</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">findAllTableQualifiedNames</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Returns a list of all table qualified names used by this expression
 or its children.</div>
</section>
</li>
<li>
<section class="detail" id="getVariablesSet(org.apache.calcite.rel.RelNode)">
<h3>getVariablesSet</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</span>&nbsp;<span class="element-name">getVariablesSet</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Returns a list of variables set by a relational expression or its
 descendants.</div>
</section>
</li>
<li>
<section class="detail" id="getVariablesSetAndUsed(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>getVariablesSetAndUsed</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</span>&nbsp;<span class="element-name">getVariablesSetAndUsed</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel0,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel1)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="getVariablesUsed(org.apache.calcite.rel.RelNode)">
<h3>getVariablesUsed</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&gt;</span>&nbsp;<span class="element-name">getVariablesUsed</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Returns a set of variables used by a relational expression or its
 descendants.

 <p>The set may contain "duplicates" (variables with different ids that,
 when resolved, will reference the same source relational expression).

 <p>The item type is the same as
 <a href="../rex/RexCorrelVariable.html#id"><code>RexCorrelVariable.id</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="correlationColumns(org.apache.calcite.rel.core.CorrelationId,org.apache.calcite.rel.RelNode)">
<h3>correlationColumns</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a></span>&nbsp;<span class="element-name">correlationColumns</span><wbr><span class="parameters">(<a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&nbsp;id,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Finds which columns of a correlation variable are used within a
 relational expression.</div>
</section>
</li>
<li>
<section class="detail" id="notContainsCorrelation(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.core.CorrelationId,org.apache.calcite.util.Litmus)">
<h3>notContainsCorrelation</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notContainsCorrelation</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;r,
 <a href="../rel/core/CorrelationId.html" title="class in org.apache.calcite.rel.core">CorrelationId</a>&nbsp;correlationId,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</span></div>
<div class="block">Returns true, and calls <a href="../util/Litmus.html#succeed()"><code>Litmus.succeed()</code></a> if a given relational
 expression does not contain a given correlation.</div>
</section>
</li>
<li>
<section class="detail" id="go(org.apache.calcite.rel.RelVisitor,org.apache.calcite.rel.RelNode)">
<h3>go</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">go</span><wbr><span class="parameters">(<a href="../rel/RelVisitor.html" title="class in org.apache.calcite.rel">RelVisitor</a>&nbsp;visitor,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;p)</span></div>
<div class="block">Sets a <a href="../rel/RelVisitor.html" title="class in org.apache.calcite.rel"><code>RelVisitor</code></a> going on a given relational expression, and
 returns the result.</div>
</section>
</li>
<li>
<section class="detail" id="getFieldTypeList(org.apache.calcite.rel.type.RelDataType)">
<h3>getFieldTypeList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;</span>&nbsp;<span class="element-name">getFieldTypeList</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</span></div>
<div class="block">Returns a list of the types of the fields in a given struct type. The
 list is immutable.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Struct type</dd>
<dt>Returns:</dt>
<dd>List of field types</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../rel/type/RelDataType.html#getFieldNames()"><code>RelDataType.getFieldNames()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="areRowTypesEqual(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,boolean)">
<h3>areRowTypesEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">areRowTypesEqual</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType2,
 boolean&nbsp;compareNames)</span></div>
</section>
</li>
<li>
<section class="detail" id="verifyTypeEquivalence(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,java.lang.Object)">
<h3>verifyTypeEquivalence</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">verifyTypeEquivalence</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;equivalenceClass)</span></div>
<div class="block">Verifies that a row type being added to an equivalence class matches the
 existing type, raising an assertion if this is not the case.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>originalRel</code> - canonical rel for equivalence class</dd>
<dd><code>newRel</code> - rel being added to equivalence class</dd>
<dd><code>equivalenceClass</code> - object representing equivalence class</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="propagateRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>propagateRelHints</h3>
<div class="member-signature"><span class="modifiers">public static</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">propagateRelHints</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;equiv)</span></div>
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.

 <p>The two relational expressions are assumed as semantically equivalent,
 that means the hints should be attached to the relational expression
 that expects to have them.

 <p>Try to propagate the hints to the first relational expression that matches,
 this is needed because many planner rules would generate a sub-tree whose
 root rel type is different with the original matched rel.

 <p>For the worst case, there is no relational expression that can apply these hints,
 and the whole sub-tree would be visited. We add a protection here:
 if the visiting depth is over than 3, just returns, because there are rare cases
 the new created sub-tree has layers bigger than that.

 <p>This is a best effort, we do not know exactly how the nodes are transformed
 in all kinds of planner rules, so for some complex relational expressions,
 the hints would very probably lost.

 <p>This function is experimental and would change without any notes.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>originalRel</code> - Original relational expression</dd>
<dd><code>equiv</code> - New equivalent relational expression</dd>
<dt>Returns:</dt>
<dd>A copy of <code>newRel</code> with attached qualified hints from <code>originalRel</code>,
 or <code>newRel</code> directly if one of them are not <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="propagateRelHints(org.apache.calcite.rel.RelNode,boolean)">
<h3>propagateRelHints</h3>
<div class="member-signature"><span class="modifiers">public static</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">propagateRelHints</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 boolean&nbsp;reset)</span></div>
<div class="block">Propagates the relational expression hints from root node to leaf node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - The relational expression</dd>
<dd><code>reset</code> - Flag saying if to reset the existing hints before the propagation</dd>
<dt>Returns:</dt>
<dd>New relational expression with hints propagated</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>copyRelHints</h3>
<div class="member-signature"><span class="modifiers">public static</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">copyRelHints</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel)</span></div>
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.

 <p>The hints would be attached directly(e.g. without any filtering).</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>originalRel</code> - Original relational expression</dd>
<dd><code>newRel</code> - New relational expression</dd>
<dt>Returns:</dt>
<dd>A copy of <code>newRel</code> with attached hints from <code>originalRel</code>,
 or <code>newRel</code> directly if one of them are not <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyRelHints(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,boolean)">
<h3>copyRelHints</h3>
<div class="member-signature"><span class="modifiers">public static</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">copyRelHints</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newRel,
 boolean&nbsp;filterHints)</span></div>
<div class="block">Copy the <a href="../rel/hint/RelHint.html" title="class in org.apache.calcite.rel.hint"><code>RelHint</code></a>s from <code>originalRel</code>
 to <code>newRel</code> if both of them are <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a>.

 <p>The hints would be filtered by the specified hint strategies
 if <code>filterHints</code> is true.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>originalRel</code> - Original relational expression</dd>
<dd><code>newRel</code> - New relational expression</dd>
<dd><code>filterHints</code> - Flag saying if to filter out unqualified hints for <code>newRel</code></dd>
<dt>Returns:</dt>
<dd>A copy of <code>newRel</code> with attached hints from <code>originalRel</code>,
 or <code>newRel</code> directly if one of them are not <a href="../rel/hint/Hintable.html" title="interface in org.apache.calcite.rel.hint"><code>Hintable</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="permutationIgnoreCast(java.util.List,org.apache.calcite.rel.type.RelDataType)">
<h3>permutationIgnoreCast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">permutationIgnoreCast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType)</span></div>
<div class="block">Returns a permutation describing where output fields come from. In
 the returned map, value of <code>map.getTargetOpt(i)</code> is <code>n</code> if
 field <code>i</code> projects input field <code>n</code> or applies a cast on
 <code>n</code>, -1 if it is another expression.</div>
</section>
</li>
<li>
<section class="detail" id="permutation(java.util.List,org.apache.calcite.rel.type.RelDataType)">
<h3>permutation</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">permutation</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType)</span></div>
<div class="block">Returns a permutation describing where output fields come from. In
 the returned map, value of <code>map.getTargetOpt(i)</code> is <code>n</code> if
 field <code>i</code> projects input field <code>n</code>, -1 if it is an
 expression.</div>
</section>
</li>
<li>
<section class="detail" id="permutationPushDownProject(java.util.List,org.apache.calcite.rel.type.RelDataType,int,int)">
<h3>permutationPushDownProject</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a></span>&nbsp;<span class="element-name">permutationPushDownProject</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;inputRowType,
 int&nbsp;sourceOffset,
 int&nbsp;targetOffset)</span></div>
<div class="block">Returns a permutation describing where the Project's fields come from
 after the Project is pushed down.</div>
</section>
</li>
<li>
<section class="detail" id="createExistsPlan(org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rex.RexLiteral,java.lang.String)">
<h3>createExistsPlan</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createExistsPlan</span><wbr><span class="parameters">(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions,
 @Nullable <a href="../rex/RexLiteral.html" title="class in org.apache.calcite.rex">RexLiteral</a>&nbsp;extraExpr,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;extraName)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createExistsPlan(org.apache.calcite.rel.RelNode,org.apache.calcite.plan.RelOptUtil.SubQueryType,org.apache.calcite.plan.RelOptUtil.Logic,boolean)">
<h3>createExistsPlan</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="RelOptUtil.Exists.html" title="class in org.apache.calcite.plan">RelOptUtil.Exists</a></span>&nbsp;<span class="element-name">createExistsPlan</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 <a href="RelOptUtil.SubQueryType.html" title="enum in org.apache.calcite.plan">RelOptUtil.SubQueryType</a>&nbsp;subQueryType,
 <a href="RelOptUtil.Logic.html" title="enum in org.apache.calcite.plan">RelOptUtil.Logic</a>&nbsp;logic,
 boolean&nbsp;notIn)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createExistsPlan(org.apache.calcite.rel.RelNode,org.apache.calcite.plan.RelOptUtil.SubQueryType,org.apache.calcite.plan.RelOptUtil.Logic,boolean,org.apache.calcite.tools.RelBuilder)">
<h3>createExistsPlan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="RelOptUtil.Exists.html" title="class in org.apache.calcite.plan">RelOptUtil.Exists</a></span>&nbsp;<span class="element-name">createExistsPlan</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;seekRel,
 <a href="RelOptUtil.SubQueryType.html" title="enum in org.apache.calcite.plan">RelOptUtil.SubQueryType</a>&nbsp;subQueryType,
 <a href="RelOptUtil.Logic.html" title="enum in org.apache.calcite.plan">RelOptUtil.Logic</a>&nbsp;logic,
 boolean&nbsp;notIn,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</span></div>
<div class="block">Creates a plan suitable for use in <code>EXISTS</code> or <code>IN</code>
 statements.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>seekRel</code> - A query rel, for example the resulting rel from 'select *
                   from emp' or 'values (1,2,3)' or '('Foo', 34)'.</dd>
<dd><code>subQueryType</code> - Sub-query type</dd>
<dd><code>logic</code> - Whether to use 2- or 3-valued boolean logic</dd>
<dd><code>notIn</code> - Whether the operator is NOT IN</dd>
<dd><code>relBuilder</code> - Builder for relational expressions</dd>
<dt>Returns:</dt>
<dd>A pair of a relational expression which outer joins a boolean
 condition column, and a numeric offset. The offset is 2 if column 0 is
 the number of rows and column 1 is the number of rows with not-null keys;
 0 otherwise.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../sql2rel/SqlToRelConverter.html" title="class in org.apache.calcite.sql2rel"><code>SqlToRelConverter#convertExists</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createRenameRel(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.RelNode)">
<h3>createRenameRel</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createRenameRel</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;outputType,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createFilter(org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode)">
<h3>createFilter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createFilter</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createFilter(org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.RelFactories.FilterFactory)">
<h3>createFilter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createFilter</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createFilter(org.apache.calcite.rel.RelNode,java.lang.Iterable)">
<h3>createFilter</h3>
<div class="member-signature"><span class="modifiers">public static</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">createFilter</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions)</span></div>
<div class="block">Creates a filter, using the default filter factory,
 or returns the original relational expression if the
 condition is trivial.</div>
</section>
</li>
<li>
<section class="detail" id="createFilter(org.apache.calcite.rel.RelNode,java.lang.Iterable,org.apache.calcite.rel.core.RelFactories.FilterFactory)">
<h3>createFilter</h3>
<div class="member-signature"><span class="modifiers">public static</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">createFilter</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;conditions,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory)</span></div>
<div class="block">Creates a filter using the default factory,
 or returns the original relational expression if the
 condition is trivial.</div>
</section>
</li>
<li>
<section class="detail" id="createNullFilter(org.apache.calcite.rel.RelNode,java.lang.Integer[])">
<h3>createNullFilter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createNullFilter</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>[]&nbsp;fieldOrdinals)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createCastRel(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType,boolean)">
<h3>createCastRel</h3>
<div class="member-signature"><span class="modifiers">public static</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">createCastRel</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;castRowType,
 boolean&nbsp;rename)</span></div>
<div class="block">Creates a projection which casts a rel's output to a desired row type.

 <p>No need to create new projection if <code>rel</code> is already a project,
 instead, create a projection with the input of <code>rel</code> and the new
 cast expressions.

 <p>The desired row type and the row type to be converted must have the
 same number of fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - producer of rows to be converted</dd>
<dd><code>castRowType</code> - row type after cast</dd>
<dd><code>rename</code> - if true, use field names from castRowType; if false,
                    preserve field names from rel</dd>
<dt>Returns:</dt>
<dd>conversion rel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createCastRel(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType,boolean,org.apache.calcite.rel.core.RelFactories.ProjectFactory)">
<h3>createCastRel</h3>
<div class="member-signature"><span class="modifiers">public static</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">createCastRel</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;castRowType,
 boolean&nbsp;rename,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</span></div>
<div class="block">Creates a projection which casts a rel's output to a desired row type.

 <p>No need to create new projection if <code>rel</code> is already a project,
 instead, create a projection with the input of <code>rel</code> and the new
 cast expressions.

 <p>The desired row type and the row type to be converted must have the
 same number of fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - producer of rows to be converted</dd>
<dd><code>castRowType</code> - row type after cast</dd>
<dd><code>rename</code> - if true, use field names from castRowType; if false,
                    preserve field names from rel</dd>
<dd><code>projectFactory</code> - Project Factory</dd>
<dt>Returns:</dt>
<dd>conversion rel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getAllFields(org.apache.calcite.rel.core.Aggregate)">
<h3>getAllFields</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">getAllFields</span><wbr><span class="parameters">(<a href="../rel/core/Aggregate.html" title="class in org.apache.calcite.rel.core">Aggregate</a>&nbsp;aggregate)</span></div>
<div class="block">Gets all fields in an aggregate.</div>
</section>
</li>
<li>
<section class="detail" id="getAllFields2(org.apache.calcite.util.ImmutableBitSet,java.util.List)">
<h3>getAllFields2</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">getAllFields2</span><wbr><span class="parameters">(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;groupSet,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/core/AggregateCall.html" title="class in org.apache.calcite.rel.core">AggregateCall</a>&gt;&nbsp;aggCallList)</span></div>
<div class="block">Gets all fields in an aggregate.</div>
</section>
</li>
<li>
<section class="detail" id="createSingleValueAggRel(org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.RelNode)">
<h3>createSingleValueAggRel</h3>
<div class="member-signature"><span class="modifiers">public static</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">createSingleValueAggRel</span><wbr><span class="parameters">(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Creates a LogicalAggregate that removes all duplicates from the result of
 an underlying relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - underlying rel</dd>
<dt>Returns:</dt>
<dd>rel implementing SingleValueAgg</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createDistinctRel(org.apache.calcite.rel.RelNode)">
<h3>createDistinctRel</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createDistinctRel</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../tools/RelBuilder.html#distinct()"><code>RelBuilder.distinct()</code></a>.</div>
</div>
</section>
</li>
<li>
<section class="detail" id="analyzeSimpleEquiJoin(org.apache.calcite.rel.logical.LogicalJoin,int[])">
<h3>analyzeSimpleEquiJoin</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">analyzeSimpleEquiJoin</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalJoin.html" title="class in org.apache.calcite.rel.logical">LogicalJoin</a>&nbsp;join,
 int[]&nbsp;joinFieldOrdinals)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)">
<h3>splitJoinCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">splitJoinCondition</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;&nbsp;filterNulls)</span></div>
<div class="block">Splits out the equi-join components of a join condition, and returns
 what's left. For example, given the condition

 <blockquote><code>L.A = R.X AND L.B = L.C AND (L.D = 5 OR L.E =
 R.Y)</code></blockquote>

 <p>returns

 <ul>
 <li>leftKeys = {A}
 <li>rightKeys = {X}
 <li>rest = L.B = L.C AND (L.D = 5 OR L.E = R.Y)</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>left</code> - left input to join</dd>
<dd><code>right</code> - right input to join</dd>
<dd><code>condition</code> - join condition</dd>
<dd><code>leftKeys</code> - The ordinals of the fields from the left input which are
                  equi-join keys</dd>
<dd><code>rightKeys</code> - The ordinals of the fields from the right input which
                  are equi-join keys</dd>
<dd><code>filterNulls</code> - List of boolean values for each join key position
                    indicating whether the operator filters out nulls or not.
                    Value is true if the operator is EQUALS and false if the
                    operator is IS NOT DISTINCT FROM (or an expanded version).
                    If <code>filterNulls</code> is null, only join conditions
                    with EQUALS operators are considered equi-join components.
                    Rest (including IS NOT DISTINCT FROM) are returned in
                    remaining join condition.</dd>
<dt>Returns:</dt>
<dd>remaining join filters that are not equijoins; may return a
 <a href="../rex/RexLiteral.html" title="class in org.apache.calcite.rex"><code>RexLiteral</code></a> true, but never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List,java.util.List)">
<h3>splitJoinCondition</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">splitJoinCondition</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;&nbsp;filterNulls,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nonEquiList)</span></div>
<div class="block">As
 <a href="#splitJoinCondition(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)"><code>splitJoinCondition(RelNode, RelNode, RexNode, List, List, List)</code></a>,
 but writes non-equi conditions to a conjunctive list.</div>
</section>
</li>
<li>
<section class="detail" id="isEqui(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode)">
<h3>isEqui</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isEqui</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="splitJoinCondition(java.util.List,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List,java.util.List)">
<h3>splitJoinCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">splitJoinCondition</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sysFieldList,
 <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;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftJoinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightJoinKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;filterNulls,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;&nbsp;rangeOp)</span></div>
<div class="block">Splits out the equi-join (and optionally, a single non-equi) components
 of a join condition, and returns what's left. Projection might be
 required by the caller to provide join keys that are not direct field
 references.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sysFieldList</code> - list of system fields</dd>
<dd><code>leftRel</code> - left join input</dd>
<dd><code>rightRel</code> - right join input</dd>
<dd><code>condition</code> - join condition</dd>
<dd><code>leftJoinKeys</code> - The join keys from the left input which are equi-join
                      keys</dd>
<dd><code>rightJoinKeys</code> - The join keys from the right input which are
                      equi-join keys</dd>
<dd><code>filterNulls</code> - The join key positions for which null values will not
                      match. null values only match for the "is not distinct
                      from" condition.</dd>
<dd><code>rangeOp</code> - if null, only locate equi-joins; otherwise, locate a
                      single non-equi join predicate and return its operator
                      in this list; join keys associated with the non-equi
                      join predicate are at the end of the key lists
                      returned</dd>
<dt>Returns:</dt>
<dd>What's left, never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitJoinCondition(java.util.List,java.util.List,org.apache.calcite.rex.RexNode,java.util.List,java.util.List,java.util.List)">
<h3>splitJoinCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">splitJoinCondition</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;sysFieldList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&gt;&nbsp;inputs,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/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;&gt;&nbsp;joinKeys,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;filterNulls,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;&nbsp;rangeOp)</span></div>
<div class="block">Splits out the equi-join (and optionally, a single non-equi) components
 of a join condition, and returns what's left. Projection might be
 required by the caller to provide join keys that are not direct field
 references.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sysFieldList</code> - list of system fields</dd>
<dd><code>inputs</code> - join inputs</dd>
<dd><code>condition</code> - join condition</dd>
<dd><code>joinKeys</code> - The join keys from the inputs which are equi-join
                      keys</dd>
<dd><code>filterNulls</code> - The join key positions for which null values will not
                      match. null values only match for the "is not distinct
                      from" condition.</dd>
<dd><code>rangeOp</code> - if null, only locate equi-joins; otherwise, locate a
                      single non-equi join predicate and return its operator
                      in this list; join keys associated with the non-equi
                      join predicate are at the end of the key lists
                      returned</dd>
<dt>Returns:</dt>
<dd>What's left, never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitCorrelatedFilterCondition(org.apache.calcite.rel.logical.LogicalFilter,java.util.List,java.util.List)">
<h3>splitCorrelatedFilterCondition</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">splitCorrelatedFilterCondition</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical">LogicalFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexInputRef.html" title="class in org.apache.calcite.rex">RexInputRef</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="splitCorrelatedFilterCondition(org.apache.calcite.rel.logical.LogicalFilter,java.util.List,java.util.List,boolean)">
<h3>splitCorrelatedFilterCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">splitCorrelatedFilterCondition</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical">LogicalFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys,
 boolean&nbsp;extractCorrelatedFieldAccess)</span></div>
</section>
</li>
<li>
<section class="detail" id="splitCorrelatedFilterCondition(org.apache.calcite.rel.core.Filter,java.util.List,java.util.List,boolean)">
<h3>splitCorrelatedFilterCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">splitCorrelatedFilterCondition</span><wbr><span class="parameters">(<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;correlatedJoinKeys,
 boolean&nbsp;extractCorrelatedFieldAccess)</span></div>
</section>
</li>
<li>
<section class="detail" id="createEquiJoinCondition(org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rex.RexBuilder)">
<h3>createEquiJoinCondition</h3>
<div class="member-signature"><span class="modifiers">public static</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">createEquiJoinCondition</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;left,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder)</span></div>
<div class="block">Builds an equi-join condition from a set of left and right keys.</div>
</section>
</li>
<li>
<section class="detail" id="op(org.apache.calcite.sql.SqlKind,org.apache.calcite.sql.SqlOperator)">
<h3>op</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a></span>&nbsp;<span class="element-name">op</span><wbr><span class="parameters">(<a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind,
 <a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator)</span></div>
<div class="block">Returns <a href="../sql/SqlOperator.html" title="class in org.apache.calcite.sql"><code>SqlOperator</code></a> for given <a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql"><code>SqlKind</code></a> or returns <code>operator</code>
 when <a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql"><code>SqlKind</code></a> is not known.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>kind</code> - input kind</dd>
<dd><code>operator</code> - default operator value</dd>
<dt>Returns:</dt>
<dd>SqlOperator for the given kind</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../rex/RexUtil.html#op(org.apache.calcite.sql.SqlKind)"><code>RexUtil.op(SqlKind)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="collapseExpandedIsNotDistinctFromExpr(org.apache.calcite.rex.RexCall,org.apache.calcite.rex.RexBuilder)">
<h3>collapseExpandedIsNotDistinctFromExpr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a></span>&nbsp;<span class="element-name">collapseExpandedIsNotDistinctFromExpr</span><wbr><span class="parameters">(<a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a>&nbsp;call,
 <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder)</span></div>
<div class="block">Collapses an expanded version of <code>IS NOT DISTINCT FROM</code> expression.

 <p>Helper method for
 <code>splitJoinCondition(RexBuilder, int, RexNode, List, List, List, List)</code>
 and
 <code>splitJoinCondition(List, List, RexNode, List, List, List, List)</code>.

 <p>If the given expr <code>call</code> is an expanded version of
 <code>IS NOT DISTINCT FROM</code> function call, collapses it and return a
 <code>IS NOT DISTINCT FROM</code> function call.

 <p>For example: <code>t1.key IS NOT DISTINCT FROM t2.key</code>
 can rewritten in expanded form as
 <code>t1.key = t2.key OR (t1.key IS NULL AND t2.key IS NULL)</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - Function expression to try collapsing</dd>
<dd><code>rexBuilder</code> - <a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex"><code>RexBuilder</code></a> instance to create new <a href="../rex/RexCall.html" title="class in org.apache.calcite.rex"><code>RexCall</code></a> instances.</dd>
<dt>Returns:</dt>
<dd>If the given function is an expanded IS NOT DISTINCT FROM function call,
         return a IS NOT DISTINCT FROM function call. Otherwise return the input
         function call as it is.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="projectJoinInputs(org.apache.calcite.rel.RelNode[],java.util.List,java.util.List,int,java.util.List,java.util.List,java.util.List)">
<h3>projectJoinInputs</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">projectJoinInputs</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>[]&nbsp;inputRels,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftJoinKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightJoinKeys,
 int&nbsp;systemColCount,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;leftKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;rightKeys,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;outputProj)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createProjectJoinRel(java.util.List,org.apache.calcite.rel.RelNode)">
<h3>createProjectJoinRel</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createProjectJoinRel</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;outputProj,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="registerAbstractRels(org.apache.calcite.plan.RelOptPlanner)">
<h3>registerAbstractRels</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">registerAbstractRels</span><wbr><span class="parameters">(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="registerAbstractRules(org.apache.calcite.plan.RelOptPlanner)">
<h3>registerAbstractRules</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">registerAbstractRules</span><wbr><span class="parameters">(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</span></div>
</section>
</li>
<li>
<section class="detail" id="registerAbstractRelationalRules(org.apache.calcite.plan.RelOptPlanner)">
<h3>registerAbstractRelationalRules</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">registerAbstractRelationalRules</span><wbr><span class="parameters">(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner)</span></div>
</section>
</li>
<li>
<section class="detail" id="registerDefaultRules(org.apache.calcite.plan.RelOptPlanner,boolean,boolean)">
<h3>registerDefaultRules</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">registerDefaultRules</span><wbr><span class="parameters">(<a href="RelOptPlanner.html" title="interface in org.apache.calcite.plan">RelOptPlanner</a>&nbsp;planner,
 boolean&nbsp;enableMaterializations,
 boolean&nbsp;enableBindable)</span></div>
</section>
</li>
<li>
<section class="detail" id="dumpPlan(java.lang.String,org.apache.calcite.rel.RelNode,org.apache.calcite.sql.SqlExplainFormat,org.apache.calcite.sql.SqlExplainLevel)">
<h3>dumpPlan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">dumpPlan</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;header,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../sql/SqlExplainFormat.html" title="enum in org.apache.calcite.sql">SqlExplainFormat</a>&nbsp;format,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</span></div>
<div class="block">Dumps a plan as a string.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>header</code> - Header to print before the plan. Ignored if the format
                    is XML</dd>
<dd><code>rel</code> - Relational expression to explain</dd>
<dd><code>format</code> - Output format</dd>
<dd><code>detailLevel</code> - Detail level</dd>
<dt>Returns:</dt>
<dd>Plan</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dumpPlan(java.lang.String,org.apache.calcite.rel.RelNode,boolean,org.apache.calcite.sql.SqlExplainLevel)">
<h3>dumpPlan</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">dumpPlan</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;header,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 boolean&nbsp;asXml,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createDmlRowType(org.apache.calcite.sql.SqlKind,org.apache.calcite.rel.type.RelDataTypeFactory)">
<h3>createDmlRowType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></span>&nbsp;<span class="element-name">createDmlRowType</span><wbr><span class="parameters">(<a href="../sql/SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind,
 <a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</span></div>
<div class="block">Creates the row type descriptor for the result of a DML operation, which
 is a single column named ROWCOUNT of type BIGINT for INSERT;
 a single column named PLAN for EXPLAIN.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>kind</code> - Kind of node</dd>
<dd><code>typeFactory</code> - factory to use for creating type descriptor</dd>
<dt>Returns:</dt>
<dd>created type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="eq(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.Litmus)">
<h3>eq</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">eq</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc2,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type2,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</span></div>
<div class="block">Returns whether two types are equal using 'equals'.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>desc1</code> - Description of first type</dd>
<dd><code>type1</code> - First type</dd>
<dd><code>desc2</code> - Description of second type</dd>
<dd><code>type2</code> - Second type</dd>
<dd><code>litmus</code> - What to do if an error is detected (types are not equal)</dd>
<dt>Returns:</dt>
<dd>Whether the types are equal</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equal(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.Litmus)">
<h3>equal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type1,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc2,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type2,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</span></div>
<div class="block">Returns whether two types are equal using
 <a href="#areRowTypesEqual(org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataType,boolean)"><code>areRowTypesEqual(RelDataType, RelDataType, boolean)</code></a>. Both types
 must not be null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>desc1</code> - Description of role of first type</dd>
<dd><code>type1</code> - First type</dd>
<dd><code>desc2</code> - Description of role of second type</dd>
<dd><code>type2</code> - Second type</dd>
<dd><code>litmus</code> - Whether to assert if they are not equal</dd>
<dt>Returns:</dt>
<dd>Whether the types are equal</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFullTypeDifferenceString(java.lang.String,org.apache.calcite.rel.type.RelDataType,java.lang.String,org.apache.calcite.rel.type.RelDataType)">
<h3>getFullTypeDifferenceString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getFullTypeDifferenceString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sourceDesc,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;sourceType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetDesc,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetType)</span></div>
<div class="block">Returns the detailed difference of two types.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceDesc</code> - description of role of source type</dd>
<dd><code>sourceType</code> - source type</dd>
<dd><code>targetDesc</code> - description of role of target type</dd>
<dd><code>targetType</code> - target type</dd>
<dt>Returns:</dt>
<dd>the detailed difference of two types</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equalType(java.lang.String,org.apache.calcite.rel.RelNode,java.lang.String,org.apache.calcite.rel.RelNode,org.apache.calcite.util.Litmus)">
<h3>equalType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equalType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc0,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel0,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;desc1,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel1,
 <a href="../util/Litmus.html" title="interface in org.apache.calcite.util">Litmus</a>&nbsp;litmus)</span></div>
<div class="block">Returns whether two relational expressions have the same row-type.</div>
</section>
</li>
<li>
<section class="detail" id="isDistinctFrom(org.apache.calcite.rex.RexBuilder,org.apache.calcite.rex.RexNode,org.apache.calcite.rex.RexNode,boolean)">
<h3>isDistinctFrom</h3>
<div class="member-signature"><span class="modifiers">public static</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">isDistinctFrom</span><wbr><span class="parameters">(<a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;x,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;y,
 boolean&nbsp;neg)</span></div>
<div class="block">Returns a translation of the <code>IS DISTINCT FROM</code> (or <code>IS
 NOT DISTINCT FROM</code>) sql operator.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>neg</code> - if false, returns a translation of IS NOT DISTINCT FROM</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toString(org.apache.calcite.rel.RelNode)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel)</span></div>
<div class="block">Converts a relational expression to a string, showing just basic
 attributes.</div>
</section>
</li>
<li>
<section class="detail" id="toString(org.apache.calcite.rel.RelNode,org.apache.calcite.sql.SqlExplainLevel)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@PolyNull <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(@PolyNull <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../sql/SqlExplainLevel.html" title="enum in org.apache.calcite.sql">SqlExplainLevel</a>&nbsp;detailLevel)</span></div>
<div class="block">Converts a relational expression to a string;
 returns null if and only if <code>rel</code> is null.</div>
</section>
</li>
<li>
<section class="detail" id="renameIfNecessary(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.type.RelDataType)">
<h3>renameIfNecessary</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">renameIfNecessary</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;desiredRowType)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="dumpType(org.apache.calcite.rel.type.RelDataType)">
<h3>dumpType</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">dumpType</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</span></div>
</section>
</li>
<li>
<section class="detail" id="deduplicateColumns(java.util.List,java.util.List)">
<h3>deduplicateColumns</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;</span>&nbsp;<span class="element-name">deduplicateColumns</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;baseColumns,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extendedColumns)</span></div>
<div class="block">Returns the set of columns with unique names, with prior columns taking
 precedence over columns that appear later in the list.</div>
</section>
</li>
<li>
<section class="detail" id="decomposeConjunction(org.apache.calcite.rex.RexNode,java.util.List)">
<h3>decomposeConjunction</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">decomposeConjunction</span><wbr><span class="parameters">(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList)</span></div>
<div class="block">Decomposes a predicate into a list of expressions that are AND'ed
 together.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rexPredicate</code> - predicate to be analyzed</dd>
<dd><code>rexList</code> - list of decomposed RexNodes</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="decomposeConjunction(org.apache.calcite.rex.RexNode,java.util.List,java.util.List)">
<h3>decomposeConjunction</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">decomposeConjunction</span><wbr><span class="parameters">(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;notList)</span></div>
<div class="block">Decomposes a predicate into a list of expressions that are AND'ed
 together, and a list of expressions that are preceded by NOT.

 <p>For example, <code>a AND NOT b AND NOT (c and d) AND TRUE AND NOT
 FALSE</code> returns <code>rexList = [a], notList = [b, c AND d]</code>.</p>

 <p>TRUE and NOT FALSE expressions are ignored. FALSE and NOT TRUE
 expressions are placed on <code>rexList</code> and <code>notList</code> as other
 expressions.</p>

 <p>For example, <code>a AND TRUE AND NOT TRUE</code> returns
 <code>rexList = [a], notList = [TRUE]</code>.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rexPredicate</code> - predicate to be analyzed</dd>
<dd><code>rexList</code> - list of decomposed RexNodes (except those with NOT)</dd>
<dd><code>notList</code> - list of decomposed RexNodes that were prefixed NOT</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="decomposeDisjunction(org.apache.calcite.rex.RexNode,java.util.List)">
<h3>decomposeDisjunction</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">decomposeDisjunction</span><wbr><span class="parameters">(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rexList)</span></div>
<div class="block">Decomposes a predicate into a list of expressions that are OR'ed
 together.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rexPredicate</code> - predicate to be analyzed</dd>
<dd><code>rexList</code> - list of decomposed RexNodes</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="conjunctions(org.apache.calcite.rex.RexNode)">
<h3>conjunctions</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">conjunctions</span><wbr><span class="parameters">(@Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate)</span></div>
<div class="block">Returns a condition decomposed by AND.

 <p>For example, <code>conjunctions(TRUE)</code> returns the empty list;
 <code>conjunctions(FALSE)</code> returns list <code>{FALSE}</code>.</p></div>
</section>
</li>
<li>
<section class="detail" id="disjunctions(org.apache.calcite.rex.RexNode)">
<h3>disjunctions</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">disjunctions</span><wbr><span class="parameters">(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;rexPredicate)</span></div>
<div class="block">Returns a condition decomposed by OR.

 <p>For example, <code>disjunctions(FALSE)</code> returns the empty list.</p></div>
</section>
</li>
<li>
<section class="detail" id="andJoinFilters(org.apache.calcite.rex.RexBuilder,org.apache.calcite.rex.RexNode,org.apache.calcite.rex.RexNode)">
<h3>andJoinFilters</h3>
<div class="member-signature"><span class="modifiers">public static</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">andJoinFilters</span><wbr><span class="parameters">(<a href="../rex/RexBuilder.html" title="class in org.apache.calcite.rex">RexBuilder</a>&nbsp;rexBuilder,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;left,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;right)</span></div>
<div class="block">Ands two sets of join filters together, either of which can be null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rexBuilder</code> - rexBuilder to create AND expression</dd>
<dd><code>left</code> - filter on the left that the right will be AND'd to</dd>
<dd><code>right</code> - filter on the right</dd>
<dt>Returns:</dt>
<dd>AND'd filter</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../rex/RexUtil.html#composeConjunction(org.apache.calcite.rex.RexBuilder,java.lang.Iterable)"><code>RexUtil.composeConjunction(org.apache.calcite.rex.RexBuilder, java.lang.Iterable&lt;? extends org.apache.calcite.rex.RexNode&gt;)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="inferViewPredicates(java.util.Map,java.util.List,org.apache.calcite.rex.RexNode)">
<h3>inferViewPredicates</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">inferViewPredicates</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;projectMap,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;constraint)</span></div>
<div class="block">Decomposes the WHERE clause of a view into predicates that constraint
 a column to a particular value.

 <p>This method is key to the validation of a modifiable view. Columns that
 are constrained to a single value can be omitted from the
 SELECT clause of a modifiable view.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>projectMap</code> - Mapping from column ordinal to the expression that
 populate that column, to be populated by this method</dd>
<dd><code>filters</code> - List of remaining filters, to be populated by this method</dd>
<dd><code>constraint</code> - Constraint to be analyzed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getColumnConstraints(org.apache.calcite.schema.ModifiableView,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.rel.type.RelDataTypeFactory)">
<h3>getColumnConstraints</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">getColumnConstraints</span><wbr><span class="parameters">(<a href="../schema/ModifiableView.html" title="interface in org.apache.calcite.schema">ModifiableView</a>&nbsp;modifiableViewTable,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;targetRowType,
 <a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory)</span></div>
<div class="block">Returns a mapping of the column ordinal in the underlying table to a column
 constraint of the modifiable view.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>modifiableViewTable</code> - The modifiable view which has a constraint</dd>
<dd><code>targetRowType</code> - The target type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="validateValueAgainstConstraint(org.apache.calcite.sql.SqlNode,org.apache.calcite.rex.RexNode,java.util.function.Supplier)">
<h3>validateValueAgainstConstraint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">validateValueAgainstConstraint</span><wbr><span class="parameters">(<a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;sourceValue,
 <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;targetConstraint,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/Supplier.html" title="class or interface in java.util.function" class="external-link">Supplier</a>&lt;<a href="../runtime/CalciteContextException.html" title="class in org.apache.calcite.runtime">CalciteContextException</a>&gt;&nbsp;errorSupplier)</span></div>
<div class="block">Ensures that a source value does not violate the constraint of the target
 column.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sourceValue</code> - The insert value being validated</dd>
<dd><code>targetConstraint</code> - The constraint applied to sourceValue for validation</dd>
<dd><code>errorSupplier</code> - The function to apply when validation fails</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="adjustKeys(java.util.List,int)">
<h3>adjustKeys</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">adjustKeys</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;keys,
 int&nbsp;adjustment)</span></div>
<div class="block">Adjusts key values in a list by some fixed amount.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keys</code> - list of key values</dd>
<dd><code>adjustment</code> - the amount to adjust the key values by</dd>
<dt>Returns:</dt>
<dd>modified list</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="simplifyJoin(org.apache.calcite.rel.RelNode,com.google.common.collect.ImmutableList,org.apache.calcite.rel.core.JoinRelType)">
<h3>simplifyJoin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a></span>&nbsp;<span class="element-name">simplifyJoin</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 com.google.common.collect.ImmutableList&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;aboveFilters,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</span></div>
<div class="block">Simplifies outer joins if filter above would reject nulls.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>joinRel</code> - Join</dd>
<dd><code>aboveFilters</code> - Filters from above</dd>
<dd><code>joinType</code> - Join type, can not be inner join</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)">
<h3>classifyFilters</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">classifyFilters</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 boolean&nbsp;pushInto,
 boolean&nbsp;pushLeft,
 boolean&nbsp;pushRight,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightFilters)</span></div>
<div class="block">Classifies filters according to where they should be processed. They
 either stay where they are, are pushed to the join (if they originated
 from above the join), or are pushed to one of the children. Filters that
 are pushed are added to list passed in as input parameters.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>joinRel</code> - join node</dd>
<dd><code>filters</code> - filters to be classified</dd>
<dd><code>pushInto</code> - whether filters can be pushed into the join</dd>
<dd><code>pushLeft</code> - true if filters can be pushed to the left</dd>
<dd><code>pushRight</code> - true if filters can be pushed to the right</dd>
<dd><code>joinFilters</code> - list of filters to push to the join</dd>
<dd><code>leftFilters</code> - list of filters to push to the left child</dd>
<dd><code>rightFilters</code> - list of filters to push to the right child</dd>
<dt>Returns:</dt>
<dd>whether at least one filter was pushed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,org.apache.calcite.rel.core.JoinRelType,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)">
<h3>classifyFilters</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">classifyFilters</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;joinRel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;filters,
 <a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType,
 boolean&nbsp;pushInto,
 boolean&nbsp;pushLeft,
 boolean&nbsp;pushRight,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;joinFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;leftFilters,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;rightFilters)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use
 <a href="#classifyFilters(org.apache.calcite.rel.RelNode,java.util.List,boolean,boolean,boolean,java.util.List,java.util.List,java.util.List)"><code>classifyFilters(RelNode, List, boolean, boolean, boolean, List, List, List)</code></a></div>
</div>
<div class="block">Classifies filters according to where they should be processed. They
 either stay where they are, are pushed to the join (if they originated
 from above the join), or are pushed to one of the children. Filters that
 are pushed are added to list passed in as input parameters.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>joinRel</code> - join node</dd>
<dd><code>filters</code> - filters to be classified</dd>
<dd><code>joinType</code> - join type</dd>
<dd><code>pushInto</code> - whether filters can be pushed into the ON clause</dd>
<dd><code>pushLeft</code> - true if filters can be pushed to the left</dd>
<dd><code>pushRight</code> - true if filters can be pushed to the right</dd>
<dd><code>joinFilters</code> - list of filters to push to the join</dd>
<dd><code>leftFilters</code> - list of filters to push to the left child</dd>
<dd><code>rightFilters</code> - list of filters to push to the right child</dd>
<dt>Returns:</dt>
<dd>whether at least one filter was pushed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitFilters(org.apache.calcite.util.ImmutableBitSet,org.apache.calcite.rex.RexNode,java.util.List,java.util.List)">
<h3>splitFilters</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">splitFilters</span><wbr><span class="parameters">(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;childBitmap,
 @Nullable <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;predicate,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;pushable,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;notPushable)</span></div>
<div class="block">Splits a filter into two lists, depending on whether or not the filter
 only references its child input.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>childBitmap</code> - Fields in the child</dd>
<dd><code>predicate</code> - filters that will be split</dd>
<dd><code>pushable</code> - returns the list of filters that can be pushed to the
                    child input</dd>
<dd><code>notPushable</code> - returns the list of filters that cannot be pushed to
                    the child input</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkProjAndChildInputs(org.apache.calcite.rel.core.Project,boolean)">
<h3>checkProjAndChildInputs</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">checkProjAndChildInputs</span><wbr><span class="parameters">(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 boolean&nbsp;checkNames)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createSwappedJoinExprs(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.core.Join,boolean)">
<h3>createSwappedJoinExprs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">createSwappedJoinExprs</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newJoin,
 <a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;origJoin,
 boolean&nbsp;origOrder)</span></div>
<div class="block">Creates projection expressions reflecting the swapping of a join's input.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>newJoin</code> - the RelNode corresponding to the join with its inputs
                  swapped</dd>
<dd><code>origJoin</code> - original LogicalJoin</dd>
<dd><code>origOrder</code> - if true, create the projection expressions to reflect
                  the original (pre-swapped) join projection; otherwise,
                  create the projection to reflect the order of the swapped
                  projection</dd>
<dt>Returns:</dt>
<dd>array of expression representing the swapped join inputs</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pushFilterPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)">
<h3>pushFilterPastProject</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a></span>&nbsp;<span class="element-name">pushFilterPastProject</span><wbr><span class="parameters">(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;filter,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;projRel)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="pushPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)">
<h3>pushPastProject</h3>
<div class="member-signature"><span class="modifiers">public static</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">pushPastProject</span><wbr><span class="parameters">(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;node,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</span></div>
<div class="block">Converts an expression that is based on the output fields of a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> to an equivalent expression on the Project's
 input fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - The expression to be converted</dd>
<dd><code>project</code> - Project underneath the expression</dd>
<dt>Returns:</dt>
<dd>converted expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pushPastProject(java.util.List,org.apache.calcite.rel.core.Project)">
<h3>pushPastProject</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;</span>&nbsp;<span class="element-name">pushPastProject</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</span></div>
<div class="block">Converts a list of expressions that are based on the output fields of a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> to equivalent expressions on the Project's
 input fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nodes</code> - The expressions to be converted</dd>
<dd><code>project</code> - Project underneath the expression</dd>
<dt>Returns:</dt>
<dd>converted expressions</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pushPastProjectUnlessBloat(java.util.List,org.apache.calcite.rel.core.Project,int)">
<h3>pushPastProjectUnlessBloat</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/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;</span>&nbsp;<span class="element-name">pushPastProjectUnlessBloat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;nodes,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 int&nbsp;bloat)</span></div>
<div class="block">As <a href="#pushPastProject(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Project)"><code>pushPastProject(org.apache.calcite.rex.RexNode, org.apache.calcite.rel.core.Project)</code></a>, but returns null if the resulting expressions
 are significantly more complex.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>bloat</code> - Maximum allowable increase in complexity</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pushPastCalc(org.apache.calcite.rex.RexNode,org.apache.calcite.rel.core.Calc)">
<h3>pushPastCalc</h3>
<div class="member-signature"><span class="modifiers">public static</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">pushPastCalc</span><wbr><span class="parameters">(<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&nbsp;node,
 <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc)</span></div>
<div class="block">Converts an expression that is based on the output fields of a
 <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core"><code>Calc</code></a> to an equivalent expression on the Calc's input fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - The expression to be converted</dd>
<dd><code>calc</code> - Calc underneath the expression</dd>
<dt>Returns:</dt>
<dd>converted expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="projectMultiJoin(org.apache.calcite.rel.rules.MultiJoin,org.apache.calcite.rel.core.Project)">
<h3>projectMultiJoin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules">MultiJoin</a></span>&nbsp;<span class="element-name">projectMultiJoin</span><wbr><span class="parameters">(<a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules">MultiJoin</a>&nbsp;multiJoin,
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</span></div>
<div class="block">Creates a new <a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules"><code>MultiJoin</code></a> to reflect
 projection references from a
 <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> that is on top of the
 <a href="../rel/rules/MultiJoin.html" title="class in org.apache.calcite.rel.rules"><code>MultiJoin</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>multiJoin</code> - the original MultiJoin</dd>
<dd><code>project</code> - the Project on top of the MultiJoin</dd>
<dt>Returns:</dt>
<dd>the new MultiJoin</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addTrait(T,org.apache.calcite.plan.RelTrait)">
<h3 id="addTrait(org.apache.calcite.rel.RelNode,org.apache.calcite.plan.RelTrait)">addTrait</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">addTrait</span><wbr><span class="parameters">(T&nbsp;rel,
 <a href="RelTrait.html" title="interface in org.apache.calcite.plan">RelTrait</a>&nbsp;trait)</span></div>
</section>
</li>
<li>
<section class="detail" id="replaceInput(org.apache.calcite.rel.RelNode,int,org.apache.calcite.rel.RelNode)">
<h3>replaceInput</h3>
<div class="member-signature"><span class="modifiers">public static</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">replaceInput</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;parent,
 int&nbsp;ordinal,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;newInput)</span></div>
<div class="block">Returns a shallow copy of a relational expression with a particular
 input replaced.</div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mappings.TargetMapping)">
<h3>createProject</h3>
<div class="member-signature"><span class="modifiers">public static</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">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping)</span></div>
<div class="block">Creates a <a href="../rel/logical/LogicalProject.html" title="class in org.apache.calcite.rel.logical"><code>LogicalProject</code></a> that
 projects particular fields of its input, according to a mapping.</div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mappings.TargetMapping,org.apache.calcite.rel.core.RelFactories.ProjectFactory)">
<h3>createProject</h3>
<div class="member-signature"><span class="modifiers">public static</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">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="../util/mapping/Mappings.TargetMapping.html" title="interface in org.apache.calcite.util.mapping">Mappings.TargetMapping</a>&nbsp;mapping,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</span></div>
</section>
</li>
<li>
<section class="detail" id="contains(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>contains</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">contains</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;ancestor,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;target)</span></div>
<div class="block">Returns whether relational expression <code>target</code> occurs within a
 relational expression <code>ancestor</code>.</div>
</section>
</li>
<li>
<section class="detail" id="replace(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public static</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">replace</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;query,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;find,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;replace)</span></div>
<div class="block">Within a relational expression <code>query</code>, replaces occurrences of
 <code>find</code> with <code>replace</code>.</div>
</section>
</li>
<li>
<section class="detail" id="getContext(org.apache.calcite.plan.RelOptCluster)">
<h3>getContext</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="RelOptTable.ToRelContext.html" title="interface in org.apache.calcite.plan">RelOptTable.ToRelContext</a></span>&nbsp;<span class="element-name">getContext</span><wbr><span class="parameters">(<a href="RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="countJoins(org.apache.calcite.rel.RelNode)">
<h3>countJoins</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">countJoins</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rootRel)</span></div>
<div class="block">Returns the number of <a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core"><code>Join</code></a> nodes in a
 tree.</div>
</section>
</li>
<li>
<section class="detail" id="permute(org.apache.calcite.rel.type.RelDataTypeFactory,org.apache.calcite.rel.type.RelDataType,org.apache.calcite.util.mapping.Mapping)">
<h3>permute</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a></span>&nbsp;<span class="element-name">permute</span><wbr><span class="parameters">(<a href="../rel/type/RelDataTypeFactory.html" title="interface in org.apache.calcite.rel.type">RelDataTypeFactory</a>&nbsp;typeFactory,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;rowType,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</span></div>
<div class="block">Permutes a record type according to a mapping.</div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List)">
<h3>createProject</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprList,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNameList)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,java.util.List,boolean)">
<h3>createProject</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../util/Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;<a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>,<wbr>? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&gt;&nbsp;projectList,
 boolean&nbsp;optimize)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,java.util.List)">
<h3>createProject</h3>
<div class="member-signature"><span class="modifiers">public static</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">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;posList)</span></div>
<div class="block">Creates a relational expression that projects the given fields of the
 input.

 <p>Optimizes if the fields are the identity projection.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>child</code> - Input relational expression</dd>
<dd><code>posList</code> - Source of each projected field</dd>
<dt>Returns:</dt>
<dd>Relational expression that projects given fields</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List,boolean)">
<h3>createProject</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 boolean&nbsp;optimize)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.RelNode,java.util.List,java.util.List,boolean,org.apache.calcite.tools.RelBuilder)">
<h3>createProject</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createProject</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="../rex/RexNode.html" title="class in org.apache.calcite.rex">RexNode</a>&gt;&nbsp;exprs,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 boolean&nbsp;optimize,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use
 <a href="../tools/RelBuilder.html#projectNamed(java.lang.Iterable,java.lang.Iterable,boolean)"><code>RelBuilder.projectNamed(Iterable, Iterable, boolean)</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="createRename(org.apache.calcite.rel.RelNode,java.util.List)">
<h3>createRename</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">createRename</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="permute(org.apache.calcite.rel.RelNode,org.apache.calcite.util.Permutation,java.util.List)">
<h3>permute</h3>
<div class="member-signature"><span class="modifiers">public static</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">permute</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/Permutation.html" title="class in org.apache.calcite.util">Permutation</a>&nbsp;permutation,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames)</span></div>
<div class="block">Creates a relational expression which permutes the output fields of a
 relational expression according to a permutation.

 <p>Optimizations:</p>

 <ul>
 <li>If the relational expression is a
 <a href="../rel/logical/LogicalCalc.html" title="class in org.apache.calcite.rel.logical"><code>LogicalCalc</code></a> or
 <a href="../rel/logical/LogicalProject.html" title="class in org.apache.calcite.rel.logical"><code>LogicalProject</code></a> that is already
 acting as a permutation, combines the new permutation with the old;</li>

 <li>If the permutation is the identity, returns the original relational
 expression.</li>
 </ul>

 <p>If a permutation is combined with its inverse, these optimizations
 would combine to remove them both.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - Relational expression</dd>
<dd><code>permutation</code> - Permutation to apply to fields</dd>
<dd><code>fieldNames</code> - Field names; if null, or if a particular entry is null,
                    the name of the permuted field is used</dd>
<dt>Returns:</dt>
<dd>relational expression which permutes its input fields</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createProject(org.apache.calcite.rel.core.RelFactories.ProjectFactory,org.apache.calcite.rel.RelNode,java.util.List)">
<h3>createProject</h3>
<div class="member-signature"><span class="modifiers">public static</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">createProject</span><wbr><span class="parameters">(<a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;factory,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;child,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;posList)</span></div>
<div class="block">Creates a relational expression that projects the given fields of the
 input.

 <p>Optimizes if the fields are the identity projection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>factory</code> - ProjectFactory</dd>
<dd><code>child</code> - Input relational expression</dd>
<dd><code>posList</code> - Source of each projected field</dd>
<dt>Returns:</dt>
<dd>Relational expression that projects given fields</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="projectMapping(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping,java.util.List,org.apache.calcite.rel.core.RelFactories.ProjectFactory)">
<h3>projectMapping</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">projectMapping</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;fieldNames,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="notContainsWindowedAgg(org.apache.calcite.rel.core.Calc)">
<h3>notContainsWindowedAgg</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notContainsWindowedAgg</span><wbr><span class="parameters">(<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc)</span></div>
<div class="block">Predicate for if a <a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core"><code>Calc</code></a> does not contain windowed aggregates.</div>
</section>
</li>
<li>
<section class="detail" id="notContainsWindowedAgg(org.apache.calcite.rel.core.Filter)">
<h3>notContainsWindowedAgg</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notContainsWindowedAgg</span><wbr><span class="parameters">(<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&nbsp;filter)</span></div>
<div class="block">Predicate for if a <a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core"><code>Filter</code></a> does not windowed aggregates.</div>
</section>
</li>
<li>
<section class="detail" id="notContainsWindowedAgg(org.apache.calcite.rel.core.Project)">
<h3>notContainsWindowedAgg</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notContainsWindowedAgg</span><wbr><span class="parameters">(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project)</span></div>
<div class="block">Predicate for if a <a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core"><code>Project</code></a> does not contain windowed aggregates.</div>
</section>
</li>
<li>
<section class="detail" id="pushDownJoinConditions(org.apache.calcite.rel.core.Join,org.apache.calcite.tools.RelBuilder)">
<h3>pushDownJoinConditions</h3>
<div class="member-signature"><span class="modifiers">public static</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">pushDownJoinConditions</span><wbr><span class="parameters">(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</span></div>
<div class="block">Pushes down expressions in "equal" join condition.

 <p>For example, given
 "emp JOIN dept ON emp.deptno + 1 = dept.deptno", adds a project above
 "emp" that computes the expression
 "emp.deptno + 1". The resulting join condition is a simple combination
 of AND, equals, and input fields, plus the remaining non-equal conditions.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>originalJoin</code> - Join whose condition is to be pushed down</dd>
<dd><code>relBuilder</code> - Factory to create project operator</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pushDownJoinConditions(org.apache.calcite.rel.core.Join)">
<h3>pushDownJoinConditions</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">pushDownJoinConditions</span><wbr><span class="parameters">(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="pushDownJoinConditions(org.apache.calcite.rel.core.Join,org.apache.calcite.rel.core.RelFactories.ProjectFactory)">
<h3>pushDownJoinConditions</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">pushDownJoinConditions</span><wbr><span class="parameters">(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;originalJoin,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
