<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>RelFieldTrimmer (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.sql2rel, class: RelFieldTrimmer">
<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>Field&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>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql2rel</a></div>
<h1 title="Class RelFieldTrimmer" class="title">Class RelFieldTrimmer</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql2rel.RelFieldTrimmer</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../util/ReflectiveVisitor.html" title="interface in org.apache.calcite.util">ReflectiveVisitor</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">RelFieldTrimmer</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../util/ReflectiveVisitor.html" title="interface in org.apache.calcite.util">ReflectiveVisitor</a></span></div>
<div class="block">Transformer that walks over a tree of relational expressions, replacing each
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a> with a 'slimmed down' relational expression that projects
 only the columns required by its consumer.

 <p>Uses multi-methods to fire the right rule for each type of relational
 expression. This allows the transformer to be extended without having to
 add a new method to RelNode, and without requiring a collection of rule
 classes scattered to the four winds.

 <p>REVIEW: jhyde, 2009/7/28: Is sql2rel the correct package for this class?
 Trimming fields is not an essential part of SQL-to-Rel translation, and
 arguably belongs in the optimization phase. But this transformer does not
 obey the usual pattern for planner rules; it is difficult to do so, because
 each <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel"><code>RelNode</code></a> needs to return a different set of fields after
 trimming.

 <p>TODO: Change 2nd arg of the <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet, java.util.Set&lt;org.apache.calcite.rel.type.RelDataTypeField&gt;)</code></a> method from BitSet to
 Mapping. Sometimes it helps the consumer if you return the columns in a
 particular order. For instance, it may avoid a project at the top of the
 tree just for reordering. Could ease the transition by writing methods that
 convert BitSet to Mapping and vice versa.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="RelFieldTrimmer.TrimResult.html" class="type-name-link" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-last even-row-color">
<div class="block">Result of an attempt to trim columns from a relational expression.</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(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.core.RelFactories.ProjectFactory,org.apache.calcite.rel.core.RelFactories.FilterFactory,org.apache.calcite.rel.core.RelFactories.JoinFactory,org.apache.calcite.rel.core.RelFactories.SortFactory,org.apache.calcite.rel.core.RelFactories.AggregateFactory,org.apache.calcite.rel.core.RelFactories.SetOpFactory)" class="member-name-link">RelFieldTrimmer</a><wbr>(@Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory,
 <a href="../rel/core/RelFactories.JoinFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.JoinFactory</a>&nbsp;joinFactory,
 <a href="../rel/core/RelFactories.SortFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.SortFactory</a>&nbsp;sortFactory,
 <a href="../rel/core/RelFactories.AggregateFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.AggregateFactory</a>&nbsp;aggregateFactory,
 <a href="../rel/core/RelFactories.SetOpFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.SetOpFactory</a>&nbsp;setOpFactory)</code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.tools.RelBuilder)" class="member-name-link">RelFieldTrimmer</a><wbr>(@Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <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">
<div class="block">Creates a RelFieldTrimmer.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createMapping(org.apache.calcite.util.ImmutableBitSet,int)" class="member-name-link">createMapping</a><wbr>(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 int&nbsp;fieldCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#dispatchTrimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">dispatchTrimFields</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Invokes <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet, java.util.Set&lt;org.apache.calcite.rel.type.RelDataTypeField&gt;)</code></a>, or the appropriate method for the type
 of the rel parameter, using multi-method dispatch.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#dummyProject(int,org.apache.calcite.rel.RelNode)" class="member-name-link">dummyProject</a><wbr>(int&nbsp;fieldCount,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a project with a dummy column, to protect the parts of the system
 that cannot handle a relational expression with no columns.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#dummyProject(int,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)" class="member-name-link">dummyProject</a><wbr>(int&nbsp;fieldCount,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 @Nullable <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRelNode)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a project with a dummy column, to protect the parts of the system
 that cannot handle a relational expression with no columns.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#result(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping)" class="member-name-link">result</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;r,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#result(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping,org.apache.calcite.rel.RelNode)" class="member-name-link">result</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,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;oldRel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trim(org.apache.calcite.rel.RelNode)" class="member-name-link">trim</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;root)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Trims unused fields from a relational expression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimChild(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimChild</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Trims the fields of an input relational expression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimChildRestore(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimChildRestore</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Trims a child relational expression, then adds back a dummy project to
 restore the fields that were removed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Aggregate,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Aggregate.html" title="class in org.apache.calcite.rel.core">Aggregate</a>&nbsp;aggregate,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalAggregate.html" title="class in org.apache.calcite.rel.logical"><code>LogicalAggregate</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Calc,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalCalc.html" title="class in org.apache.calcite.rel.logical"><code>LogicalCalc</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Exchange,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Exchange.html" title="class in org.apache.calcite.rel.core">Exchange</a>&nbsp;exchange,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Filter,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Filter.html" title="class in org.apache.calcite.rel.core">Filter</a>&nbsp;filter,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical"><code>LogicalFilter</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Join,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;join,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalJoin.html" title="class in org.apache.calcite.rel.logical"><code>LogicalJoin</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Project,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalProject.html" title="class in org.apache.calcite.rel.logical"><code>LogicalProject</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.SetOp,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/SetOp.html" title="class in org.apache.calcite.rel.core">SetOp</a>&nbsp;setOp,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/core/SetOp.html" title="class in org.apache.calcite.rel.core"><code>SetOp</code></a> (Only UNION ALL is supported).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.SortExchange,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/SortExchange.html" title="class in org.apache.calcite.rel.core">SortExchange</a>&nbsp;sortExchange,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.Sort,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/Sort.html" title="class in org.apache.calcite.rel.core">Sort</a>&nbsp;sort,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/core/Sort.html" title="class in org.apache.calcite.rel.core"><code>Sort</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.core.TableScan,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/core/TableScan.html" title="class in org.apache.calcite.rel.core">TableScan</a>&nbsp;tableAccessRel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableScan.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableScan</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.logical.LogicalTableFunctionScan,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical">LogicalTableFunctionScan</a>&nbsp;tabFun,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableFunctionScan</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.logical.LogicalTableModify,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/logical/LogicalTableModify.html" title="class in org.apache.calcite.rel.logical">LogicalTableModify</a>&nbsp;modifier,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableModify.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableModify</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.logical.LogicalValues,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/logical/LogicalValues.html" title="class in org.apache.calcite.rel.logical">LogicalValues</a>&nbsp;values,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalValues.html" title="class in org.apache.calcite.rel.logical"><code>LogicalValues</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)" class="member-name-link">trimFields</a><wbr>(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Visit method, per <a href="../util/ReflectiveVisitor.html" title="interface in org.apache.calcite.util"><code>ReflectiveVisitor</code></a>.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.tools.RelBuilder)">
<h3>RelFieldTrimmer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">RelFieldTrimmer</span><wbr><span class="parameters">(@Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../tools/RelBuilder.html" title="class in org.apache.calcite.tools">RelBuilder</a>&nbsp;relBuilder)</span></div>
<div class="block">Creates a RelFieldTrimmer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>validator</code> - Validator</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.sql.validate.SqlValidator,org.apache.calcite.plan.RelOptCluster,org.apache.calcite.rel.core.RelFactories.ProjectFactory,org.apache.calcite.rel.core.RelFactories.FilterFactory,org.apache.calcite.rel.core.RelFactories.JoinFactory,org.apache.calcite.rel.core.RelFactories.SortFactory,org.apache.calcite.rel.core.RelFactories.AggregateFactory,org.apache.calcite.rel.core.RelFactories.SetOpFactory)">
<h3>RelFieldTrimmer</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="element-name">RelFieldTrimmer</span><wbr><span class="parameters">(@Nullable <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate">SqlValidator</a>&nbsp;validator,
 <a href="../plan/RelOptCluster.html" title="class in org.apache.calcite.plan">RelOptCluster</a>&nbsp;cluster,
 <a href="../rel/core/RelFactories.ProjectFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.ProjectFactory</a>&nbsp;projectFactory,
 <a href="../rel/core/RelFactories.FilterFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.FilterFactory</a>&nbsp;filterFactory,
 <a href="../rel/core/RelFactories.JoinFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.JoinFactory</a>&nbsp;joinFactory,
 <a href="../rel/core/RelFactories.SortFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.SortFactory</a>&nbsp;sortFactory,
 <a href="../rel/core/RelFactories.AggregateFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.AggregateFactory</a>&nbsp;aggregateFactory,
 <a href="../rel/core/RelFactories.SetOpFactory.html" title="interface in org.apache.calcite.rel.core">RelFactories.SetOpFactory</a>&nbsp;setOpFactory)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</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="trim(org.apache.calcite.rel.RelNode)">
<h3>trim</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a></span>&nbsp;<span class="element-name">trim</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;root)</span></div>
<div class="block">Trims unused fields from a relational expression.

 <p>We presume that all fields of the relational expression are wanted by
 its consumer, so only trim fields that are not used within the tree.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>root</code> - Root node of relational expression</dd>
<dt>Returns:</dt>
<dd>Trimmed relational expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trimChild(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimChild</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimChild</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Trims the fields of an input relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - Relational expression</dd>
<dd><code>input</code> - Input relational expression, whose fields to trim</dd>
<dd><code>fieldsUsed</code> - Bitmap of fields needed by the consumer</dd>
<dt>Returns:</dt>
<dd>New relational expression and its field mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trimChildRestore(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimChildRestore</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimChildRestore</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Trims a child relational expression, then adds back a dummy project to
 restore the fields that were removed.

 <p>Sounds pointless? It causes unused fields to be removed
 further down the tree (towards the leaves), but it ensure that the
 consuming relational expression continues to see the same fields.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - Relational expression</dd>
<dd><code>input</code> - Input relational expression, whose fields to trim</dd>
<dd><code>fieldsUsed</code> - Bitmap of fields needed by the consumer</dd>
<dt>Returns:</dt>
<dd>New relational expression and its field mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dispatchTrimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>dispatchTrimFields</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">dispatchTrimFields</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Invokes <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet, java.util.Set&lt;org.apache.calcite.rel.type.RelDataTypeField&gt;)</code></a>, or the appropriate method for the type
 of the rel parameter, using multi-method dispatch.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - Relational expression</dd>
<dd><code>fieldsUsed</code> - Bitmap of fields needed by the consumer</dd>
<dt>Returns:</dt>
<dd>New relational expression and its field mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="result(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping,org.apache.calcite.rel.RelNode)">
<h3>result</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">result</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,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;oldRel)</span></div>
</section>
</li>
<li>
<section class="detail" id="result(org.apache.calcite.rel.RelNode,org.apache.calcite.util.mapping.Mapping)">
<h3>result</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">result</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;r,
 <a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a>&nbsp;mapping)</span></div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;rel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Visit method, per <a href="../util/ReflectiveVisitor.html" title="interface in org.apache.calcite.util"><code>ReflectiveVisitor</code></a>.

 <p>This method is invoked reflectively, so there may not be any apparent
 calls to it. The class (or derived classes) may contain overloads of
 this method with more specific types for the <code>rel</code> parameter.

 <p>Returns a pair: the relational expression created, and the mapping
 between the original fields and the fields of the newly created
 relational expression.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>rel</code> - Relational expression</dd>
<dd><code>fieldsUsed</code> - Fields needed by the consumer</dd>
<dt>Returns:</dt>
<dd>relational expression and mapping</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Calc,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Calc.html" title="class in org.apache.calcite.rel.core">Calc</a>&nbsp;calc,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalCalc.html" title="class in org.apache.calcite.rel.logical"><code>LogicalCalc</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Project,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Project.html" title="class in org.apache.calcite.rel.core">Project</a>&nbsp;project,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalProject.html" title="class in org.apache.calcite.rel.logical"><code>LogicalProject</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="dummyProject(int,org.apache.calcite.rel.RelNode)">
<h3>dummyProject</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">dummyProject</span><wbr><span class="parameters">(int&nbsp;fieldCount,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input)</span></div>
<div class="block">Creates a project with a dummy column, to protect the parts of the system
 that cannot handle a relational expression with no columns.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>fieldCount</code> - Number of fields in the original relational expression</dd>
<dd><code>input</code> - Trimmed input</dd>
<dt>Returns:</dt>
<dd>Dummy project</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dummyProject(int,org.apache.calcite.rel.RelNode,org.apache.calcite.rel.RelNode)">
<h3>dummyProject</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">dummyProject</span><wbr><span class="parameters">(int&nbsp;fieldCount,
 <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;input,
 @Nullable <a href="../rel/RelNode.html" title="interface in org.apache.calcite.rel">RelNode</a>&nbsp;originalRelNode)</span></div>
<div class="block">Creates a project with a dummy column, to protect the parts of the system
 that cannot handle a relational expression with no columns.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>fieldCount</code> - Number of fields in the original relational expression</dd>
<dd><code>input</code> - Trimmed input</dd>
<dd><code>originalRelNode</code> - Source RelNode for hint propagation (or null if no propagation needed)</dd>
<dt>Returns:</dt>
<dd>Dummy project</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Filter,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</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="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalFilter.html" title="class in org.apache.calcite.rel.logical"><code>LogicalFilter</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Sort,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Sort.html" title="class in org.apache.calcite.rel.core">Sort</a>&nbsp;sort,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/core/Sort.html" title="class in org.apache.calcite.rel.core"><code>Sort</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Exchange,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Exchange.html" title="class in org.apache.calcite.rel.core">Exchange</a>&nbsp;exchange,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.SortExchange,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/SortExchange.html" title="class in org.apache.calcite.rel.core">SortExchange</a>&nbsp;sortExchange,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Join,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Join.html" title="class in org.apache.calcite.rel.core">Join</a>&nbsp;join,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalJoin.html" title="class in org.apache.calcite.rel.logical"><code>LogicalJoin</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.SetOp,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/SetOp.html" title="class in org.apache.calcite.rel.core">SetOp</a>&nbsp;setOp,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/core/SetOp.html" title="class in org.apache.calcite.rel.core"><code>SetOp</code></a> (Only UNION ALL is supported).</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.Aggregate,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/Aggregate.html" title="class in org.apache.calcite.rel.core">Aggregate</a>&nbsp;aggregate,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalAggregate.html" title="class in org.apache.calcite.rel.logical"><code>LogicalAggregate</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.logical.LogicalTableModify,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalTableModify.html" title="class in org.apache.calcite.rel.logical">LogicalTableModify</a>&nbsp;modifier,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableModify.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableModify</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.logical.LogicalTableFunctionScan,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical">LogicalTableFunctionScan</a>&nbsp;tabFun,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableFunctionScan.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableFunctionScan</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.logical.LogicalValues,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/logical/LogicalValues.html" title="class in org.apache.calcite.rel.logical">LogicalValues</a>&nbsp;values,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalValues.html" title="class in org.apache.calcite.rel.logical"><code>LogicalValues</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="createMapping(org.apache.calcite.util.ImmutableBitSet,int)">
<h3>createMapping</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../util/mapping/Mapping.html" title="interface in org.apache.calcite.util.mapping">Mapping</a></span>&nbsp;<span class="element-name">createMapping</span><wbr><span class="parameters">(<a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 int&nbsp;fieldCount)</span></div>
</section>
</li>
<li>
<section class="detail" id="trimFields(org.apache.calcite.rel.core.TableScan,org.apache.calcite.util.ImmutableBitSet,java.util.Set)">
<h3>trimFields</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="RelFieldTrimmer.TrimResult.html" title="class in org.apache.calcite.sql2rel">RelFieldTrimmer.TrimResult</a></span>&nbsp;<span class="element-name">trimFields</span><wbr><span class="parameters">(<a href="../rel/core/TableScan.html" title="class in org.apache.calcite.rel.core">TableScan</a>&nbsp;tableAccessRel,
 <a href="../util/ImmutableBitSet.html" title="class in org.apache.calcite.util">ImmutableBitSet</a>&nbsp;fieldsUsed,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../rel/type/RelDataTypeField.html" title="interface in org.apache.calcite.rel.type">RelDataTypeField</a>&gt;&nbsp;extraFields)</span></div>
<div class="block">Variant of <a href="#trimFields(org.apache.calcite.rel.RelNode,org.apache.calcite.util.ImmutableBitSet,java.util.Set)"><code>trimFields(RelNode, ImmutableBitSet, Set)</code></a> for
 <a href="../rel/logical/LogicalTableScan.html" title="class in org.apache.calcite.rel.logical"><code>LogicalTableScan</code></a>.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
