<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Expressions (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.linq4j.tree, class: Expressions">
<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>Constr&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>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.linq4j.tree</a></div>
<h1 title="Class Expressions" class="title">Class Expressions</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.linq4j.tree.Expressions</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">Expressions</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Utility methods for expressions, including a lot of factory methods.</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 interface&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Expressions.FluentList.html" class="type-name-link" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;<a href="Expressions.FluentList.html" title="type parameter in Expressions.FluentList">T</a>&gt;</code></div>
<div class="col-last even-row-color">
<div class="block">Fluent list.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">add</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">add</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">addAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">addAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">addAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaLeft,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaRight)</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 BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">addAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">addAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">addAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">addChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 addition operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">addChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 addition operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">and</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise AND
 operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">and</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise AND
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">andAlso</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a conditional AND
 operation that evaluates the second operand only if the first
 operand evaluates to true.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">andAlso</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a conditional AND
 operation that evaluates the second operand only if the first
 operand is resolved to true.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">andAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">andAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">andAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#arrayIndex(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">arrayIndex</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;array,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;indexExpression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an expression that represents applying an array
 index operator to an array of rank one.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#arrayLength(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">arrayLength</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;array)</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 UnaryExpression that represents an expression for
 obtaining the length of a one-dimensional array.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#assign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">assign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents an assignment
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">bind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 MemberAssignment that represents the initialization
 of a field or property.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">bind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 MemberAssignment that represents the initialization
 of a member by using a property accessor method.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#block(java.lang.reflect.Type,java.lang.Iterable)" class="member-name-link">block</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;expressions)</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 BlockExpression that contains the given expressions,
 has no variables and has specific result type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#block(java.lang.Iterable)" class="member-name-link">block</a><wbr>(<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="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;statements)</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 BlockExpression that contains the given statements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#block(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Statement...)" class="member-name-link">block</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</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 BlockExpression that contains the given statements
 and has a specific result type, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#block(org.apache.calcite.linq4j.tree.Statement...)" class="member-name-link">block</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</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 BlockExpression that contains the given statements,
 using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#box(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">box</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts e.g.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#box(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)" class="member-name-link">box</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Primitive.html" title="enum in org.apache.calcite.linq4j.tree">Primitive</a>&nbsp;primitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an expression to box the value of a primitive 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="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget)" class="member-name-link">break_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</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 GotoExpression representing a break statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)" class="member-name-link">break_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a break statement with
 the specified 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="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">break_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 GotoExpression representing a break statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">break_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a break statement with
 the specified 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="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">call</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 method that takes arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">call</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 method that takes arguments, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 static method that has arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 static method that has arguments, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;returnType,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;returnType,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type, with varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Type,java.lang.String,java.lang.Iterable)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;methodName,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(java.lang.reflect.Type,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">call</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;methodName,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,java.lang.Iterable)" class="member-name-link">call</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
 <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;methodName,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">call</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
 <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;methodName,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#catch_(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">catch_</a><wbr>(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;statement)</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 CatchBlock representing a catch statement with a
 reference to the caught Exception object for use in the handler
 body.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ClassDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ClassDeclaration</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#classDecl(int,java.lang.String,java.lang.reflect.Type,java.util.List,java.util.List)" class="member-name-link">classDecl</a><wbr>(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;extended,
 <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/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&gt;&nbsp;implemented,
 <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Declares a class.</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="#clearDebugInfo()" class="member-name-link">clearDebugInfo</a>()</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 DebugInfoExpression for clearing a sequence
 point.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">coalesce</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a coalescing
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">coalesce</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a coalescing
 operation, given a conversion function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">condition</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifTrue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifFalse)</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 ConditionalExpression that represents a conditional
 statement.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConditionalExpression.html" title="class in org.apache.calcite.linq4j.tree">ConditionalExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">condition</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifTrue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifFalse,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 ConditionalExpression that represents a conditional
 statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#constant(java.lang.Object)" class="member-name-link">constant</a><wbr>(@Nullable <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;value)</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 ConstantExpression that has the Value property set
 to the specified 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="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#constant(java.lang.Object,java.lang.reflect.Type)" class="member-name-link">constant</a><wbr>(@Nullable <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;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 ConstantExpression that has the Value and Type
 properties set to the specified values.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConstructorDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ConstructorDeclaration</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#constructorDecl(int,java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)" class="member-name-link">constructorDecl</a><wbr>(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;declaredAgainst,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Declares a constructor.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#continue_(org.apache.calcite.linq4j.tree.LabelTarget)" class="member-name-link">continue_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</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 GotoExpression representing a continue statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#continue_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)" class="member-name-link">continue_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a continue statement
 with the specified 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">convert_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 UnaryExpression that represents a type conversion
 operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)" class="member-name-link">convert_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents a conversion
 operation for which the implementing method is specified.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convertChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">convertChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 UnaryExpression that represents a conversion
 operation that throws an exception if the target type is
 overflowed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convertChecked_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)" class="member-name-link">convertChecked_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents a conversion
 operation that throws an exception if the target type is
 overflowed and for which the implementing method is
 specified.</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="#debugInfo()" class="member-name-link">debugInfo</a>()</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 DebugInfoExpression with the specified 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="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#declare(int,java.lang.String,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">declare</a><wbr>(int&nbsp;modifiers,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an expression that declares and initializes a variable.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#declare(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">declare</a><wbr>(int&nbsp;modifiers,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</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 statement that declares a variable.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#decrement(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">decrement</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#decrement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">decrement</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#default_()" class="member-name-link">default_</a>()</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 DefaultExpression that has the Type property set to
 the specified 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">divide</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 division operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">divide</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 division operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">divideAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">divideAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">divideAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,java.lang.Iterable)" class="member-name-link">dynamic</a><wbr>(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</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 DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">dynamic</a><wbr>(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expression)</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 <code>DynamicExpression</code> that represents a dynamic
 operation bound by the provided <code>CallSiteBinder</code>, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#elementInit(java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">elementInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an <code>ElementInit</code>, given an <code>Iterable&lt;T&gt;</code> as the second
 argument.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#elementInit(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">elementInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an ElementInit, given an array of values as the second
 argument, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#empty()" class="member-name-link">empty</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an empty expression that has Void 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">equal</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an equality
 comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">equal</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression0,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression1,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an equality
 comparison.</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/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#evaluate(org.apache.calcite.linq4j.tree.Node)" class="member-name-link">evaluate</a><wbr>(<a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;node)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Evaluates an 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 <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">exclusiveOr</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined types.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">exclusiveOr</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">exclusiveOrAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">exclusiveOrAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">exclusiveOrAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Field)" class="member-name-link">field</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html" title="class or interface in java.lang.reflect" class="external-link">Field</a>&nbsp;field)</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 MemberExpression that represents accessing a field.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)" class="member-name-link">field</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;fieldName)</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 MemberExpression that represents accessing a field.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#field(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)" class="member-name-link">field</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="PseudoField.html" title="interface in org.apache.calcite.linq4j.tree">PseudoField</a>&nbsp;field)</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 MemberExpression that represents accessing a field.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.String)" class="member-name-link">field</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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;fieldName)</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 MemberExpression that represents accessing a field
 given the name of the field.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression)" class="member-name-link">fieldDecl</a><wbr>(int&nbsp;modifier,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Declares a field.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">fieldDecl</a><wbr>(int&nbsp;modifier,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Declares a field with an initializer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#foldAnd(java.util.List)" class="member-name-link">foldAnd</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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;conditions)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Combines a list of expressions using AND.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#foldOr(java.util.List)" class="member-name-link">foldOr</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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Combines a list of expressions using OR.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#for_(java.lang.Iterable,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">for_</a><wbr>(<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="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a>&gt;&nbsp;declarations,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;post,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</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 LoopExpression with the given body.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#for_(org.apache.calcite.linq4j.tree.DeclarationStatement,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">for_</a><wbr>(<a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a>&nbsp;declaration,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;post,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</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 LoopExpression with the given body.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ForEachStatement.html" title="class in org.apache.calcite.linq4j.tree">ForEachStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#forEach(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">forEach</a><wbr>(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;iterable,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</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 ForEachExpression with the given body.</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getActionType(java.lang.Class...)" class="member-name-link">getActionType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</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 Type object that represents a generic System.Action
 delegate type that has specific type arguments.</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDelegateType(java.lang.Class...)" class="member-name-link">getDelegateType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Gets a Type object that represents a generic System.Func or
 System.Action delegate type that has specific type
 arguments.</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getFuncType(java.lang.Class...)" class="member-name-link">getFuncType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</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 Type object that represents a generic System.Func
 delegate type that has specific type arguments.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget)" class="member-name-link">goto_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</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 GotoExpression representing a "go to" statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)" class="member-name-link">goto_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified 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="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">goto_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 GotoExpression representing a "go to" statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">goto_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">greaterThan</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a "greater than"
 numeric comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">greaterThan</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a "greater than"
 numeric comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">greaterThanOrEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">greaterThanOrEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ifThen(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node)" class="member-name-link">ifThen</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifTrue)</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 ConditionalExpression that represents a conditional
 block with an if statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ifThenElse(java.lang.Iterable)" class="member-name-link">ifThenElse</a><wbr>(<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="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&gt;&nbsp;nodes)</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 ConditionalExpression that represents a conditional
 block with if and else statements:
 <code>if (test) stmt1 [ else if (test2) stmt2 ]...</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node...)" class="member-name-link">ifThenElse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>...&nbsp;nodes)</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 ConditionalExpression that represents a conditional
 block with if and else statements:
 <code>if (test) stmt1 [ else if (test2) stmt2 ]...</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node,org.apache.calcite.linq4j.tree.Node)" class="member-name-link">ifThenElse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifTrue,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifFalse)</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 ConditionalExpression that represents a conditional
 block with if and else statements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#increment(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">increment</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents the incrementing of
 the expression value by 1.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#increment(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">increment</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents the incrementing of
 the expression by 1.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#invoke(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)" class="member-name-link">invoke</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#invoke(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">invoke</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions, using varargs.</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="#isConstantNull(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">isConstantNull</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e)</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 an expression always evaluates to null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isFalse(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">isFalse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 the expression evaluates to false.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isFalse(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">isFalse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 the expression evaluates to false.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isTrue(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">isTrue</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 the expression evaluates to true.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isTrue(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">isTrue</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 the expression evaluates to true.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label()" class="member-name-link">label</a>()</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 LabelTarget representing a label with X type and
 no name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label(java.lang.reflect.Type)" class="member-name-link">label</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 LabelTarget representing a label with the given
 type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label(java.lang.reflect.Type,java.lang.String)" class="member-name-link">label</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</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 LabelTarget representing a label with the given type
 and name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label(java.lang.String)" class="member-name-link">label</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;name)</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 LabelTarget representing a label with X type and
 the given name.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label(org.apache.calcite.linq4j.tree.LabelTarget)" class="member-name-link">label</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</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 LabelExpression representing a label without a
 default 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="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#label(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">label</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 LabelExpression representing a label with the given
 default value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(F)" class="member-name-link">lambda</a><wbr>(F&nbsp;function)</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 FunctionExpression from an actual function.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)" class="member-name-link">lambda</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)" class="member-name-link">lambda</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)" class="member-name-link">lambda</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)" class="member-name-link">lambda</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)" class="member-name-link">lambda</a><wbr>(<a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)" class="member-name-link">lambda</a><wbr>(<a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</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 LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)" class="member-name-link">lambda</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;<br><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lambda(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)" class="member-name-link">lambda</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">leftShift</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise
 left-shift operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">leftShift</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise
 left-shift operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">leftShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">leftShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">leftShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">lessThan</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">lessThan</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a "less than"
 numeric comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">lessThanOrEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a " less than or
 equal" numeric comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">lessThanOrEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a "less than or
 equal" numeric comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#list()" class="member-name-link">list</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an empty fluent list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#list(java.lang.Iterable)" class="member-name-link">list</a><wbr>(<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;T&gt;&nbsp;ts)</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 fluent list with elements from the given collection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#list(T...)" class="member-name-link">list</a><wbr>(T...&nbsp;ts)</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 fluent list with given elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listBind(java.lang.reflect.Member,java.lang.Iterable)" class="member-name-link">listBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</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 MemberListBinding where the member is a field or
 property.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.ElementInit...)" class="member-name-link">listBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</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 MemberListBinding where the member is a field or
 property, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listBind(java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">listBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</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 MemberListBinding based on a specified property
 accessor method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.ElementInit...)" class="member-name-link">listBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</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 MemberListBinding object based on a specified
 property accessor method, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)" class="member-name-link">listInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</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 ListInitExpression that uses specified ElementInit
 objects to initialize a collection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">listInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 ListInitExpression that uses a specified method to
 add elements to a collection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">listInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 ListInitExpression that uses a specified method to
 add elements to a collection, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.ElementInit...)" class="member-name-link">listInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</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 ListInitExpression that uses specified ElementInit
 objects to initialize a collection, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">listInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 ListInitExpression that uses a method named "Add" to
 add elements to a collection, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listInitE(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)" class="member-name-link">listInitE</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 ListInitExpression that uses a method named "Add" to
 add elements to a collection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">makeBinary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">makeBinary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression, given the left operand, right
 operand and implementing method, by calling the appropriate
 factory method.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">makeBinary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression, given the left operand, right
 operand, implementing method and type conversion function, by
 calling the appropriate factory method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeCatchBlock(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">makeCatchBlock</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;variable,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;filter)</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 CatchBlock representing a catch statement with the
 specified elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.Iterable)" class="member-name-link">makeDynamic</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">makeDynamic</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">makeGoto</a><wbr>(<a href="GotoExpressionKind.html" title="enum in org.apache.calcite.linq4j.tree">GotoExpressionKind</a>&nbsp;kind,
 @Nullable <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">makeGoto</a><wbr>(<a href="GotoExpressionKind.html" title="enum in org.apache.calcite.linq4j.tree">GotoExpressionKind</a>&nbsp;kind,
 <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;target,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a jump of the specified
 GotoExpressionKind.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeMemberAccess(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)" class="member-name-link">makeMemberAccess</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="PseudoField.html" title="interface in org.apache.calcite.linq4j.tree">PseudoField</a>&nbsp;member)</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 MemberExpression that represents accessing a field.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TernaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TernaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeTernary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">makeTernary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;ternaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e0,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e1,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e2)</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 TernaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeTry(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)" class="member-name-link">makeTry</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;finally_,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;fault,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</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 TryExpression representing a try block with the
 specified elements.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeTry(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.CatchBlock...)" class="member-name-link">makeTry</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;finally_,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;fault,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</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 TryExpression representing a try block with the
 specified elements, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">makeUnary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;expressionType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression, given an operand, by calling the
 appropriate factory method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)" class="member-name-link">makeUnary</a><wbr>(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;expressionType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression, given an operand and implementing
 method, by calling the appropriate factory method.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberBind(java.lang.reflect.Member,java.lang.Iterable)" class="member-name-link">memberBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</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 MemberMemberBinding that represents the recursive
 initialization of members of a field or property.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.MemberBinding...)" class="member-name-link">memberBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</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 MemberMemberBinding that represents the recursive
 initialization of members of a field or property, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberBind(java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">memberBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</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 MemberMemberBinding that represents the recursive
 initialization of members of a member that is accessed by using
 a property accessor method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.MemberBinding...)" class="member-name-link">memberBind</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</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 MemberMemberBinding that represents the recursive
 initialization of members of a member that is accessed by using
 a property accessor method, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)" class="member-name-link">memberInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#memberInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.MemberBinding...)" class="member-name-link">memberInit</a><wbr>(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MethodDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MethodDeclaration</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#methodDecl(int,java.lang.reflect.Type,java.lang.String,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)" class="member-name-link">methodDecl</a><wbr>(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;resultType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Declares a method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">modulo</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">modulo</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 remainder operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">moduloAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">moduloAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a remainder
 assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">moduloAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a remainder
 assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">multiply</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">multiply</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">multiplyAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">multiplyAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">multiplyAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">multiplyAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">multiplyAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">multiplyAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">multiplyChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">multiplyChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#negate(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">negate</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents an arithmetic
 negation operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#negate(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">negate</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents an arithmetic
 negation operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#negateChecked(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">negateChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents an arithmetic
 negation operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#negateChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">negateChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents an arithmetic
 negation operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Constructor)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor)</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 NewExpression that represents calling the specified
 constructor that takes no arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</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 NewExpression that represents calling the specified
 constructor with the specified arguments.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable,java.lang.Iterable)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions,
 <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</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 NewExpression that represents calling the specified
 constructor with the specified arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions,
 <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>...&nbsp;memberDeclarations)</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 NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Constructor,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</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 NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Type)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a NewExpression that represents calling the
 parameterless constructor of the specified 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="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Type,java.lang.Iterable)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</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 NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Type,java.lang.Iterable,java.lang.Iterable)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments,
 @Nullable <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</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 NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments,
 <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>...&nbsp;memberDeclarations)</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 NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#new_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">new_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</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 NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newArrayBounds(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">newArrayBounds</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;bound)</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 NewArrayExpression that represents creating an array
 that has a specified rank.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newArrayInit(java.lang.reflect.Type,int,java.lang.Iterable)" class="member-name-link">newArrayInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</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 NewArrayExpression that represents creating a
 n-dimensional array and initializing it from a list of
 elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newArrayInit(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">newArrayInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</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 NewArrayExpression that represents creating an
 n-dimensional array and initializing it from a list of
 elements, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newArrayInit(java.lang.reflect.Type,java.lang.Iterable)" class="member-name-link">newArrayInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</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 NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#newArrayInit(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">newArrayInit</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</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 NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#not(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">not</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents a bitwise complement
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#not(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">not</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents a bitwise complement
 operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">notEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)" class="member-name-link">notEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an inequality
 comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#onesComplement(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">onesComplement</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the expression representing the ones complement.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#onesComplement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">onesComplement</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 expression representing the ones complement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">or</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">or</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise OR
 operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">orAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">orAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">orAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">orElse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a conditional OR
 operation that evaluates the second operand only if the first
 operand evaluates to false.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">orElse</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a conditional OR
 operation that evaluates the second operand only if the first
 operand evaluates to false.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#parameter(int,java.lang.reflect.Type,java.lang.String)" class="member-name-link">parameter</a><wbr>(int&nbsp;modifiers,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</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 ParameterExpression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#parameter(java.lang.reflect.Type)" class="member-name-link">parameter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#parameter(java.lang.reflect.Type,java.lang.String)" class="member-name-link">parameter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</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 ParameterExpression node that can be used to
 identify a parameter or a variable in an expression 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#postDecrementAssign(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">postDecrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents the assignment of
 the expression followed by a subsequent decrement by 1 of the
 original 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#postDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">postDecrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents the assignment of
 the expression followed by a subsequent decrement by 1 of the
 original 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#postIncrementAssign(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">postIncrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents the assignment of
 the expression followed by a subsequent increment by 1 of the
 original 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#postIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">postIncrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents the assignment of
 the expression followed by a subsequent increment by 1 of the
 original 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">power</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">power</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents raising a number to
 a power.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">powerAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">powerAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">powerAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#preDecrementAssign(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">preDecrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that decrements the expression by 1
 and assigns the result back to the 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#preDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">preDecrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that decrements the expression by 1
 and assigns the result back to the 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#preIncrementAssign(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">preIncrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that increments the expression by 1
 and assigns the result back to the 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="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#preIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">preIncrementAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that increments the expression by 1
 and assigns the result back to the 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="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 MemberExpression that represents accessing a
 property by using a property accessor method.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</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 MemberExpression accessing a property.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.String)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</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 MemberExpression that represents accessing a
 property.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property)</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 MemberExpression that represents accessing a
 property.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,java.lang.Iterable)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">property</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#propertyOrField(org.apache.calcite.linq4j.tree.Expression,java.lang.String)" class="member-name-link">propertyOrField</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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;propertyOfFieldName)</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 MemberExpression that represents accessing a
 property or field.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#quote(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">quote</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents an expression that
 has a constant value of type 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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reduce(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">reduce</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Reduces this node to a simpler 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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reduceAndCheck(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">reduceAndCheck</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Reduces this node to a simpler 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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reduceExtensions(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">reduceExtensions</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Reduces the expression to a known node type (that is not an
 Extension node) or just returns the expression if it is already
 a known 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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#referenceEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">referenceEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a reference
 equality comparison.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#referenceNotEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">referenceNotEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a reference
 inequality comparison.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rethrow()" class="member-name-link">rethrow</a>()</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 UnaryExpression that represents a rethrowing of an
 exception.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rethrow(java.lang.reflect.Type)" class="member-name-link">rethrow</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception with a given 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="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">return_</a><wbr>(@Nullable <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 GotoExpression representing a return statement.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget)" class="member-name-link">return_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</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 GotoExpression representing a return statement.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)" class="member-name-link">return_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 GotoExpression representing a return statement with
 the specified type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">return_</a><wbr>(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a GotoExpression representing a return statement with
 the specified 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">rightShift</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise
 right-shift operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">rightShift</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise
 right-shift operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">rightShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">rightShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">rightShiftAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#runtimeVariables(java.lang.Iterable)" class="member-name-link">runtimeVariables</a><wbr>(<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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;expressions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of RuntimeVariablesExpression.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#runtimeVariables(org.apache.calcite.linq4j.tree.ParameterExpression...)" class="member-name-link">runtimeVariables</a><wbr>(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;arguments)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of RuntimeVariablesExpression, using varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#statement(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">statement</a><wbr>(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 statement that executes an 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="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">subtract</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">subtract</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">subtractAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">subtractAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">subtractAssign</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">subtractAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</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">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">subtractAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)" class="member-name-link">subtractAssignChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</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 BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">subtractChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</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 BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">subtractChecked</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">switch_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</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 SwitchExpression that represents a switch statement
 that has a default case.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.SwitchCase...)" class="member-name-link">switch_</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</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 SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)" class="member-name-link">switch_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</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 SwitchExpression that represents a switch statement
 that has a default case.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.SwitchCase...)" class="member-name-link">switch_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</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 SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)" class="member-name-link">switch_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</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 SwitchExpression that represents a switch statement
 that has a default case.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)" class="member-name-link">switch_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</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 SwitchExpression that represents a switch statement
 without a default case.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switchCase(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)" class="member-name-link">switchCase</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;body)</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 SwitchCase for use in a SwitchExpression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#switchCase(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)" class="member-name-link">switchCase</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;body)</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 SwitchCase for use in a SwitchExpression, with varargs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#symbolDocument(java.lang.String)" class="member-name-link">symbolDocument</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;fileName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#symbolDocument(java.lang.String,java.util.UUID)" class="member-name-link">symbolDocument</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;fileName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#symbolDocument(java.lang.String,java.util.UUID,java.util.UUID)" class="member-name-link">symbolDocument</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;fileName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;vendor)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#symbolDocument(java.lang.String,java.util.UUID,java.util.UUID,java.util.UUID)" class="member-name-link">symbolDocument</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;filename,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;vendor,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;documentType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="ThrowStatement.html" title="class in org.apache.calcite.linq4j.tree">ThrowStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#throw_(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">throw_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 statement that represents the throwing of an exception.</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="#toString(java.util.List,java.lang.String,boolean)" class="member-name-link">toString</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="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&gt;&nbsp;expressions,
 <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;sep,
 boolean&nbsp;generics)</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 list of expressions to Java source code, optionally emitting
 extra type information in generics.</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.linq4j.tree.Node)" class="member-name-link">toString</a><wbr>(<a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;expression)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an expression to Java source 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="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tryCatch(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable)" class="member-name-link">tryCatch</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</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 TryExpression representing a try block with any
 number of catch statements and neither a fault nor finally
 block.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tryCatch(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)" class="member-name-link">tryCatch</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</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 TryExpression representing a try block with any
 number of catch statements and neither a fault nor finally
 block, with varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">tryCatchFinally</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_)</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 TryExpression representing a try block with any
 number of catch statements and a finally block.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)" class="member-name-link">tryCatchFinally</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</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 TryExpression representing a try block with any
 number of catch statements and a finally block, with varargs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tryFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">tryFinally</a><wbr>(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_)</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 TryExpression representing a try block with a
 finally block and no catch statements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#typeAs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">typeAs</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 UnaryExpression that represents an explicit
 reference or boxing conversion where null is supplied if the
 conversion fails.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#typeEqual(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">typeEqual</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a TypeBinaryExpression that compares run-time type
 identity.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#typeIs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">typeIs</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 TypeBinaryExpression.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unaryPlus(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">unaryPlus</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</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 UnaryExpression that represents a unary plus
 operation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unaryPlus(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)" class="member-name-link">unaryPlus</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</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 UnaryExpression that represents a unary plus
 operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unbox(org.apache.calcite.linq4j.tree.Expression)" class="member-name-link">unbox</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts e.g.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unbox(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)" class="member-name-link">unbox</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 UnaryExpression that represents an explicit
 unboxing.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unbox(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)" class="member-name-link">unbox</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Primitive.html" title="enum in org.apache.calcite.linq4j.tree">Primitive</a>&nbsp;primitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an expression to unbox the value of a boxed-primitive 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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#variable(java.lang.reflect.Type)" class="member-name-link">variable</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</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 ParameterExpression node that can be used to
 identify a parameter or a variable in an expression 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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#variable(java.lang.reflect.Type,java.lang.String)" class="member-name-link">variable</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</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 ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#visitChildren(org.apache.calcite.linq4j.tree.ExpressionVisitor)" class="member-name-link">visitChildren</a><wbr>(<a href="ExpressionVisitor.html" title="interface in org.apache.calcite.linq4j.tree">ExpressionVisitor</a>&nbsp;visitor)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Reduces the node and then calls the visitor delegate on the
 reduced 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="WhileStatement.html" title="class in org.apache.calcite.linq4j.tree">WhileStatement</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#while_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)" class="member-name-link">while_</a><wbr>(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</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 WhileExpression representing a while loop.</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">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="toString(java.util.List,java.lang.String,boolean)">
<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="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="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&gt;&nbsp;expressions,
 <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;sep,
 boolean&nbsp;generics)</span></div>
<div class="block">Converts a list of expressions to Java source code, optionally emitting
 extra type information in generics.</div>
</section>
</li>
<li>
<section class="detail" id="toString(org.apache.calcite.linq4j.tree.Node)">
<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="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;expression)</span></div>
<div class="block">Converts an expression to Java source code.</div>
</section>
</li>
<li>
<section class="detail" id="add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking. The
 implementing method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>addAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>addAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>addAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaLeft,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaRight)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>addAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>addAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>addAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>addChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>addChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">addChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that has overflow checking. The implementing
 method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>and</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">and</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>and</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">and</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 operation. The implementing method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>andAlso</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">andAlso</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a conditional AND
 operation that evaluates the second operand only if the first
 operand evaluates to true.</div>
</section>
</li>
<li>
<section class="detail" id="andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>andAlso</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">andAlso</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a conditional AND
 operation that evaluates the second operand only if the first
 operand is resolved to true. The implementing method can be
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>andAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">andAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>andAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">andAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>andAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">andAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="arrayIndex(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>arrayIndex</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="element-name">arrayIndex</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;array,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;indexExpression)</span></div>
<div class="block">Creates an expression that represents applying an array
 index operator to an array of rank one.</div>
</section>
</li>
<li>
<section class="detail" id="arrayLength(org.apache.calcite.linq4j.tree.Expression)">
<h3>arrayLength</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">arrayLength</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;array)</span></div>
<div class="block">Creates a UnaryExpression that represents an expression for
 obtaining the length of a one-dimensional array.</div>
</section>
</li>
<li>
<section class="detail" id="assign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>assign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">assign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an assignment
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="bind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.Expression)">
<h3>bind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></span>&nbsp;<span class="element-name">bind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a MemberAssignment that represents the initialization
 of a field or property.</div>
</section>
</li>
<li>
<section class="detail" id="bind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression)">
<h3>bind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></span>&nbsp;<span class="element-name">bind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a MemberAssignment that represents the initialization
 of a member by using a property accessor method.</div>
</section>
</li>
<li>
<section class="detail" id="block(java.lang.Iterable)">
<h3>block</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="element-name">block</span><wbr><span class="parameters">(<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="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;statements)</span></div>
<div class="block">Creates a BlockExpression that contains the given statements.</div>
</section>
</li>
<li>
<section class="detail" id="block(org.apache.calcite.linq4j.tree.Statement...)">
<h3>block</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="element-name">block</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</span></div>
<div class="block">Creates a BlockExpression that contains the given statements,
 using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="block(java.lang.reflect.Type,java.lang.Iterable)">
<h3>block</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="element-name">block</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates a BlockExpression that contains the given expressions,
 has no variables and has specific result type.</div>
</section>
</li>
<li>
<section class="detail" id="block(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Statement...)">
<h3>block</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="element-name">block</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</span></div>
<div class="block">Creates a BlockExpression that contains the given statements
 and has a specific result type, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="break_(org.apache.calcite.linq4j.tree.LabelTarget)">
<h3>break_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">break_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</span></div>
<div class="block">Creates a GotoExpression representing a break statement.</div>
</section>
</li>
<li>
<section class="detail" id="break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">
<h3>break_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">break_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a GotoExpression representing a break statement. The
 value passed to the label upon jumping can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="break_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">
<h3>break_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">break_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a break statement with
 the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>break_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">break_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a break statement with
 the specified type. The value passed to the label upon jumping
 can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Method,java.lang.Iterable)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method that has arguments.</div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method that has arguments, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments.</div>
</section>
</li>
<li>
<section class="detail" id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;returnType,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type.

 <p>The return type must be consistent with the return type of the method,
 but may contain extra information, such as type parameters.</p>

 <p>The <code>expression</code> argument may be null if and only if the method
 is static.</p></div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;returnType,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type, with varargs.

 <p>The return type must be consistent with the return type of the method,
 but may contain extra information, such as type parameters.</p>

 <p>The <code>expression</code> argument may be null if and only if the method
 is static.</p></div>
</section>
</li>
<li>
<section class="detail" id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,java.lang.Iterable)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
 <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;methodName,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
 <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;methodName,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Type,java.lang.String,java.lang.Iterable)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;methodName,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="call(java.lang.reflect.Type,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">
<h3>call</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="element-name">call</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;methodName,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="catch_(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Statement)">
<h3>catch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></span>&nbsp;<span class="element-name">catch_</span><wbr><span class="parameters">(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;statement)</span></div>
<div class="block">Creates a CatchBlock representing a catch statement with a
 reference to the caught Exception object for use in the handler
 body.</div>
</section>
</li>
<li>
<section class="detail" id="clearDebugInfo()">
<h3>clearDebugInfo</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearDebugInfo</span>()</div>
<div class="block">Creates a DebugInfoExpression for clearing a sequence
 point.</div>
</section>
</li>
<li>
<section class="detail" id="coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>coalesce</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">coalesce</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a coalescing
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>coalesce</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">coalesce</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a coalescing
 operation, given a conversion function.</div>
</section>
</li>
<li>
<section class="detail" id="condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>condition</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">condition</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifTrue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifFalse)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 statement.</div>
</section>
</li>
<li>
<section class="detail" id="isConstantNull(org.apache.calcite.linq4j.tree.Expression)">
<h3>isConstantNull</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isConstantNull</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e)</span></div>
<div class="block">Returns whether an expression always evaluates to null.</div>
</section>
</li>
<li>
<section class="detail" id="condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>condition</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConditionalExpression.html" title="class in org.apache.calcite.linq4j.tree">ConditionalExpression</a></span>&nbsp;<span class="element-name">condition</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifTrue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;ifFalse,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 statement.

 <p>This method allows explicitly unifying the result type of the
 conditional expression in cases where the types of ifTrue and ifFalse
 expressions are not equal. Types of both ifTrue and ifFalse must be
 implicitly reference assignable to the result type. The type is allowed
 to be <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Void.html#TYPE" title="class or interface in java.lang" class="external-link"><code>void</code></a>.</p></div>
</section>
</li>
<li>
<section class="detail" id="constant(java.lang.Object)">
<h3>constant</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></span>&nbsp;<span class="element-name">constant</span><wbr><span class="parameters">(@Nullable <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;value)</span></div>
<div class="block">Creates a ConstantExpression that has the Value property set
 to the specified value.

 <p>Does the right thing for null, String, primitive values (e.g. int 12,
 short 12, double 3.14 and boolean false), boxed primitives
 (e.g. Integer.valueOf(12)), enums, classes, BigDecimal, BigInteger,
 classes that have a constructor with a parameter for each field, and
 arrays.</p></div>
</section>
</li>
<li>
<section class="detail" id="constant(java.lang.Object,java.lang.reflect.Type)">
<h3>constant</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></span>&nbsp;<span class="element-name">constant</span><wbr><span class="parameters">(@Nullable <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;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a ConstantExpression that has the Value and Type
 properties set to the specified values.</div>
</section>
</li>
<li>
<section class="detail" id="continue_(org.apache.calcite.linq4j.tree.LabelTarget)">
<h3>continue_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">continue_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</span></div>
<div class="block">Creates a GotoExpression representing a continue statement.</div>
</section>
</li>
<li>
<section class="detail" id="continue_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">
<h3>continue_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">continue_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a continue statement
 with the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>convert_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">convert_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents a type conversion
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">
<h3>convert_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">convert_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents a conversion
 operation for which the implementing method is specified.</div>
</section>
</li>
<li>
<section class="detail" id="convertChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>convertChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">convertChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents a conversion
 operation that throws an exception if the target type is
 overflowed.</div>
</section>
</li>
<li>
<section class="detail" id="convertChecked_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">
<h3>convertChecked_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">convertChecked_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents a conversion
 operation that throws an exception if the target type is
 overflowed and for which the implementing method is
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="debugInfo()">
<h3>debugInfo</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">debugInfo</span>()</div>
<div class="block">Creates a DebugInfoExpression with the specified span.</div>
</section>
</li>
<li>
<section class="detail" id="decrement(org.apache.calcite.linq4j.tree.Expression)">
<h3>decrement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">decrement</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</section>
</li>
<li>
<section class="detail" id="decrement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>decrement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">decrement</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</section>
</li>
<li>
<section class="detail" id="default_()">
<h3>default_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></span>&nbsp;<span class="element-name">default_</span>()</div>
<div class="block">Creates a DefaultExpression that has the Type property set to
 the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 division operation.</div>
</section>
</li>
<li>
<section class="detail" id="divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>divide</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">divide</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 division operation. The implementing method can be
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>divideAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">divideAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>divideAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">divideAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>divideAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">divideAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,java.lang.Iterable)">
<h3>dynamic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="element-name">dynamic</span><wbr><span class="parameters">(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</section>
</li>
<li>
<section class="detail" id="dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">
<h3>dynamic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="element-name">dynamic</span><wbr><span class="parameters">(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expression)</span></div>
<div class="block">Creates a <code>DynamicExpression</code> that represents a dynamic
 operation bound by the provided <code>CallSiteBinder</code>, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="elementInit(java.lang.reflect.Method,java.lang.Iterable)">
<h3>elementInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></span>&nbsp;<span class="element-name">elementInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates an <code>ElementInit</code>, given an <code>Iterable&lt;T&gt;</code> as the second
 argument.</div>
</section>
</li>
<li>
<section class="detail" id="elementInit(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">
<h3>elementInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></span>&nbsp;<span class="element-name">elementInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</span></div>
<div class="block">Creates an ElementInit, given an array of values as the second
 argument, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="empty()">
<h3>empty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></span>&nbsp;<span class="element-name">empty</span>()</div>
<div class="block">Creates an empty expression that has Void type.</div>
</section>
</li>
<li>
<section class="detail" id="equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>equal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">equal</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an equality
 comparison.</div>
</section>
</li>
<li>
<section class="detail" id="equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>equal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">equal</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression0,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression1,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an equality
 comparison. The implementing method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>exclusiveOr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">exclusiveOr</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined types.</div>
</section>
</li>
<li>
<section class="detail" id="exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>exclusiveOr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">exclusiveOr</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined types. The
 implementing method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>exclusiveOrAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">exclusiveOrAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</section>
</li>
<li>
<section class="detail" id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>exclusiveOrAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">exclusiveOrAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</section>
</li>
<li>
<section class="detail" id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>exclusiveOrAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">exclusiveOrAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</section>
</li>
<li>
<section class="detail" id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Field)">
<h3>field</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">field</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html" title="class or interface in java.lang.reflect" class="external-link">Field</a>&nbsp;field)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li>
<section class="detail" id="field(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">
<h3>field</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">field</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="PseudoField.html" title="interface in org.apache.calcite.linq4j.tree">PseudoField</a>&nbsp;field)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li>
<section class="detail" id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">
<h3>field</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">field</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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;fieldName)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field
 given the name of the field.</div>
</section>
</li>
<li>
<section class="detail" id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">
<h3>field</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">field</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;fieldName)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li>
<section class="detail" id="getActionType(java.lang.Class...)">
<h3>getActionType</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></span>&nbsp;<span class="element-name">getActionType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</span></div>
<div class="block">Creates a Type object that represents a generic System.Action
 delegate type that has specific type arguments.</div>
</section>
</li>
<li>
<section class="detail" id="getDelegateType(java.lang.Class...)">
<h3>getDelegateType</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></span>&nbsp;<span class="element-name">getDelegateType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</span></div>
<div class="block">Gets a Type object that represents a generic System.Func or
 System.Action delegate type that has specific type
 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="getFuncType(java.lang.Class...)">
<h3>getFuncType</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/Class.html" title="class or interface in java.lang" class="external-link">Class</a></span>&nbsp;<span class="element-name">getFuncType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>...&nbsp;typeArgs)</span></div>
<div class="block">Creates a Type object that represents a generic System.Func
 delegate type that has specific type arguments. The last type
 argument specifies the return type of the created delegate.</div>
</section>
</li>
<li>
<section class="detail" id="goto_(org.apache.calcite.linq4j.tree.LabelTarget)">
<h3>goto_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">goto_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</span></div>
<div class="block">Creates a GotoExpression representing a "go to" statement.</div>
</section>
</li>
<li>
<section class="detail" id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">
<h3>goto_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">goto_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a GotoExpression representing a "go to" statement. The
 value passed to the label upon jumping can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">
<h3>goto_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">goto_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>goto_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">goto_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified type. The value passed to the label upon jumping
 can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>greaterThan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">greaterThan</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a "greater than"
 numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>greaterThan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">greaterThan</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a "greater than"
 numeric comparison. The implementing method can be
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>greaterThanOrEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">greaterThanOrEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>greaterThanOrEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">greaterThanOrEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="ifThen(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node)">
<h3>ifThen</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="element-name">ifThen</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifTrue)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with an if statement.</div>
</section>
</li>
<li>
<section class="detail" id="ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node,org.apache.calcite.linq4j.tree.Node)">
<h3>ifThenElse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="element-name">ifThenElse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifTrue,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;ifFalse)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with if and else statements.</div>
</section>
</li>
<li>
<section class="detail" id="ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node...)">
<h3>ifThenElse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="element-name">ifThenElse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;test,
 <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>...&nbsp;nodes)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with if and else statements:
 <code>if (test) stmt1 [ else if (test2) stmt2 ]... [ else stmtN ]</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ifThenElse(java.lang.Iterable)">
<h3>ifThenElse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="element-name">ifThenElse</span><wbr><span class="parameters">(<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="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&gt;&nbsp;nodes)</span></div>
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with if and else statements:
 <code>if (test) stmt1 [ else if (test2) stmt2 ]... [ else stmtN ]</code>.</div>
</section>
</li>
<li>
<section class="detail" id="increment(org.apache.calcite.linq4j.tree.Expression)">
<h3>increment</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">increment</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents the incrementing of
 the expression value by 1.</div>
</section>
</li>
<li>
<section class="detail" id="increment(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>increment</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">increment</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents the incrementing of
 the expression by 1.</div>
</section>
</li>
<li>
<section class="detail" id="invoke(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">
<h3>invoke</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></span>&nbsp;<span class="element-name">invoke</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions.</div>
</section>
</li>
<li>
<section class="detail" id="invoke(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">
<h3>invoke</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></span>&nbsp;<span class="element-name">invoke</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="isFalse(org.apache.calcite.linq4j.tree.Expression)">
<h3>isFalse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">isFalse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Returns whether the expression evaluates to false.</div>
</section>
</li>
<li>
<section class="detail" id="isFalse(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>isFalse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">isFalse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Returns whether the expression evaluates to false.</div>
</section>
</li>
<li>
<section class="detail" id="isTrue(org.apache.calcite.linq4j.tree.Expression)">
<h3>isTrue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">isTrue</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Returns whether the expression evaluates to true.</div>
</section>
</li>
<li>
<section class="detail" id="isTrue(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>isTrue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">isTrue</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Returns whether the expression evaluates to true.</div>
</section>
</li>
<li>
<section class="detail" id="label()">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="element-name">label</span>()</div>
<div class="block">Creates a LabelTarget representing a label with X type and
 no name.</div>
</section>
</li>
<li>
<section class="detail" id="label(org.apache.calcite.linq4j.tree.LabelTarget)">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></span>&nbsp;<span class="element-name">label</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</span></div>
<div class="block">Creates a LabelExpression representing a label without a
 default value.</div>
</section>
</li>
<li>
<section class="detail" id="label(java.lang.String)">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="element-name">label</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;name)</span></div>
<div class="block">Creates a LabelTarget representing a label with X type and
 the given name.</div>
</section>
</li>
<li>
<section class="detail" id="label(java.lang.reflect.Type)">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="element-name">label</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a LabelTarget representing a label with the given
 type.</div>
</section>
</li>
<li>
<section class="detail" id="label(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></span>&nbsp;<span class="element-name">label</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a LabelExpression representing a label with the given
 default value.</div>
</section>
</li>
<li>
<section class="detail" id="label(java.lang.reflect.Type,java.lang.String)">
<h3>label</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="element-name">label</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</span></div>
<div class="block">Creates a LabelTarget representing a label with the given type
 and name.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(F)">
<h3 id="lambda(org.apache.calcite.linq4j.function.Function)">lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(F&nbsp;function)</span></div>
<div class="block">Creates a FunctionExpression from an actual function.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</span></div>
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</span></div>
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.

 <p>It can be used when the delegate type is not known at compile time.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.

 <p>It can be used when the delegate type is not known at compile time.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.

 <p>It can be used when the delegate type is not known at compile time.</div>
</section>
</li>
<li>
<section class="detail" id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">
<h3>lambda</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T,<wbr>
F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;? extends T&gt;&gt;</span>
<span class="return-type"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="element-name">lambda</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;F&gt;&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;parameters)</span></div>
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.

 <p>It can be used when the delegate type is not known at compile time.</div>
</section>
</li>
<li>
<section class="detail" id="leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>leftShift</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">leftShift</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift operation.</div>
</section>
</li>
<li>
<section class="detail" id="leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>leftShift</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">leftShift</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift operation.</div>
</section>
</li>
<li>
<section class="detail" id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>leftShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">leftShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>leftShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">leftShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>leftShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">leftShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>lessThan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">lessThan</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>lessThan</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">lessThan</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>lessThanOrEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">lessThanOrEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a " less than or
 equal" numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>lessThanOrEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">lessThanOrEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a "less than or
 equal" numeric comparison.</div>
</section>
</li>
<li>
<section class="detail" id="listBind(java.lang.reflect.Member,java.lang.Iterable)">
<h3>listBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="element-name">listBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</span></div>
<div class="block">Creates a MemberListBinding where the member is a field or
 property.</div>
</section>
</li>
<li>
<section class="detail" id="listBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.ElementInit...)">
<h3>listBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="element-name">listBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</span></div>
<div class="block">Creates a MemberListBinding where the member is a field or
 property, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="listBind(java.lang.reflect.Method,java.lang.Iterable)">
<h3>listBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="element-name">listBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</span></div>
<div class="block">Creates a MemberListBinding based on a specified property
 accessor method.</div>
</section>
</li>
<li>
<section class="detail" id="listBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.ElementInit...)">
<h3>listBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="element-name">listBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</span></div>
<div class="block">Creates a MemberListBinding object based on a specified
 property accessor method, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">
<h3>listInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</span></div>
<div class="block">Creates a ListInitExpression that uses specified ElementInit
 objects to initialize a collection.</div>
</section>
</li>
<li>
<section class="detail" id="listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.ElementInit...)">
<h3>listInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</span></div>
<div class="block">Creates a ListInitExpression that uses specified ElementInit
 objects to initialize a collection, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="listInitE(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">
<h3>listInitE</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInitE</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a ListInitExpression that uses a method named "Add" to
 add elements to a collection.</div>
</section>
</li>
<li>
<section class="detail" id="listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.Expression...)">
<h3>listInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a ListInitExpression that uses a method named "Add" to
 add elements to a collection, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,java.lang.Iterable)">
<h3>listInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a ListInitExpression that uses a specified method to
 add elements to a collection.</div>
</section>
</li>
<li>
<section class="detail" id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">
<h3>listInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="element-name">listInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a ListInitExpression that uses a specified method to
 add elements to a collection, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="for_(java.lang.Iterable,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">
<h3>for_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></span>&nbsp;<span class="element-name">for_</span><wbr><span class="parameters">(<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="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a>&gt;&nbsp;declarations,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;post,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</span></div>
<div class="block">Creates a LoopExpression with the given body.</div>
</section>
</li>
<li>
<section class="detail" id="for_(org.apache.calcite.linq4j.tree.DeclarationStatement,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">
<h3>for_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></span>&nbsp;<span class="element-name">for_</span><wbr><span class="parameters">(<a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a>&nbsp;declaration,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;post,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</span></div>
<div class="block">Creates a LoopExpression with the given body.</div>
</section>
</li>
<li>
<section class="detail" id="forEach(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">
<h3>forEach</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ForEachStatement.html" title="class in org.apache.calcite.linq4j.tree">ForEachStatement</a></span>&nbsp;<span class="element-name">forEach</span><wbr><span class="parameters">(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;iterable,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</span></div>
<div class="block">Creates a ForEachExpression with the given body.</div>
</section>
</li>
<li>
<section class="detail" id="makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>makeBinary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">makeBinary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="box(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">
<h3>box</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">box</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Primitive.html" title="enum in org.apache.calcite.linq4j.tree">Primitive</a>&nbsp;primitive)</span></div>
<div class="block">Returns an expression to box the value of a primitive expression.
 E.g. <code>box(e, Primitive.INT)</code> returns <code>Integer.valueOf(e)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="box(org.apache.calcite.linq4j.tree.Expression)">
<h3>box</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">box</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Converts e.g. "anInteger" to "Integer.valueOf(anInteger)".</div>
</section>
</li>
<li>
<section class="detail" id="unbox(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">
<h3>unbox</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">unbox</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Primitive.html" title="enum in org.apache.calcite.linq4j.tree">Primitive</a>&nbsp;primitive)</span></div>
<div class="block">Returns an expression to unbox the value of a boxed-primitive expression.
 E.g. <code>unbox(e, Primitive.INT)</code> returns <code>e.intValue()</code>.
 It is assumed that e is of the right box type (or <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link"><code>Number</code></a>)."Value</div>
</section>
</li>
<li>
<section class="detail" id="unbox(org.apache.calcite.linq4j.tree.Expression)">
<h3>unbox</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">unbox</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Converts e.g. "anInteger" to "anInteger.intValue()".</div>
</section>
</li>
<li>
<section class="detail" id="makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>makeBinary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">makeBinary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression, given the left operand, right
 operand and implementing method, by calling the appropriate
 factory method.</div>
</section>
</li>
<li>
<section class="detail" id="makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>makeBinary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">makeBinary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;binaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression, given the left operand, right
 operand, implementing method and type conversion function, by
 calling the appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="makeTernary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>makeTernary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TernaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TernaryExpression</a></span>&nbsp;<span class="element-name">makeTernary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;ternaryType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e0,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e1,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e2)</span></div>
<div class="block">Creates a TernaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="makeCatchBlock(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>makeCatchBlock</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></span>&nbsp;<span class="element-name">makeCatchBlock</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;variable,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;filter)</span></div>
<div class="block">Creates a CatchBlock representing a catch statement with the
 specified elements.</div>
</section>
</li>
<li>
<section class="detail" id="makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.Iterable)">
<h3>makeDynamic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="element-name">makeDynamic</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</section>
</li>
<li>
<section class="detail" id="makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,org.apache.calcite.linq4j.tree.Expression...)">
<h3>makeDynamic</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="element-name">makeDynamic</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>makeGoto</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">makeGoto</span><wbr><span class="parameters">(<a href="GotoExpressionKind.html" title="enum in org.apache.calcite.linq4j.tree">GotoExpressionKind</a>&nbsp;kind,
 <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;target,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;value,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a jump of the specified
 GotoExpressionKind. The value passed to the label upon jumping
 can also be specified.</div>
</section>
</li>
<li>
<section class="detail" id="makeMemberAccess(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">
<h3>makeMemberAccess</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">makeMemberAccess</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="PseudoField.html" title="interface in org.apache.calcite.linq4j.tree">PseudoField</a>&nbsp;member)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li>
<section class="detail" id="makeTry(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">
<h3>makeTry</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">makeTry</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;finally_,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;fault,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</span></div>
<div class="block">Creates a TryExpression representing a try block with the
 specified elements.</div>
</section>
</li>
<li>
<section class="detail" id="makeTry(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.CatchBlock...)">
<h3>makeTry</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">makeTry</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;finally_,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;fault,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</span></div>
<div class="block">Creates a TryExpression representing a try block with the
 specified elements, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression)">
<h3>makeUnary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">makeUnary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;expressionType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression, given an operand, by calling the
 appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">
<h3>makeUnary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">makeUnary</span><wbr><span class="parameters">(<a href="ExpressionType.html" title="enum in org.apache.calcite.linq4j.tree">ExpressionType</a>&nbsp;expressionType,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression, given an operand and implementing
 method, by calling the appropriate factory method.</div>
</section>
</li>
<li>
<section class="detail" id="memberBind(java.lang.reflect.Member,java.lang.Iterable)">
<h3>memberBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="element-name">memberBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</span></div>
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a field or property.</div>
</section>
</li>
<li>
<section class="detail" id="memberBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.MemberBinding...)">
<h3>memberBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="element-name">memberBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Member.html" title="class or interface in java.lang.reflect" class="external-link">Member</a>&nbsp;member,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</span></div>
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a field or property, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="memberBind(java.lang.reflect.Method,java.lang.Iterable)">
<h3>memberBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="element-name">memberBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</span></div>
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a member that is accessed by using
 a property accessor method.</div>
</section>
</li>
<li>
<section class="detail" id="memberBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.MemberBinding...)">
<h3>memberBind</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="element-name">memberBind</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</span></div>
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a member that is accessed by using
 a property accessor method, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="memberInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">
<h3>memberInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></span>&nbsp;<span class="element-name">memberInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <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="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</span></div>
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object.</div>
</section>
</li>
<li>
<section class="detail" id="memberInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.MemberBinding...)">
<h3>memberInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></span>&nbsp;<span class="element-name">memberInit</span><wbr><span class="parameters">(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
 <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</span></div>
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="methodDecl(int,java.lang.reflect.Type,java.lang.String,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">
<h3>methodDecl</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MethodDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MethodDeclaration</a></span>&nbsp;<span class="element-name">methodDecl</span><wbr><span class="parameters">(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;resultType,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body)</span></div>
<div class="block">Declares a method.</div>
</section>
</li>
<li>
<section class="detail" id="constructorDecl(int,java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">
<h3>constructorDecl</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ConstructorDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ConstructorDeclaration</a></span>&nbsp;<span class="element-name">constructorDecl</span><wbr><span class="parameters">(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;declaredAgainst,
 <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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters,
 <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body)</span></div>
<div class="block">Declares a constructor.</div>
</section>
</li>
<li>
<section class="detail" id="fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">
<h3>fieldDecl</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></span>&nbsp;<span class="element-name">fieldDecl</span><wbr><span class="parameters">(int&nbsp;modifier,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</span></div>
<div class="block">Declares a field with an initializer.</div>
</section>
</li>
<li>
<section class="detail" id="fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression)">
<h3>fieldDecl</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></span>&nbsp;<span class="element-name">fieldDecl</span><wbr><span class="parameters">(int&nbsp;modifier,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter)</span></div>
<div class="block">Declares a field.</div>
</section>
</li>
<li>
<section class="detail" id="classDecl(int,java.lang.String,java.lang.reflect.Type,java.util.List,java.util.List)">
<h3>classDecl</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ClassDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ClassDeclaration</a></span>&nbsp;<span class="element-name">classDecl</span><wbr><span class="parameters">(int&nbsp;modifier,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;extended,
 <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/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&gt;&nbsp;implemented,
 <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</span></div>
<div class="block">Declares a class.</div>
</section>
</li>
<li>
<section class="detail" id="modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>modulo</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">modulo</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</section>
</li>
<li>
<section class="detail" id="modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>modulo</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">modulo</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</section>
</li>
<li>
<section class="detail" id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>moduloAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">moduloAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>moduloAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">moduloAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>moduloAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">moduloAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>multiply</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiply</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>multiplyAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>multiplyAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>multiplyAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>multiplyAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>multiplyAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>multiplyAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>multiplyChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>multiplyChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">multiplyChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="negate(org.apache.calcite.linq4j.tree.Expression)">
<h3>negate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">negate</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation.</div>
</section>
</li>
<li>
<section class="detail" id="negate(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>negate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">negate</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation.</div>
</section>
</li>
<li>
<section class="detail" id="negateChecked(org.apache.calcite.linq4j.tree.Expression)">
<h3>negateChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">negateChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="negateChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>negateChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">negateChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation that has overflow checking. The implementing
 method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Constructor)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor)</span></div>
<div class="block">Creates a NewExpression that represents calling the specified
 constructor that takes no arguments.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Type)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a NewExpression that represents calling the
 parameterless constructor of the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Type,java.lang.Iterable)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Type,java.lang.Iterable,java.lang.Iterable)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments,
 @Nullable <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</span></div>
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments,
 <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>...&nbsp;memberDeclarations)</span></div>
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Constructor,java.lang.Iterable)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Constructor,org.apache.calcite.linq4j.tree.Expression...)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</span></div>
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Constructor,java.lang.Iterable,java.lang.Iterable)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions,
 <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="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</span></div>
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments.

 <p>The members that access the constructor initialized fields are
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="new_(java.lang.reflect.Constructor,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">
<h3>new_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="element-name">new_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html" title="class or interface in java.lang.reflect" class="external-link">Constructor</a>&nbsp;constructor,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions,
 <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>...&nbsp;memberDeclarations)</span></div>
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.

 <p>The members that access the constructor initialized fields are
 specified.</div>
</section>
</li>
<li>
<section class="detail" id="newArrayBounds(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression)">
<h3>newArrayBounds</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="element-name">newArrayBounds</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;bound)</span></div>
<div class="block">Creates a NewArrayExpression that represents creating an array
 that has a specified rank.

 <p>For example,
 <code>newArrayBounds(int.class, 1, constant(8))</code>
 yields <code>new int[8]</code>;
 <code>newArrayBounds(int.class, 3, constant(8))</code>
 yields <code>new int[8][][]</code>;</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>dimension</code> - Dimension of the array</dd>
<dd><code>bound</code> - Size of the first dimension</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newArrayInit(java.lang.reflect.Type,java.lang.Iterable)">
<h3>newArrayInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="element-name">newArrayInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates a NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements.

 <p>For example, "<code>newArrayInit(int.class,
 Arrays.asList(constant(1), constant(2))</code>"
 yields "<code>new int[] {1, 2}</code>".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newArrayInit(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">
<h3>newArrayInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="element-name">newArrayInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</span></div>
<div class="block">Creates a NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements, using varargs.

 <p>For example, "<code>newArrayInit(int.class, constant(1), constant(2)</code>"
 yields "<code>new int[] {1, 2}</code>".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newArrayInit(java.lang.reflect.Type,int,java.lang.Iterable)">
<h3>newArrayInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="element-name">newArrayInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates a NewArrayExpression that represents creating a
 n-dimensional array and initializing it from a list of
 elements.

 <p>For example, "<code>newArrayInit(int.class, 2, Arrays.asList())</code>"
 yields "<code>new int[][] {}</code>".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>dimension</code> - Dimension of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newArrayInit(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression...)">
<h3>newArrayInit</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="element-name">newArrayInit</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 int&nbsp;dimension,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</span></div>
<div class="block">Creates a NewArrayExpression that represents creating an
 n-dimensional array and initializing it from a list of
 elements, using varargs.

 <p>For example, "<code>newArrayInit(int.class, 2)</code>"
 yields "<code>new int[][] {}</code>".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>dimension</code> - Dimension of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="not(org.apache.calcite.linq4j.tree.Expression)">
<h3>not</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">not</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents a bitwise complement
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="not(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>not</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">not</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents a bitwise complement
 operation. The implementing method can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>notEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">notEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</section>
</li>
<li>
<section class="detail" id="notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">
<h3>notEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">notEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 boolean&nbsp;liftToNull,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</section>
</li>
<li>
<section class="detail" id="onesComplement(org.apache.calcite.linq4j.tree.Expression)">
<h3>onesComplement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">onesComplement</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Returns the expression representing the ones complement.</div>
</section>
</li>
<li>
<section class="detail" id="onesComplement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>onesComplement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">onesComplement</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Returns the expression representing the ones complement.</div>
</section>
</li>
<li>
<section class="detail" id="or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>or</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">or</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>or</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">or</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>orAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">orAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>orAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">orAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>orAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">orAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>orElse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">orElse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a conditional OR
 operation that evaluates the second operand only if the first
 operand evaluates to false.</div>
</section>
</li>
<li>
<section class="detail" id="orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>orElse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">orElse</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a conditional OR
 operation that evaluates the second operand only if the first
 operand evaluates to false.</div>
</section>
</li>
<li>
<section class="detail" id="parameter(java.lang.reflect.Type)">
<h3>parameter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="element-name">parameter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</section>
</li>
<li>
<section class="detail" id="parameter(java.lang.reflect.Type,java.lang.String)">
<h3>parameter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="element-name">parameter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</span></div>
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</section>
</li>
<li>
<section class="detail" id="parameter(int,java.lang.reflect.Type,java.lang.String)">
<h3>parameter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="element-name">parameter</span><wbr><span class="parameters">(int&nbsp;modifiers,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</span></div>
<div class="block">Creates a ParameterExpression.</div>
</section>
</li>
<li>
<section class="detail" id="postDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">
<h3>postDecrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">postDecrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents the assignment of
 the expression followed by a subsequent decrement by 1 of the
 original expression.</div>
</section>
</li>
<li>
<section class="detail" id="postDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>postDecrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">postDecrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents the assignment of
 the expression followed by a subsequent decrement by 1 of the
 original expression.</div>
</section>
</li>
<li>
<section class="detail" id="postIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">
<h3>postIncrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">postIncrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents the assignment of
 the expression followed by a subsequent increment by 1 of the
 original expression.</div>
</section>
</li>
<li>
<section class="detail" id="postIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>postIncrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">postIncrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents the assignment of
 the expression followed by a subsequent increment by 1 of the
 original expression.</div>
</section>
</li>
<li>
<section class="detail" id="power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</section>
</li>
<li>
<section class="detail" id="power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>power</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">power</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</section>
</li>
<li>
<section class="detail" id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>powerAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">powerAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</section>
</li>
<li>
<section class="detail" id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>powerAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">powerAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</section>
</li>
<li>
<section class="detail" id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>powerAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">powerAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</section>
</li>
<li>
<section class="detail" id="preDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">
<h3>preDecrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">preDecrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that decrements the expression by 1
 and assigns the result back to the expression.</div>
</section>
</li>
<li>
<section class="detail" id="preDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>preDecrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">preDecrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that decrements the expression by 1
 and assigns the result back to the expression.</div>
</section>
</li>
<li>
<section class="detail" id="preIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">
<h3>preIncrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">preIncrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that increments the expression by 1
 and assigns the result back to the expression.</div>
</section>
</li>
<li>
<section class="detail" id="preIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>preIncrementAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">preIncrementAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that increments the expression by 1
 and assigns the result back to the expression.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property by using a property accessor method.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,java.lang.Iterable)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</span></div>
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,org.apache.calcite.linq4j.tree.Expression...)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 org.apache.calcite.linq4j.tree.Expressions.PropertyInfo&nbsp;property,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates an IndexExpression representing the access to an
 indexed property, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</section>
</li>
<li>
<section class="detail" id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">property</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</span></div>
<div class="block">Creates a MemberExpression accessing a property.</div>
</section>
</li>
<li>
<section class="detail" id="propertyOrField(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">
<h3>propertyOrField</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="element-name">propertyOrField</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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;propertyOfFieldName)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property or field.</div>
</section>
</li>
<li>
<section class="detail" id="quote(org.apache.calcite.linq4j.tree.Expression)">
<h3>quote</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">quote</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents an expression that
 has a constant value of type Expression.</div>
</section>
</li>
<li>
<section class="detail" id="reduce(org.apache.calcite.linq4j.tree.Expression)">
<h3>reduce</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">reduce</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Reduces this node to a simpler expression. If CanReduce
 returns true, this should return a valid expression. This
 method can return another node which itself must be reduced.</div>
</section>
</li>
<li>
<section class="detail" id="reduceAndCheck(org.apache.calcite.linq4j.tree.Expression)">
<h3>reduceAndCheck</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">reduceAndCheck</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Reduces this node to a simpler expression. If CanReduce
 returns true, this should return a valid expression. This
 method can return another node which itself must be reduced.</div>
</section>
</li>
<li>
<section class="detail" id="reduceExtensions(org.apache.calcite.linq4j.tree.Expression)">
<h3>reduceExtensions</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">reduceExtensions</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Reduces the expression to a known node type (that is not an
 Extension node) or just returns the expression if it is already
 a known type.</div>
</section>
</li>
<li>
<section class="detail" id="referenceEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>referenceEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">referenceEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a reference
 equality comparison.</div>
</section>
</li>
<li>
<section class="detail" id="referenceNotEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>referenceNotEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">referenceNotEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a reference
 inequality comparison.</div>
</section>
</li>
<li>
<section class="detail" id="rethrow()">
<h3>rethrow</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">rethrow</span>()</div>
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception.</div>
</section>
</li>
<li>
<section class="detail" id="rethrow(java.lang.reflect.Type)">
<h3>rethrow</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">rethrow</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception with a given type.</div>
</section>
</li>
<li>
<section class="detail" id="return_(org.apache.calcite.linq4j.tree.LabelTarget)">
<h3>return_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">return_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</span></div>
<div class="block">Creates a GotoExpression representing a return statement.</div>
</section>
</li>
<li>
<section class="detail" id="return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">
<h3>return_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">return_</span><wbr><span class="parameters">(@Nullable <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a GotoExpression representing a return statement. The
 value passed to the label upon jumping can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">
<h3>makeGoto</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">makeGoto</span><wbr><span class="parameters">(<a href="GotoExpressionKind.html" title="enum in org.apache.calcite.linq4j.tree">GotoExpressionKind</a>&nbsp;kind,
 @Nullable <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
</section>
</li>
<li>
<section class="detail" id="return_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">
<h3>return_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">return_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a return statement with
 the specified type.</div>
</section>
</li>
<li>
<section class="detail" id="return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>return_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="element-name">return_</span><wbr><span class="parameters">(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a return statement with
 the specified type. The value passed to the label upon jumping
 can be specified.</div>
</section>
</li>
<li>
<section class="detail" id="rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>rightShift</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">rightShift</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift operation.</div>
</section>
</li>
<li>
<section class="detail" id="rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>rightShift</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">rightShift</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift operation.</div>
</section>
</li>
<li>
<section class="detail" id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>rightShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">rightShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>rightShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">rightShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>rightShiftAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">rightShiftAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</section>
</li>
<li>
<section class="detail" id="runtimeVariables(java.lang.Iterable)">
<h3>runtimeVariables</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</span>&nbsp;<span class="element-name">runtimeVariables</span><wbr><span class="parameters">(<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="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;expressions)</span></div>
<div class="block">Creates an instance of RuntimeVariablesExpression.</div>
</section>
</li>
<li>
<section class="detail" id="runtimeVariables(org.apache.calcite.linq4j.tree.ParameterExpression...)">
<h3>runtimeVariables</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</span>&nbsp;<span class="element-name">runtimeVariables</span><wbr><span class="parameters">(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;arguments)</span></div>
<div class="block">Creates an instance of RuntimeVariablesExpression, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>subtract</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtract</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>subtract</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtract</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>subtractAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>subtractAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>subtractAssign</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssign</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>subtractAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>subtractAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">
<h3>subtractAssignChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractAssignChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</span></div>
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">
<h3>subtractChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>subtractChecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="element-name">subtractChecked</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;left,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 without a default case.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.SwitchCase...)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <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="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</section>
</li>
<li>
<section class="detail" id="switch_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.SwitchCase...)">
<h3>switch_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="element-name">switch_</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;switchValue,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;defaultBody,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method,
 <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</span></div>
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</section>
</li>
<li>
<section class="detail" id="switchCase(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">
<h3>switchCase</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></span>&nbsp;<span class="element-name">switchCase</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;body)</span></div>
<div class="block">Creates a SwitchCase for use in a SwitchExpression.</div>
</section>
</li>
<li>
<section class="detail" id="switchCase(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">
<h3>switchCase</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></span>&nbsp;<span class="element-name">switchCase</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;body)</span></div>
<div class="block">Creates a SwitchCase for use in a SwitchExpression, with varargs.</div>
</section>
</li>
<li>
<section class="detail" id="symbolDocument(java.lang.String)">
<h3>symbolDocument</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="element-name">symbolDocument</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;fileName)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li>
<section class="detail" id="symbolDocument(java.lang.String,java.util.UUID)">
<h3>symbolDocument</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="element-name">symbolDocument</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;fileName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li>
<section class="detail" id="symbolDocument(java.lang.String,java.util.UUID,java.util.UUID)">
<h3>symbolDocument</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="element-name">symbolDocument</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;fileName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;vendor)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li>
<section class="detail" id="symbolDocument(java.lang.String,java.util.UUID,java.util.UUID,java.util.UUID)">
<h3>symbolDocument</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="element-name">symbolDocument</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;filename,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;language,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;vendor,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;documentType)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li>
<section class="detail" id="throw_(org.apache.calcite.linq4j.tree.Expression)">
<h3>throw_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ThrowStatement.html" title="class in org.apache.calcite.linq4j.tree">ThrowStatement</a></span>&nbsp;<span class="element-name">throw_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a statement that represents the throwing of an exception.</div>
</section>
</li>
<li>
<section class="detail" id="tryCatch(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable)">
<h3>tryCatch</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">tryCatch</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</span></div>
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and neither a fault nor finally
 block.</div>
</section>
</li>
<li>
<section class="detail" id="tryCatch(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">
<h3>tryCatch</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">tryCatch</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</span></div>
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and neither a fault nor finally
 block, with varargs.</div>
</section>
</li>
<li>
<section class="detail" id="tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable,org.apache.calcite.linq4j.tree.Statement)">
<h3>tryCatchFinally</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">tryCatchFinally</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <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="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_)</span></div>
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and a finally block.</div>
</section>
</li>
<li>
<section class="detail" id="tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">
<h3>tryCatchFinally</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">tryCatchFinally</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_,
 <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>...&nbsp;handlers)</span></div>
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and a finally block, with varargs.</div>
</section>
</li>
<li>
<section class="detail" id="tryFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement)">
<h3>tryFinally</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="element-name">tryFinally</span><wbr><span class="parameters">(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;finally_)</span></div>
<div class="block">Creates a TryExpression representing a try block with a
 finally block and no catch statements.</div>
</section>
</li>
<li>
<section class="detail" id="typeAs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>typeAs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">typeAs</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents an explicit
 reference or boxing conversion where null is supplied if the
 conversion fails.</div>
</section>
</li>
<li>
<section class="detail" id="typeEqual(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>typeEqual</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></span>&nbsp;<span class="element-name">typeEqual</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a TypeBinaryExpression that compares run-time type
 identity.</div>
</section>
</li>
<li>
<section class="detail" id="typeIs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>typeIs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></span>&nbsp;<span class="element-name">typeIs</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a TypeBinaryExpression.</div>
</section>
</li>
<li>
<section class="detail" id="unaryPlus(org.apache.calcite.linq4j.tree.Expression)">
<h3>unaryPlus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">unaryPlus</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a UnaryExpression that represents a unary plus
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="unaryPlus(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">
<h3>unaryPlus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">unaryPlus</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html" title="class or interface in java.lang.reflect" class="external-link">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents a unary plus
 operation.</div>
</section>
</li>
<li>
<section class="detail" id="unbox(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">
<h3>unbox</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="element-name">unbox</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents an explicit
 unboxing.</div>
</section>
</li>
<li>
<section class="detail" id="variable(java.lang.reflect.Type)">
<h3>variable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="element-name">variable</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</section>
</li>
<li>
<section class="detail" id="variable(java.lang.reflect.Type,java.lang.String)">
<h3>variable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="element-name">variable</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Type.html" title="class or interface in java.lang.reflect" class="external-link">Type</a>&nbsp;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>&nbsp;name)</span></div>
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</section>
</li>
<li>
<section class="detail" id="visitChildren(org.apache.calcite.linq4j.tree.ExpressionVisitor)">
<h3>visitChildren</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">visitChildren</span><wbr><span class="parameters">(<a href="ExpressionVisitor.html" title="interface in org.apache.calcite.linq4j.tree">ExpressionVisitor</a>&nbsp;visitor)</span></div>
<div class="block">Reduces the node and then calls the visitor delegate on the
 reduced expression. The method throws an exception if the node
 is not reducible.</div>
</section>
</li>
<li>
<section class="detail" id="while_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">
<h3>while_</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="WhileStatement.html" title="class in org.apache.calcite.linq4j.tree">WhileStatement</a></span>&nbsp;<span class="element-name">while_</span><wbr><span class="parameters">(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;condition,
 <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body)</span></div>
<div class="block">Creates a WhileExpression representing a while loop.</div>
</section>
</li>
<li>
<section class="detail" id="declare(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">
<h3>declare</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></span>&nbsp;<span class="element-name">declare</span><wbr><span class="parameters">(int&nbsp;modifiers,
 <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter,
 @Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</span></div>
<div class="block">Creates a statement that declares a variable.</div>
</section>
</li>
<li>
<section class="detail" id="declare(int,java.lang.String,org.apache.calcite.linq4j.tree.Expression)">
<h3>declare</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></span>&nbsp;<span class="element-name">declare</span><wbr><span class="parameters">(int&nbsp;modifiers,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</span></div>
<div class="block">Creates an expression that declares and initializes a variable. No
 type is required; it is assumed that the variable is the same type as
 the initializer. You can retrieve the <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree"><code>ParameterExpression</code></a> from
 the <a href="DeclarationStatement.html#parameter"><code>DeclarationStatement.parameter</code></a> field of the result.</div>
</section>
</li>
<li>
<section class="detail" id="statement(org.apache.calcite.linq4j.tree.Expression)">
<h3>statement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a></span>&nbsp;<span class="element-name">statement</span><wbr><span class="parameters">(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</span></div>
<div class="block">Creates a statement that executes an expression.</div>
</section>
</li>
<li>
<section class="detail" id="foldAnd(java.util.List)">
<h3>foldAnd</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">foldAnd</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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;conditions)</span></div>
<div class="block">Combines a list of expressions using AND.
 Returns TRUE if the list is empty.
 Returns FALSE if any of the conditions are constant FALSE;
 otherwise returns NULL if any of the conditions are constant NULL.</div>
</section>
</li>
<li>
<section class="detail" id="foldOr(java.util.List)">
<h3>foldOr</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="element-name">foldOr</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="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;conditions)</span></div>
<div class="block">Combines a list of expressions using OR.
 Returns FALSE if the list is empty.
 Returns TRUE if any of the conditions are constant TRUE;
 otherwise returns NULL if all of the conditions are constant NULL.</div>
</section>
</li>
<li>
<section class="detail" id="list()">
<h3>list</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="element-name">list</span>()</div>
<div class="block">Creates an empty fluent list.</div>
</section>
</li>
<li>
<section class="detail" id="list(T...)">
<h3 id="list(java.lang.Object[])">list</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/SafeVarargs.html" title="class or interface in java.lang" class="external-link">@SafeVarargs</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="element-name">list</span><wbr><span class="parameters">(T...&nbsp;ts)</span></div>
<div class="block">Creates a fluent list with given elements.</div>
</section>
</li>
<li>
<section class="detail" id="list(java.lang.Iterable)">
<h3>list</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="element-name">list</span><wbr><span class="parameters">(<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;T&gt;&nbsp;ts)</span></div>
<div class="block">Creates a fluent list with elements from the given collection.</div>
</section>
</li>
<li>
<section class="detail" id="evaluate(org.apache.calcite.linq4j.tree.Node)">
<h3>evaluate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">evaluate</span><wbr><span class="parameters">(<a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;node)</span></div>
<div class="block">Evaluates an expression and returns the result.</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>
