<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<title>Expressions (Apache Calcite calcite API)</title>
<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.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../script-dir/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../script-dir/jquery-3.4.1.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.js"></script>
</head>
<body class="class-declaration">
<script type="text/javascript">var data = {"i0":9,"i1":9,"i2":9,"i3":9,"i4":9,"i5":9,"i6":9,"i7":9,"i8":9,"i9":9,"i10":9,"i11":9,"i12":9,"i13":9,"i14":9,"i15":9,"i16":9,"i17":9,"i18":9,"i19":9,"i20":9,"i21":9,"i22":9,"i23":9,"i24":9,"i25":9,"i26":9,"i27":9,"i28":9,"i29":9,"i30":9,"i31":9,"i32":9,"i33":9,"i34":9,"i35":9,"i36":9,"i37":9,"i38":9,"i39":9,"i40":9,"i41":9,"i42":9,"i43":9,"i44":9,"i45":9,"i46":9,"i47":9,"i48":9,"i49":9,"i50":9,"i51":9,"i52":9,"i53":9,"i54":9,"i55":9,"i56":9,"i57":9,"i58":9,"i59":9,"i60":9,"i61":9,"i62":9,"i63":9,"i64":9,"i65":9,"i66":9,"i67":9,"i68":9,"i69":9,"i70":9,"i71":9,"i72":9,"i73":9,"i74":9,"i75":9,"i76":9,"i77":9,"i78":9,"i79":9,"i80":9,"i81":9,"i82":9,"i83":9,"i84":9,"i85":9,"i86":9,"i87":9,"i88":9,"i89":9,"i90":9,"i91":9,"i92":9,"i93":9,"i94":9,"i95":9,"i96":9,"i97":9,"i98":9,"i99":9,"i100":9,"i101":9,"i102":9,"i103":9,"i104":9,"i105":9,"i106":9,"i107":9,"i108":9,"i109":9,"i110":9,"i111":9,"i112":9,"i113":9,"i114":9,"i115":9,"i116":9,"i117":9,"i118":9,"i119":9,"i120":9,"i121":9,"i122":9,"i123":9,"i124":9,"i125":9,"i126":9,"i127":9,"i128":9,"i129":9,"i130":9,"i131":9,"i132":9,"i133":9,"i134":9,"i135":9,"i136":9,"i137":9,"i138":9,"i139":9,"i140":9,"i141":9,"i142":9,"i143":9,"i144":9,"i145":9,"i146":9,"i147":9,"i148":9,"i149":9,"i150":9,"i151":9,"i152":9,"i153":9,"i154":9,"i155":9,"i156":9,"i157":9,"i158":9,"i159":9,"i160":9,"i161":9,"i162":9,"i163":9,"i164":9,"i165":9,"i166":9,"i167":9,"i168":9,"i169":9,"i170":9,"i171":9,"i172":9,"i173":9,"i174":9,"i175":9,"i176":9,"i177":9,"i178":9,"i179":9,"i180":9,"i181":9,"i182":9,"i183":9,"i184":9,"i185":9,"i186":9,"i187":9,"i188":9,"i189":9,"i190":9,"i191":9,"i192":9,"i193":9,"i194":9,"i195":9,"i196":9,"i197":9,"i198":9,"i199":9,"i200":9,"i201":9,"i202":9,"i203":9,"i204":9,"i205":9,"i206":9,"i207":9,"i208":9,"i209":9,"i210":9,"i211":9,"i212":9,"i213":9,"i214":9,"i215":9,"i216":9,"i217":9,"i218":9,"i219":9,"i220":9,"i221":9,"i222":9,"i223":9,"i224":9,"i225":9,"i226":9,"i227":9,"i228":9,"i229":9,"i230":9,"i231":9,"i232":9,"i233":9,"i234":9,"i235":9,"i236":9,"i237":9,"i238":9,"i239":9,"i240":9,"i241":9,"i242":9,"i243":9,"i244":9,"i245":9,"i246":9,"i247":9,"i248":9,"i249":9,"i250":9,"i251":9,"i252":9,"i253":9,"i254":9,"i255":9,"i256":9,"i257":9,"i258":9,"i259":9,"i260":9,"i261":9,"i262":9,"i263":9,"i264":9,"i265":9,"i266":9,"i267":9,"i268":9,"i269":9,"i270":9,"i271":9,"i272":9,"i273":9,"i274":9,"i275":9,"i276":9,"i277":9,"i278":9,"i279":9,"i280":9,"i281":9,"i282":9,"i283":9,"i284":9,"i285":9,"i286":9,"i287":9,"i288":9,"i289":9,"i290":9,"i291":9,"i292":9,"i293":9,"i294":9,"i295":9,"i296":9,"i297":9,"i298":9,"i299":9,"i300":9,"i301":9,"i302":9,"i303":9,"i304":9,"i305":9,"i306":9,"i307":9};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flexBox">
<header role="banner" class="flexHeader">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">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">Help</a></li>
</ul>
<div class="aboutLanguage"><b>Apache Calcite</b></div>
</div>
<div class="subNav">
<div>
<ul class="subNavList">
<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="subNavList">
<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="navListSearch"><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="skipNav"><a id="skip.navbar.top">
<!--   -->
</a></div>
</nav>
</header>
<div class="flexContent">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle"><span class="packageLabelInType">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="contentContainer">
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.linq4j.tree.Expressions</div>
</div>
<section class="description">
<hr>
<pre>public abstract class <span class="typeNameLabel">Expressions</span>
extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></pre>
<div class="block">Utility methods for expressions, including a lot of factory methods.</div>
</section>
<section class="summary">
<ul class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li class="blockList">
<section class="nestedClassSummary"><a id="nested.class.summary">
<!--   -->
</a>
<h2>Nested Class Summary</h2>
<div class="memberSummary">
<table>
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<thead>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Class</th>
<th class="colLast" scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="Expressions.FluentList.html" 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;</span></code></th>
<td class="colLast">
<div class="block">Fluent list.</div>
</td>
</tr>
</tbody>
</table>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li class="blockList">
<section class="methodSummary"><a id="method.summary">
<!--   -->
</a>
<h2>Method Summary</h2>
<div class="memberSummary">
<div role="tablist" aria-orientation="horizontal"><button role="tab" aria-selected="true" aria-controls="memberSummary_tabpanel" tabindex="0" onkeydown="switchTab(event)" id="t0" class="activeTableTab">All Methods</button><button role="tab" aria-selected="false" aria-controls="memberSummary_tabpanel" tabindex="-1" onkeydown="switchTab(event)" id="t1" class="tableTab" onclick="show(1);">Static Methods</button><button role="tab" aria-selected="false" aria-controls="memberSummary_tabpanel" tabindex="-1" onkeydown="switchTab(event)" id="t4" class="tableTab" onclick="show(8);">Concrete Methods</button></div>
<div id="memberSummary_tabpanel" role="tabpanel">
<table aria-labelledby="t0">
<thead>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr class="altColor" id="i0">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">add</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i1">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">add</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i2">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i3">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i4">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">addAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i5">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addAssignChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i6">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i7">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">addAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an addition
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i8">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i9">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 addition operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i10">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">and</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 operation.</div>
</td>
</tr>
<tr class="rowColor" id="i11">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">and</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i12">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">andAlso</a></span>&#8203;(<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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i13">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">andAlso</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i14">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">andAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i15">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">andAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i16">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">andAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i17">
<td class="colFirst"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#arrayIndex(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">arrayIndex</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates an expression that represents applying an array
 index operator to an array of rank one.</div>
</td>
</tr>
<tr class="altColor" id="i18">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#arrayLength(org.apache.calcite.linq4j.tree.Expression)">arrayLength</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;array)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an expression for
 obtaining the length of a one-dimensional array.</div>
</td>
</tr>
<tr class="rowColor" id="i19">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#assign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">assign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an assignment
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i20">
<td class="colFirst"><code>static <a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#bind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.Expression)">bind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;right)</code></th>
<td class="colLast">
<div class="block">Creates a MemberAssignment that represents the initialization
 of a field or property.</div>
</td>
</tr>
<tr class="rowColor" id="i21">
<td class="colFirst"><code>static <a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#bind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression)">bind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a MemberAssignment that represents the initialization
 of a member by using a property accessor method.</div>
</td>
</tr>
<tr class="altColor" id="i22">
<td class="colFirst"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#block(java.lang.reflect.Type,java.lang.Iterable)">block</a></span>&#8203;(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a BlockExpression that contains the given expressions,
 has no variables and has specific result type.</div>
</td>
</tr>
<tr class="rowColor" id="i23">
<td class="colFirst"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#block(java.lang.Iterable)">block</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&gt;&nbsp;statements)</code></th>
<td class="colLast">
<div class="block">Creates a BlockExpression that contains the given statements.</div>
</td>
</tr>
<tr class="altColor" id="i24">
<td class="colFirst"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#block(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Statement...)">block</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</code></th>
<td class="colLast">
<div class="block">Creates a BlockExpression that contains the given statements
 and has a specific result type, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i25">
<td class="colFirst"><code>static <a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#block(org.apache.calcite.linq4j.tree.Statement...)">block</a></span>&#8203;(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>...&nbsp;statements)</code></th>
<td class="colLast">
<div class="block">Creates a BlockExpression that contains the given statements,
 using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i26">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#box(org.apache.calcite.linq4j.tree.Expression)">box</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Converts e.g.</div>
</td>
</tr>
<tr class="rowColor" id="i27">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#box(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">box</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Returns an expression to box the value of a primitive expression.</div>
</td>
</tr>
<tr class="altColor" id="i28">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget)">break_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a break statement.</div>
</td>
</tr>
<tr class="rowColor" id="i29">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">break_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a break statement with
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i30">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">break_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a break statement.</div>
</td>
</tr>
<tr class="rowColor" id="i31">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">break_</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a break statement with
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i32">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">call</a></span>&#8203;(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i33">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></span>&#8203;(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i34">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Method,java.lang.Iterable)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method that has arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i35">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method that has arguments, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i36">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type.</div>
</td>
</tr>
<tr class="rowColor" id="i37">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 method that takes arguments, with an explicit return type, with varargs.</div>
</td>
</tr>
<tr class="altColor" id="i38">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Type,java.lang.String,java.lang.Iterable)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method.</div>
</td>
</tr>
<tr class="rowColor" id="i39">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(java.lang.reflect.Type,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">call</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to a
 static method by calling the
 appropriate factory method, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i40">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,java.lang.Iterable)">call</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method.</div>
</td>
</tr>
<tr class="rowColor" id="i41">
<td class="colFirst"><code>static <a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">call</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a MethodCallExpression that represents a call to an
 instance method by calling the appropriate factory method, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i42">
<td class="colFirst"><code>static <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#catch_(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Statement)">catch_</a></span>&#8203;(<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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i43">
<td class="colFirst"><code>static <a href="ClassDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ClassDeclaration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#classDecl(int,java.lang.String,java.lang.reflect.Type,java.util.List,java.util.List)">classDecl</a></span>&#8203;(int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;extended,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&gt;&nbsp;implemented,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">List</a>&lt;<a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</code></th>
<td class="colLast">
<div class="block">Declares a class.</div>
</td>
</tr>
<tr class="altColor" id="i44">
<td class="colFirst"><code>static void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#clearDebugInfo()">clearDebugInfo</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a DebugInfoExpression for clearing a sequence
 point.</div>
</td>
</tr>
<tr class="rowColor" id="i45">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">coalesce</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a coalescing
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i46">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.LambdaExpression)">coalesce</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a coalescing
 operation, given a conversion function.</div>
</td>
</tr>
<tr class="rowColor" id="i47">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">condition</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ConditionalExpression that represents a conditional
 statement.</div>
</td>
</tr>
<tr class="altColor" id="i48">
<td class="colFirst"><code>static <a href="ConditionalExpression.html" title="class in org.apache.calcite.linq4j.tree">ConditionalExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">condition</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a ConditionalExpression that represents a conditional
 statement.</div>
</td>
</tr>
<tr class="rowColor" id="i49">
<td class="colFirst"><code>static <a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#constant(java.lang.Object)">constant</a></span>&#8203;(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&nbsp;value)</code></th>
<td class="colLast">
<div class="block">Creates a ConstantExpression that has the Value property set
 to the specified value.</div>
</td>
</tr>
<tr class="altColor" id="i50">
<td class="colFirst"><code>static <a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#constant(java.lang.Object,java.lang.reflect.Type)">constant</a></span>&#8203;(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&nbsp;value,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a ConstantExpression that has the Value and Type
 properties set to the specified values.</div>
</td>
</tr>
<tr class="rowColor" id="i51">
<td class="colFirst"><code>static <a href="ConstructorDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ConstructorDeclaration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#constructorDecl(int,java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">constructorDecl</a></span>&#8203;(int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;declaredAgainst,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Declares a constructor.</div>
</td>
</tr>
<tr class="altColor" id="i52">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#continue_(org.apache.calcite.linq4j.tree.LabelTarget)">continue_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a continue statement.</div>
</td>
</tr>
<tr class="rowColor" id="i53">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#continue_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">continue_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a continue statement
 with the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i54">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">convert_</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a type conversion
 operation.</div>
</td>
</tr>
<tr class="rowColor" id="i55">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">convert_</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a conversion
 operation for which the implementing method is specified.</div>
</td>
</tr>
<tr class="altColor" id="i56">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#convertChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">convertChecked</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a conversion
 operation that throws an exception if the target type is
 overflowed.</div>
</td>
</tr>
<tr class="rowColor" id="i57">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#convertChecked_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">convertChecked_</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i58">
<td class="colFirst"><code>static void</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#debugInfo()">debugInfo</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a DebugInfoExpression with the specified span.</div>
</td>
</tr>
<tr class="rowColor" id="i59">
<td class="colFirst"><code>static <a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#declare(int,java.lang.String,org.apache.calcite.linq4j.tree.Expression)">declare</a></span>&#8203;(int&nbsp;modifiers,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;initializer)</code></th>
<td class="colLast">
<div class="block">Creates an expression that declares and initializes a variable.</div>
</td>
</tr>
<tr class="altColor" id="i60">
<td class="colFirst"><code>static <a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#declare(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">declare</a></span>&#8203;(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></th>
<td class="colLast">
<div class="block">Creates a statement that declares a variable.</div>
</td>
</tr>
<tr class="rowColor" id="i61">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#decrement(org.apache.calcite.linq4j.tree.Expression)">decrement</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</td>
</tr>
<tr class="altColor" id="i62">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#decrement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">decrement</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents the decrementing of
 the expression by 1.</div>
</td>
</tr>
<tr class="rowColor" id="i63">
<td class="colFirst"><code>static <a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#default_()">default_</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a DefaultExpression that has the Type property set to
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i64">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">divide</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 division operation.</div>
</td>
</tr>
<tr class="rowColor" id="i65">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">divide</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 division operation.</div>
</td>
</tr>
<tr class="altColor" id="i66">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">divideAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i67">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">divideAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i68">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">divideAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a division
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i69">
<td class="colFirst"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,java.lang.Iterable)">dynamic</a></span>&#8203;(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</td>
</tr>
<tr class="altColor" id="i70">
<td class="colFirst"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">dynamic</a></span>&#8203;(<a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a <code>DynamicExpression</code> that represents a dynamic
 operation bound by the provided <code>CallSiteBinder</code>, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i71">
<td class="colFirst"><code>static <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#elementInit(java.lang.reflect.Method,java.lang.Iterable)">elementInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates an <code>ElementInit</code>, given an <code>Iterable&lt;T&gt;</code> as the second
 argument.</div>
</td>
</tr>
<tr class="altColor" id="i72">
<td class="colFirst"><code>static <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#elementInit(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">elementInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates an ElementInit, given an array of values as the second
 argument, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i73">
<td class="colFirst"><code>static <a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#empty()">empty</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates an empty expression that has Void type.</div>
</td>
</tr>
<tr class="altColor" id="i74">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">equal</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an equality
 comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i75">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">equal</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an equality
 comparison.</div>
</td>
</tr>
<tr class="altColor" id="i76">
<td class="colFirst"><code>static @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#evaluate(org.apache.calcite.linq4j.tree.Node)">evaluate</a></span>&#8203;(<a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;node)</code></th>
<td class="colLast">
<div class="block">Evaluates an expression and returns the result.</div>
</td>
</tr>
<tr class="rowColor" id="i77">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">exclusiveOr</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined types.</div>
</td>
</tr>
<tr class="altColor" id="i78">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">exclusiveOr</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 operation, using op_ExclusiveOr for user-defined types.</div>
</td>
</tr>
<tr class="rowColor" id="i79">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">exclusiveOrAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</td>
</tr>
<tr class="altColor" id="i80">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">exclusiveOrAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</td>
</tr>
<tr class="rowColor" id="i81">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">exclusiveOrAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise XOR
 assignment operation, using op_ExclusiveOr for user-defined
 types.</div>
</td>
</tr>
<tr class="altColor" id="i82">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Field)">field</a></span>&#8203;(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Field.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Field</a>&nbsp;field)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</td>
</tr>
<tr class="rowColor" id="i83">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">field</a></span>&#8203;(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fieldName)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</td>
</tr>
<tr class="altColor" id="i84">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#field(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">field</a></span>&#8203;(@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></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</td>
</tr>
<tr class="rowColor" id="i85">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#field(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">field</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fieldName)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a field
 given the name of the field.</div>
</td>
</tr>
<tr class="altColor" id="i86">
<td class="colFirst"><code>static <a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression)">fieldDecl</a></span>&#8203;(int&nbsp;modifier,
<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&nbsp;parameter)</code></th>
<td class="colLast">
<div class="block">Declares a field.</div>
</td>
</tr>
<tr class="rowColor" id="i87">
<td class="colFirst"><code>static <a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">fieldDecl</a></span>&#8203;(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></th>
<td class="colLast">
<div class="block">Declares a field with an initializer.</div>
</td>
</tr>
<tr class="altColor" id="i88">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#foldAnd(java.util.List)">foldAnd</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">List</a>&lt;<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;conditions)</code></th>
<td class="colLast">
<div class="block">Combines a list of expressions using AND.</div>
</td>
</tr>
<tr class="rowColor" id="i89">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#foldOr(java.util.List)">foldOr</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">List</a>&lt;<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;conditions)</code></th>
<td class="colLast">
<div class="block">Combines a list of expressions using OR.</div>
</td>
</tr>
<tr class="altColor" id="i90">
<td class="colFirst"><code>static <a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#for_(java.lang.Iterable,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">for_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a LoopExpression with the given body.</div>
</td>
</tr>
<tr class="rowColor" id="i91">
<td class="colFirst"><code>static <a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">for_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a LoopExpression with the given body.</div>
</td>
</tr>
<tr class="altColor" id="i92">
<td class="colFirst"><code>static <a href="ForEachStatement.html" title="class in org.apache.calcite.linq4j.tree">ForEachStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#forEach(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">forEach</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ForEachExpression with the given body.</div>
</td>
</tr>
<tr class="rowColor" id="i93">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getActionType(java.lang.Class...)">getActionType</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a>...&nbsp;typeArgs)</code></th>
<td class="colLast">
<div class="block">Creates a Type object that represents a generic System.Action
 delegate type that has specific type arguments.</div>
</td>
</tr>
<tr class="altColor" id="i94">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getDelegateType(java.lang.Class...)">getDelegateType</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a>...&nbsp;typeArgs)</code></th>
<td class="colLast">
<div class="block">Gets a Type object that represents a generic System.Func or
 System.Action delegate type that has specific type
 arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i95">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getFuncType(java.lang.Class...)">getFuncType</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a>...&nbsp;typeArgs)</code></th>
<td class="colLast">
<div class="block">Creates a Type object that represents a generic System.Func
 delegate type that has specific type arguments.</div>
</td>
</tr>
<tr class="altColor" id="i96">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget)">goto_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a "go to" statement.</div>
</td>
</tr>
<tr class="rowColor" id="i97">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">goto_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i98">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">goto_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a "go to" statement.</div>
</td>
</tr>
<tr class="rowColor" id="i99">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">goto_</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a "go to" statement with
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i100">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">greaterThan</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "greater than"
 numeric comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i101">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">greaterThan</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "greater than"
 numeric comparison.</div>
</td>
</tr>
<tr class="altColor" id="i102">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">greaterThanOrEqual</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i103">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">greaterThanOrEqual</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "greater than or
 equal" numeric comparison.</div>
</td>
</tr>
<tr class="altColor" id="i104">
<td class="colFirst"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ifThen(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node)">ifThen</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with an if statement.</div>
</td>
</tr>
<tr class="rowColor" id="i105">
<td class="colFirst"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ifThenElse(java.lang.Iterable)">ifThenElse</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&gt;&nbsp;nodes)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i106">
<td class="colFirst"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node...)">ifThenElse</a></span>&#8203;(<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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i107">
<td class="colFirst"><code>static <a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node,org.apache.calcite.linq4j.tree.Node)">ifThenElse</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ConditionalExpression that represents a conditional
 block with if and else statements.</div>
</td>
</tr>
<tr class="altColor" id="i108">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#increment(org.apache.calcite.linq4j.tree.Expression)">increment</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents the incrementing of
 the expression value by 1.</div>
</td>
</tr>
<tr class="rowColor" id="i109">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#increment(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">increment</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents the incrementing of
 the expression by 1.</div>
</td>
</tr>
<tr class="altColor" id="i110">
<td class="colFirst"><code>static <a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#invoke(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">invoke</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions.</div>
</td>
</tr>
<tr class="rowColor" id="i111">
<td class="colFirst"><code>static <a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#invoke(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">invoke</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates an InvocationExpression that applies a delegate or
 lambda expression to a list of argument expressions, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i112">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isConstantNull(org.apache.calcite.linq4j.tree.Expression)">isConstantNull</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;e)</code></th>
<td class="colLast">
<div class="block">Returns whether an expression always evaluates to null.</div>
</td>
</tr>
<tr class="rowColor" id="i113">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isFalse(org.apache.calcite.linq4j.tree.Expression)">isFalse</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Returns whether the expression evaluates to false.</div>
</td>
</tr>
<tr class="altColor" id="i114">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isFalse(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">isFalse</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Returns whether the expression evaluates to false.</div>
</td>
</tr>
<tr class="rowColor" id="i115">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isTrue(org.apache.calcite.linq4j.tree.Expression)">isTrue</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Returns whether the expression evaluates to true.</div>
</td>
</tr>
<tr class="altColor" id="i116">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isTrue(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">isTrue</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Returns whether the expression evaluates to true.</div>
</td>
</tr>
<tr class="rowColor" id="i117">
<td class="colFirst"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label()">label</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a LabelTarget representing a label with X type and
 no name.</div>
</td>
</tr>
<tr class="altColor" id="i118">
<td class="colFirst"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label(java.lang.reflect.Type)">label</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a LabelTarget representing a label with the given
 type.</div>
</td>
</tr>
<tr class="rowColor" id="i119">
<td class="colFirst"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label(java.lang.reflect.Type,java.lang.String)">label</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a LabelTarget representing a label with the given type
 and name.</div>
</td>
</tr>
<tr class="altColor" id="i120">
<td class="colFirst"><code>static <a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label(java.lang.String)">label</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a LabelTarget representing a label with X type and
 the given name.</div>
</td>
</tr>
<tr class="rowColor" id="i121">
<td class="colFirst"><code>static <a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label(org.apache.calcite.linq4j.tree.LabelTarget)">label</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</code></th>
<td class="colLast">
<div class="block">Creates a LabelExpression representing a label without a
 default value.</div>
</td>
</tr>
<tr class="altColor" id="i122">
<td class="colFirst"><code>static <a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#label(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">label</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a LabelExpression representing a label with the given
 default value.</div>
</td>
</tr>
<tr class="rowColor" id="i123">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(F)">lambda</a></span>&#8203;(F&nbsp;function)</code></th>
<td class="colLast">
<div class="block">Creates a FunctionExpression from an actual function.</div>
</td>
</tr>
<tr class="altColor" id="i124">
<td class="colFirst"><code>static &lt;T,&#8203;
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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">lambda</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</code></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.</div>
</td>
</tr>
<tr class="rowColor" id="i125">
<td class="colFirst"><code>static &lt;T,&#8203;
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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i126">
<td class="colFirst"><code>static &lt;T,&#8203;
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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">lambda</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</code></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.</div>
</td>
</tr>
<tr class="rowColor" id="i127">
<td class="colFirst"><code>static &lt;T,&#8203;
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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i128">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">lambda</a></span>&#8203;(<a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</code></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type.</div>
</td>
</tr>
<tr class="rowColor" id="i129">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a LambdaExpression by first constructing a delegate
 type, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i130">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">lambda</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;parameters)</code></th>
<td class="colLast">
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time.</div>
</td>
</tr>
<tr class="rowColor" id="i131">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lambda(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates an Expression where the delegate type <code>F</code> is
 known at compile time, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i132">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">leftShift</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift operation.</div>
</td>
</tr>
<tr class="rowColor" id="i133">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">leftShift</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift operation.</div>
</td>
</tr>
<tr class="altColor" id="i134">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">leftShiftAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i135">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">leftShiftAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i136">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">leftShiftAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i137">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">lessThan</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</td>
</tr>
<tr class="altColor" id="i138">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">lessThan</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i139">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">lessThanOrEqual</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a " less than or
 equal" numeric comparison.</div>
</td>
</tr>
<tr class="altColor" id="i140">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">lessThanOrEqual</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a "less than or
 equal" numeric comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i141">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#list()">list</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates an empty fluent list.</div>
</td>
</tr>
<tr class="altColor" id="i142">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#list(java.lang.Iterable)">list</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;T&gt;&nbsp;ts)</code></th>
<td class="colLast">
<div class="block">Creates a fluent list with elements from the given collection.</div>
</td>
</tr>
<tr class="rowColor" id="i143">
<td class="colFirst"><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></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#list(T...)">list</a></span>&#8203;(T...&nbsp;ts)</code></th>
<td class="colLast">
<div class="block">Creates a fluent list with given elements.</div>
</td>
</tr>
<tr class="altColor" id="i144">
<td class="colFirst"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listBind(java.lang.reflect.Member,java.lang.Iterable)">listBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</code></th>
<td class="colLast">
<div class="block">Creates a MemberListBinding where the member is a field or
 property.</div>
</td>
</tr>
<tr class="rowColor" id="i145">
<td class="colFirst"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.ElementInit...)">listBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</code></th>
<td class="colLast">
<div class="block">Creates a MemberListBinding where the member is a field or
 property, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i146">
<td class="colFirst"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listBind(java.lang.reflect.Method,java.lang.Iterable)">listBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</code></th>
<td class="colLast">
<div class="block">Creates a MemberListBinding based on a specified property
 accessor method.</div>
</td>
</tr>
<tr class="rowColor" id="i147">
<td class="colFirst"><code>static <a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.ElementInit...)">listBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>...&nbsp;elementInits)</code></th>
<td class="colLast">
<div class="block">Creates a MemberListBinding object based on a specified
 property accessor method, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i148">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">listInit</a></span>&#8203;(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a>&gt;&nbsp;elementInits)</code></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses specified ElementInit
 objects to initialize a collection.</div>
</td>
</tr>
<tr class="rowColor" id="i149">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,java.lang.Iterable)">listInit</a></span>&#8203;(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses a specified method to
 add elements to a collection.</div>
</td>
</tr>
<tr class="altColor" id="i150">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">listInit</a></span>&#8203;(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses a specified method to
 add elements to a collection, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i151">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.ElementInit...)">listInit</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses specified ElementInit
 objects to initialize a collection, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i152">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.Expression...)">listInit</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses a method named "Add" to
 add elements to a collection, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i153">
<td class="colFirst"><code>static <a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#listInitE(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">listInitE</a></span>&#8203;(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a ListInitExpression that uses a method named "Add" to
 add elements to a collection.</div>
</td>
</tr>
<tr class="altColor" id="i154">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">makeBinary</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</td>
</tr>
<tr class="rowColor" id="i155">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeBinary</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression, given the left operand, right
 operand and implementing method, by calling the appropriate
 factory method.</div>
</td>
</tr>
<tr class="altColor" id="i156">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeBinary</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i157">
<td class="colFirst"><code>static <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeCatchBlock</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a CatchBlock representing a catch statement with the
 specified elements.</div>
</td>
</tr>
<tr class="altColor" id="i158">
<td class="colFirst"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.Iterable)">makeDynamic</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder.</div>
</td>
</tr>
<tr class="rowColor" id="i159">
<td class="colFirst"><code>static <a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,org.apache.calcite.linq4j.tree.Expression...)">makeDynamic</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a DynamicExpression that represents a dynamic
 operation bound by the provided CallSiteBinder, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i160">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">makeGoto</a></span>&#8203;(<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></th>
<td class="colLast">&nbsp;</td>
</tr>
<tr class="rowColor" id="i161">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeGoto</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a jump of the specified
 GotoExpressionKind.</div>
</td>
</tr>
<tr class="altColor" id="i162">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeMemberAccess(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">makeMemberAccess</a></span>&#8203;(@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></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</td>
</tr>
<tr class="rowColor" id="i163">
<td class="colFirst"><code>static <a href="TernaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TernaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeTernary</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a TernaryExpression, given the left and right operands,
 by calling an appropriate factory method.</div>
</td>
</tr>
<tr class="altColor" id="i164">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">makeTry</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</code></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with the
 specified elements.</div>
</td>
</tr>
<tr class="rowColor" id="i165">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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...)">makeTry</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with the
 specified elements, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i166">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression)">makeUnary</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression, given an operand, by calling the
 appropriate factory method.</div>
</td>
</tr>
<tr class="rowColor" id="i167">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">makeUnary</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression, given an operand and implementing
 method, by calling the appropriate factory method.</div>
</td>
</tr>
<tr class="altColor" id="i168">
<td class="colFirst"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberBind(java.lang.reflect.Member,java.lang.Iterable)">memberBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</code></th>
<td class="colLast">
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a field or property.</div>
</td>
</tr>
<tr class="rowColor" id="i169">
<td class="colFirst"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.MemberBinding...)">memberBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</code></th>
<td class="colLast">
<div class="block">Creates a MemberMemberBinding that represents the recursive
 initialization of members of a field or property, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i170">
<td class="colFirst"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberBind(java.lang.reflect.Method,java.lang.Iterable)">memberBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i171">
<td class="colFirst"><code>static <a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.MemberBinding...)">memberBind</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>...&nbsp;bindings)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i172">
<td class="colFirst"><code>static <a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">memberInit</a></span>&#8203;(<a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="MemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberBinding</a>&gt;&nbsp;bindings)</code></th>
<td class="colLast">
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object.</div>
</td>
</tr>
<tr class="rowColor" id="i173">
<td class="colFirst"><code>static <a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#memberInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.MemberBinding...)">memberInit</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Represents an expression that creates a new object and
 initializes a property of the object, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i174">
<td class="colFirst"><code>static <a href="MethodDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MethodDeclaration</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#methodDecl(int,java.lang.reflect.Type,java.lang.String,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">methodDecl</a></span>&#8203;(int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;resultType,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Declares a method.</div>
</td>
</tr>
<tr class="rowColor" id="i175">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">modulo</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</td>
</tr>
<tr class="altColor" id="i176">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">modulo</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</td>
</tr>
<tr class="rowColor" id="i177">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">moduloAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i178">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">moduloAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i179">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">moduloAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i180">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiply</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</td>
</tr>
<tr class="rowColor" id="i181">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiply</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that does not have overflow
 checking.</div>
</td>
</tr>
<tr class="altColor" id="i182">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i183">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i184">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">multiplyAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i185">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyAssignChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i186">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i187">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">multiplyAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a multiplication
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i188">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i189">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 multiplication operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i190">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#negate(org.apache.calcite.linq4j.tree.Expression)">negate</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation.</div>
</td>
</tr>
<tr class="rowColor" id="i191">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#negate(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">negate</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation.</div>
</td>
</tr>
<tr class="altColor" id="i192">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#negateChecked(org.apache.calcite.linq4j.tree.Expression)">negateChecked</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i193">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#negateChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">negateChecked</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i194">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Constructor)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the specified
 constructor that takes no arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i195">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments.</div>
</td>
</tr>
<tr class="altColor" id="i196">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable,java.lang.Iterable)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i197">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Constructor,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i198">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Constructor,org.apache.calcite.linq4j.tree.Expression...)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the specified
 constructor with the specified arguments, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i199">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Type)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the
 parameterless constructor of the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i200">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Type,java.lang.Iterable)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</td>
</tr>
<tr class="rowColor" id="i201">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Type,java.lang.Iterable,java.lang.Iterable)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="MemberDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MemberDeclaration</a>&gt;&nbsp;memberDeclarations)</code></th>
<td class="colLast">
<div class="block">Creates a NewExpression that represents calling the constructor of the
 specified type whose parameters are assignable from the specified
 arguments.</div>
</td>
</tr>
<tr class="altColor" id="i202">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i203">
<td class="colFirst"><code>static <a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#new_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">new_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i204">
<td class="colFirst"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newArrayBounds(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression)">newArrayBounds</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a NewArrayExpression that represents creating an array
 that has a specified rank.</div>
</td>
</tr>
<tr class="rowColor" id="i205">
<td class="colFirst"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newArrayInit(java.lang.reflect.Type,int,java.lang.Iterable)">newArrayInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
int&nbsp;dimension,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewArrayExpression that represents creating a
 n-dimensional array and initializing it from a list of
 elements.</div>
</td>
</tr>
<tr class="altColor" id="i206">
<td class="colFirst"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newArrayInit(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression...)">newArrayInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
int&nbsp;dimension,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewArrayExpression that represents creating an
 n-dimensional array and initializing it from a list of
 elements, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i207">
<td class="colFirst"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newArrayInit(java.lang.reflect.Type,java.lang.Iterable)">newArrayInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements.</div>
</td>
</tr>
<tr class="altColor" id="i208">
<td class="colFirst"><code>static <a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#newArrayInit(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">newArrayInit</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates a NewArrayExpression that represents creating a
 one-dimensional array and initializing it from a list of
 elements, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i209">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#not(org.apache.calcite.linq4j.tree.Expression)">not</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a bitwise complement
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i210">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#not(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">not</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a bitwise complement
 operation.</div>
</td>
</tr>
<tr class="rowColor" id="i211">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">notEqual</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</td>
</tr>
<tr class="altColor" id="i212">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">notEqual</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i213">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#onesComplement(org.apache.calcite.linq4j.tree.Expression)">onesComplement</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Returns the expression representing the ones complement.</div>
</td>
</tr>
<tr class="altColor" id="i214">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#onesComplement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">onesComplement</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Returns the expression representing the ones complement.</div>
</td>
</tr>
<tr class="rowColor" id="i215">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">or</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i216">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">or</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</td>
</tr>
<tr class="rowColor" id="i217">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">orAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i218">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">orAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i219">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">orAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i220">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">orElse</a></span>&#8203;(<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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i221">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">orElse</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i222">
<td class="colFirst"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#parameter(int,java.lang.reflect.Type,java.lang.String)">parameter</a></span>&#8203;(int&nbsp;modifiers,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a ParameterExpression.</div>
</td>
</tr>
<tr class="rowColor" id="i223">
<td class="colFirst"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#parameter(java.lang.reflect.Type)">parameter</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</td>
</tr>
<tr class="altColor" id="i224">
<td class="colFirst"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#parameter(java.lang.reflect.Type,java.lang.String)">parameter</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</td>
</tr>
<tr class="rowColor" id="i225">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#postDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">postDecrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i226">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#postDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">postDecrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i227">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#postIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">postIncrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i228">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#postIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">postIncrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i229">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">power</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</td>
</tr>
<tr class="altColor" id="i230">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">power</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</td>
</tr>
<tr class="rowColor" id="i231">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">powerAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</td>
</tr>
<tr class="altColor" id="i232">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">powerAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</td>
</tr>
<tr class="rowColor" id="i233">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">powerAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents raising an
 expression to a power and assigning the result back to the
 expression.</div>
</td>
</tr>
<tr class="altColor" id="i234">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#preDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">preDecrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that decrements the expression by 1
 and assigns the result back to the expression.</div>
</td>
</tr>
<tr class="rowColor" id="i235">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#preDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">preDecrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that decrements the expression by 1
 and assigns the result back to the expression.</div>
</td>
</tr>
<tr class="altColor" id="i236">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#preIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">preIncrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that increments the expression by 1
 and assigns the result back to the expression.</div>
</td>
</tr>
<tr class="rowColor" id="i237">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#preIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">preIncrementAssign</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that increments the expression by 1
 and assigns the result back to the expression.</div>
</td>
</tr>
<tr class="altColor" id="i238">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">property</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a
 property by using a property accessor method.</div>
</td>
</tr>
<tr class="rowColor" id="i239">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">property</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression accessing a property.</div>
</td>
</tr>
<tr class="altColor" id="i240">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">property</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a
 property.</div>
</td>
</tr>
<tr class="rowColor" id="i241">
<td class="colFirst"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">property</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</td>
</tr>
<tr class="altColor" id="i242">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo)">property</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a
 property.</div>
</td>
</tr>
<tr class="rowColor" id="i243">
<td class="colFirst"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,java.lang.Iterable)">property</a></span>&#8203;(<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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property.</div>
</td>
</tr>
<tr class="altColor" id="i244">
<td class="colFirst"><code>static <a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,org.apache.calcite.linq4j.tree.Expression...)">property</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates an IndexExpression representing the access to an
 indexed property, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i245">
<td class="colFirst"><code>static <a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#propertyOrField(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">propertyOrField</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;propertyOfFieldName)</code></th>
<td class="colLast">
<div class="block">Creates a MemberExpression that represents accessing a
 property or field.</div>
</td>
</tr>
<tr class="altColor" id="i246">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#quote(org.apache.calcite.linq4j.tree.Expression)">quote</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an expression that
 has a constant value of type Expression.</div>
</td>
</tr>
<tr class="rowColor" id="i247">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduce(org.apache.calcite.linq4j.tree.Expression)">reduce</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Reduces this node to a simpler expression.</div>
</td>
</tr>
<tr class="altColor" id="i248">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceAndCheck(org.apache.calcite.linq4j.tree.Expression)">reduceAndCheck</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Reduces this node to a simpler expression.</div>
</td>
</tr>
<tr class="rowColor" id="i249">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#reduceExtensions(org.apache.calcite.linq4j.tree.Expression)">reduceExtensions</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="altColor" id="i250">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#referenceEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">referenceEqual</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a reference
 equality comparison.</div>
</td>
</tr>
<tr class="rowColor" id="i251">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#referenceNotEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">referenceNotEqual</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a reference
 inequality comparison.</div>
</td>
</tr>
<tr class="altColor" id="i252">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rethrow()">rethrow</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception.</div>
</td>
</tr>
<tr class="rowColor" id="i253">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rethrow(java.lang.reflect.Type)">rethrow</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception with a given type.</div>
</td>
</tr>
<tr class="altColor" id="i254">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">return_</a></span>&#8203;(@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></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a return statement.</div>
</td>
</tr>
<tr class="rowColor" id="i255">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget)">return_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a return statement.</div>
</td>
</tr>
<tr class="altColor" id="i256">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">return_</a></span>&#8203;(<a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a return statement with
 the specified type.</div>
</td>
</tr>
<tr class="rowColor" id="i257">
<td class="colFirst"><code>static <a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">return_</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a GotoExpression representing a return statement with
 the specified type.</div>
</td>
</tr>
<tr class="altColor" id="i258">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">rightShift</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift operation.</div>
</td>
</tr>
<tr class="rowColor" id="i259">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">rightShift</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift operation.</div>
</td>
</tr>
<tr class="altColor" id="i260">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">rightShiftAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i261">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">rightShiftAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</td>
</tr>
<tr class="altColor" id="i262">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">rightShiftAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</td>
</tr>
<tr class="rowColor" id="i263">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#runtimeVariables(java.lang.Iterable)">runtimeVariables</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>&gt;&nbsp;expressions)</code></th>
<td class="colLast">
<div class="block">Creates an instance of RuntimeVariablesExpression.</div>
</td>
</tr>
<tr class="altColor" id="i264">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#runtimeVariables(org.apache.calcite.linq4j.tree.ParameterExpression...)">runtimeVariables</a></span>&#8203;(<a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a>...&nbsp;arguments)</code></th>
<td class="colLast">
<div class="block">Creates an instance of RuntimeVariablesExpression, using varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i265">
<td class="colFirst"><code>static <a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#statement(org.apache.calcite.linq4j.tree.Expression)">statement</a></span>&#8203;(@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a statement that executes an expression.</div>
</td>
</tr>
<tr class="altColor" id="i266">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtract</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i267">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtract</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i268">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractAssign</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i269">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i270">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">subtractAssign</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that does not have overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i271">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractAssignChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i272">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i273">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">subtractAssignChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="LambdaExpression.html" title="class in org.apache.calcite.linq4j.tree">LambdaExpression</a>&nbsp;lambdaExpression)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents a subtraction
 assignment operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i274">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractChecked</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</td>
</tr>
<tr class="rowColor" id="i275">
<td class="colFirst"><code>static <a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractChecked</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a BinaryExpression that represents an arithmetic
 subtraction operation that has overflow checking.</div>
</td>
</tr>
<tr class="altColor" id="i276">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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)">switch_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</code></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</td>
</tr>
<tr class="rowColor" id="i277">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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...)">switch_</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</code></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i278">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">switch_</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>&gt;&nbsp;cases)</code></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</td>
</tr>
<tr class="rowColor" id="i279">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><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...)">switch_</a></span>&#8203;(<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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a>...&nbsp;cases)</code></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case, using varargs.</div>
</td>
</tr>
<tr class="altColor" id="i280">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">switch_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 that has a default case.</div>
</td>
</tr>
<tr class="rowColor" id="i281">
<td class="colFirst"><code>static <a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">switch_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a SwitchExpression that represents a switch statement
 without a default case.</div>
</td>
</tr>
<tr class="altColor" id="i282">
<td class="colFirst"><code>static <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#switchCase(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">switchCase</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&gt;&nbsp;body)</code></th>
<td class="colLast">
<div class="block">Creates a SwitchCase for use in a SwitchExpression.</div>
</td>
</tr>
<tr class="rowColor" id="i283">
<td class="colFirst"><code>static <a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#switchCase(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">switchCase</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a SwitchCase for use in a SwitchExpression, with varargs.</div>
</td>
</tr>
<tr class="altColor" id="i284">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#symbolDocument(java.lang.String)">symbolDocument</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName)</code></th>
<td class="colLast">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</td>
</tr>
<tr class="rowColor" id="i285">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#symbolDocument(java.lang.String,java.util.UUID)">symbolDocument</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language)</code></th>
<td class="colLast">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</td>
</tr>
<tr class="altColor" id="i286">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#symbolDocument(java.lang.String,java.util.UUID,java.util.UUID)">symbolDocument</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;vendor)</code></th>
<td class="colLast">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</td>
</tr>
<tr class="rowColor" id="i287">
<td class="colFirst"><code>static org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#symbolDocument(java.lang.String,java.util.UUID,java.util.UUID,java.util.UUID)">symbolDocument</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filename,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;vendor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;documentType)</code></th>
<td class="colLast">
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</td>
</tr>
<tr class="altColor" id="i288">
<td class="colFirst"><code>static <a href="ThrowStatement.html" title="class in org.apache.calcite.linq4j.tree">ThrowStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#throw_(org.apache.calcite.linq4j.tree.Expression)">throw_</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a statement that represents the throwing of an exception.</div>
</td>
</tr>
<tr class="rowColor" id="i289">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#toString(java.util.List,java.lang.String,boolean)">toString</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">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/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;sep,
boolean&nbsp;generics)</code></th>
<td class="colLast">
<div class="block">Converts a list of expressions to Java source code, optionally emitting
 extra type information in generics.</div>
</td>
</tr>
<tr class="altColor" id="i290">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#toString(org.apache.calcite.linq4j.tree.Node)">toString</a></span>&#8203;(<a href="Node.html" title="interface in org.apache.calcite.linq4j.tree">Node</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Converts an expression to Java source code.</div>
</td>
</tr>
<tr class="rowColor" id="i291">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#tryCatch(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable)">tryCatch</a></span>&#8203;(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">Iterable</a>&lt;? extends <a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a>&gt;&nbsp;handlers)</code></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and neither a fault nor finally
 block.</div>
</td>
</tr>
<tr class="altColor" id="i292">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#tryCatch(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">tryCatch</a></span>&#8203;(<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></th>
<td class="colLast">
<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>
</td>
</tr>
<tr class="rowColor" id="i293">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable,org.apache.calcite.linq4j.tree.Statement)">tryCatchFinally</a></span>&#8203;(<a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and a finally block.</div>
</td>
</tr>
<tr class="altColor" id="i294">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">tryCatchFinally</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with any
 number of catch statements and a finally block, with varargs.</div>
</td>
</tr>
<tr class="rowColor" id="i295">
<td class="colFirst"><code>static <a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#tryFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement)">tryFinally</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a TryExpression representing a try block with a
 finally block and no catch statements.</div>
</td>
</tr>
<tr class="altColor" id="i296">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#typeAs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeAs</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an explicit
 reference or boxing conversion where null is supplied if the
 conversion fails.</div>
</td>
</tr>
<tr class="rowColor" id="i297">
<td class="colFirst"><code>static <a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#typeEqual(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeEqual</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a TypeBinaryExpression that compares run-time type
 identity.</div>
</td>
</tr>
<tr class="altColor" id="i298">
<td class="colFirst"><code>static <a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#typeIs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeIs</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a TypeBinaryExpression.</div>
</td>
</tr>
<tr class="rowColor" id="i299">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#unaryPlus(org.apache.calcite.linq4j.tree.Expression)">unaryPlus</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a unary plus
 operation.</div>
</td>
</tr>
<tr class="altColor" id="i300">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#unaryPlus(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">unaryPlus</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents a unary plus
 operation.</div>
</td>
</tr>
<tr class="rowColor" id="i301">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#unbox(org.apache.calcite.linq4j.tree.Expression)">unbox</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression)</code></th>
<td class="colLast">
<div class="block">Converts e.g.</div>
</td>
</tr>
<tr class="altColor" id="i302">
<td class="colFirst"><code>static <a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#unbox(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">unbox</a></span>&#8203;(<a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a UnaryExpression that represents an explicit
 unboxing.</div>
</td>
</tr>
<tr class="rowColor" id="i303">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#unbox(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">unbox</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Returns an expression to unbox the value of a boxed-primitive expression.</div>
</td>
</tr>
<tr class="altColor" id="i304">
<td class="colFirst"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#variable(java.lang.reflect.Type)">variable</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</td>
</tr>
<tr class="rowColor" id="i305">
<td class="colFirst"><code>static <a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#variable(java.lang.reflect.Type,java.lang.String)">variable</a></span>&#8203;(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</code></th>
<td class="colLast">
<div class="block">Creates a ParameterExpression node that can be used to
 identify a parameter or a variable in an expression tree.</div>
</td>
</tr>
<tr class="altColor" id="i306">
<td class="colFirst"><code>static <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#visitChildren(org.apache.calcite.linq4j.tree.ExpressionVisitor)">visitChildren</a></span>&#8203;(<a href="ExpressionVisitor.html" title="interface in org.apache.calcite.linq4j.tree">ExpressionVisitor</a>&nbsp;visitor)</code></th>
<td class="colLast">
<div class="block">Reduces the node and then calls the visitor delegate on the
 reduced expression.</div>
</td>
</tr>
<tr class="rowColor" id="i307">
<td class="colFirst"><code>static <a href="WhileStatement.html" title="class in org.apache.calcite.linq4j.tree">WhileStatement</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#while_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">while_</a></span>&#8203;(<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></th>
<td class="colLast">
<div class="block">Creates a WhileExpression representing a while loop.</div>
</td>
</tr>
</tbody>
</table>
</div>
</div>
<div class="inheritedList">
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></h3>
<a id="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a><code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang" class="externalLink">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang" class="externalLink">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang" class="externalLink">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang" class="externalLink">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang" class="externalLink">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang" class="externalLink">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang" class="externalLink">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true#wait(long,int)" title="class or interface in java.lang" class="externalLink">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<li class="blockList">
<section class="methodDetails"><a id="method.detail">
<!--   -->
</a>
<h2>Method Details</h2>
<ul class="blockList">
<li class="blockList">
<section class="detail">
<h3><a id="toString(java.util.List,java.lang.String,boolean)">toString</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></span>&nbsp;<span class="memberName">toString</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">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/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="toString(org.apache.calcite.linq4j.tree.Node)">toString</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a></span>&nbsp;<span class="memberName">toString</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">add</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">add</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="add(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">add</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">add</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="addAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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)">addAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssignChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="addAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">addAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">addChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="addChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">addChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">addChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">and</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">and</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="and(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">and</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">and</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">andAlso</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">andAlso</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="andAlso(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">andAlso</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">andAlso</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">andAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">andAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">andAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">andAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise AND
 assignment operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="andAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">andAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">andAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="arrayIndex(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">arrayIndex</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="memberName">arrayIndex</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="arrayLength(org.apache.calcite.linq4j.tree.Expression)">arrayLength</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">arrayLength</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="assign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">assign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">assign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="bind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.Expression)">bind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></span>&nbsp;<span class="memberName">bind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="bind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression)">bind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberAssignment.html" title="class in org.apache.calcite.linq4j.tree">MemberAssignment</a></span>&nbsp;<span class="memberName">bind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="block(java.lang.Iterable)">block</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="memberName">block</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="block(org.apache.calcite.linq4j.tree.Statement...)">block</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="memberName">block</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="block(java.lang.reflect.Type,java.lang.Iterable)">block</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="memberName">block</span>&#8203;(<span class="arguments">@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="block(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Statement...)">block</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a></span>&nbsp;<span class="memberName">block</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="break_(org.apache.calcite.linq4j.tree.LabelTarget)">break_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">break_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">break_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">break_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="break_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">break_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">break_</span>&#8203;(<span class="arguments"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a break statement with
 the specified type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="break_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">break_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">break_</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Method,java.lang.Iterable)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments">@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments">@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,java.lang.Iterable)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;target,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Type,java.lang.String,java.lang.Iterable)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;methodName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="call(java.lang.reflect.Type,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">call</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodCallExpression.html" title="class in org.apache.calcite.linq4j.tree">MethodCallExpression</a></span>&nbsp;<span class="memberName">call</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="catch_(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Statement)">catch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></span>&nbsp;<span class="memberName">catch_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="clearDebugInfo()">clearDebugInfo</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">clearDebugInfo</span>()</div>
<div class="block">Creates a DebugInfoExpression for clearing a sequence
 point.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">coalesce</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">coalesce</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="coalesce(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.LambdaExpression)">coalesce</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">coalesce</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">condition</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">condition</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="isConstantNull(org.apache.calcite.linq4j.tree.Expression)">isConstantNull</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">boolean</span>&nbsp;<span class="memberName">isConstantNull</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="condition(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">condition</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConditionalExpression.html" title="class in org.apache.calcite.linq4j.tree">ConditionalExpression</a></span>&nbsp;<span class="memberName">condition</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/Void.html?is-external=true#TYPE" title="class or interface in java.lang" class="externalLink"><code>void</code></a>.</p></div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="constant(java.lang.Object)">constant</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></span>&nbsp;<span class="memberName">constant</span>&#8203;(<span class="arguments">@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="constant(java.lang.Object,java.lang.reflect.Type)">constant</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConstantExpression.html" title="class in org.apache.calcite.linq4j.tree">ConstantExpression</a></span>&nbsp;<span class="memberName">constant</span>&#8203;(<span class="arguments">@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a>&nbsp;value,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="continue_(org.apache.calcite.linq4j.tree.LabelTarget)">continue_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">continue_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="continue_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">continue_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">continue_</span>&#8203;(<span class="arguments"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a continue statement
 with the specified type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">convert_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">convert_</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents a type conversion
 operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="convert_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">convert_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">convert_</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="convertChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">convertChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">convertChecked</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="convertChecked_(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">convertChecked_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">convertChecked_</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="debugInfo()">debugInfo</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">void</span>&nbsp;<span class="memberName">debugInfo</span>()</div>
<div class="block">Creates a DebugInfoExpression with the specified span.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="decrement(org.apache.calcite.linq4j.tree.Expression)">decrement</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">decrement</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="decrement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">decrement</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">decrement</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="default_()">default_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></span>&nbsp;<span class="memberName">default_</span>()</div>
<div class="block">Creates a DefaultExpression that has the Type property set to
 the specified type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">divide</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">divide</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="divide(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">divide</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">divide</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">divideAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">divideAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">divideAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">divideAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="divideAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">divideAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">divideAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,java.lang.Iterable)">dynamic</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="memberName">dynamic</span>&#8203;(<span class="arguments"><a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="dynamic(org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">dynamic</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="memberName">dynamic</span>&#8203;(<span class="arguments"><a href="CallSiteBinder.html" title="interface in org.apache.calcite.linq4j.tree">CallSiteBinder</a>&nbsp;binder,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="elementInit(java.lang.reflect.Method,java.lang.Iterable)">elementInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></span>&nbsp;<span class="memberName">elementInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="elementInit(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">elementInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ElementInit.html" title="class in org.apache.calcite.linq4j.tree">ElementInit</a></span>&nbsp;<span class="memberName">elementInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="empty()">empty</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DefaultExpression.html" title="class in org.apache.calcite.linq4j.tree">DefaultExpression</a></span>&nbsp;<span class="memberName">empty</span>()</div>
<div class="block">Creates an empty expression that has Void type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">equal</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">equal</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="equal(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">equal</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">equal</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">exclusiveOr</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">exclusiveOr</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="exclusiveOr(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">exclusiveOr</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">exclusiveOr</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">exclusiveOrAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">exclusiveOrAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">exclusiveOrAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">exclusiveOrAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="exclusiveOrAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">exclusiveOrAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">exclusiveOrAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Field)">field</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">field</span>&#8203;(<span class="arguments">@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Field.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Field</a>&nbsp;field)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="field(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">field</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">field</span>&#8203;(<span class="arguments">@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 class="blockList">
<section class="detail">
<h3><a id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">field</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">field</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="field(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">field</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">field</span>&#8203;(<span class="arguments">@Nullable <a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fieldName)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a field.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="getActionType(java.lang.Class...)">getActionType</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></span>&nbsp;<span class="memberName">getActionType</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="getDelegateType(java.lang.Class...)">getDelegateType</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></span>&nbsp;<span class="memberName">getDelegateType</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="getFuncType(java.lang.Class...)">getFuncType</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">Class</a></span>&nbsp;<span class="memberName">getFuncType</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="goto_(org.apache.calcite.linq4j.tree.LabelTarget)">goto_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">goto_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">goto_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">goto_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">goto_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">goto_</span>&#8203;(<span class="arguments"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="goto_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">goto_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">goto_</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">greaterThan</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">greaterThan</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="greaterThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">greaterThan</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">greaterThan</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">greaterThanOrEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">greaterThanOrEqual</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="greaterThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">greaterThanOrEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">greaterThanOrEqual</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="ifThen(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node)">ifThen</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="memberName">ifThen</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node,org.apache.calcite.linq4j.tree.Node)">ifThenElse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="memberName">ifThenElse</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="ifThenElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Node...)">ifThenElse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="memberName">ifThenElse</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="ifThenElse(java.lang.Iterable)">ifThenElse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConditionalStatement.html" title="class in org.apache.calcite.linq4j.tree">ConditionalStatement</a></span>&nbsp;<span class="memberName">ifThenElse</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="increment(org.apache.calcite.linq4j.tree.Expression)">increment</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">increment</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="increment(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">increment</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">increment</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="invoke(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">invoke</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></span>&nbsp;<span class="memberName">invoke</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="invoke(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">invoke</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="InvocationExpression.html" title="class in org.apache.calcite.linq4j.tree">InvocationExpression</a></span>&nbsp;<span class="memberName">invoke</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="isFalse(org.apache.calcite.linq4j.tree.Expression)">isFalse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">isFalse</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="isFalse(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">isFalse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">isFalse</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Returns whether the expression evaluates to false.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="isTrue(org.apache.calcite.linq4j.tree.Expression)">isTrue</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">isTrue</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="isTrue(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">isTrue</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">isTrue</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Returns whether the expression evaluates to true.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="label()">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="memberName">label</span>()</div>
<div class="block">Creates a LabelTarget representing a label with X type and
 no name.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="label(org.apache.calcite.linq4j.tree.LabelTarget)">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></span>&nbsp;<span class="memberName">label</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="label(java.lang.String)">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="memberName">label</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="label(java.lang.reflect.Type)">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="memberName">label</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a LabelTarget representing a label with the given
 type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="label(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelStatement.html" title="class in org.apache.calcite.linq4j.tree">LabelStatement</a></span>&nbsp;<span class="memberName">label</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="label(java.lang.reflect.Type,java.lang.String)">label</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a></span>&nbsp;<span class="memberName">label</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(org.apache.calcite.linq4j.function.Function)">
<!--   -->
</a><a id="lambda(F)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments">F&nbsp;function)</span></div>
<div class="block">Creates a FunctionExpression from an actual function.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="lambda(org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="BlockStatement.html" title="class in org.apache.calcite.linq4j.tree">BlockStatement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="lambda(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;F extends <a href="../function/Function.html" title="interface in org.apache.calcite.linq4j.function">Function</a>&lt;?&gt;&gt;</span>
<span class="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,java.lang.Iterable)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T,&#8203;
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="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.BlockStatement,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T,&#8203;
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="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T,&#8203;
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="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lambda(java.lang.Class,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.ParameterExpression...)">lambda</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T,&#8203;
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="returnType"><a href="FunctionExpression.html" title="class in org.apache.calcite.linq4j.tree">FunctionExpression</a>&lt;F&gt;</span>&nbsp;<span class="memberName">lambda</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">leftShift</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">leftShift</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="leftShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">leftShift</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">leftShift</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">leftShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">leftShiftAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">leftShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">leftShiftAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 left-shift assignment operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="leftShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">leftShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">leftShiftAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">lessThan</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">lessThan</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="lessThan(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">lessThan</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">lessThan</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a "less than"
 numeric comparison.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">lessThanOrEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">lessThanOrEqual</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="lessThanOrEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">lessThanOrEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">lessThanOrEqual</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listBind(java.lang.reflect.Member,java.lang.Iterable)">listBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="memberName">listBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.ElementInit...)">listBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="memberName">listBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listBind(java.lang.reflect.Method,java.lang.Iterable)">listBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="memberName">listBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.ElementInit...)">listBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberListBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberListBinding</a></span>&nbsp;<span class="memberName">listBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">listInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInit</span>&#8203;(<span class="arguments"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.ElementInit...)">listInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInit</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="listInitE(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">listInitE</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInitE</span>&#8203;(<span class="arguments"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.Expression...)">listInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInit</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,java.lang.Iterable)">listInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInit</span>&#8203;(<span class="arguments"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="listInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.Expression...)">listInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ListInitExpression.html" title="class in org.apache.calcite.linq4j.tree">ListInitExpression</a></span>&nbsp;<span class="memberName">listInit</span>&#8203;(<span class="arguments"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="for_(java.lang.Iterable,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">for_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></span>&nbsp;<span class="memberName">for_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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)">for_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ForStatement.html" title="class in org.apache.calcite.linq4j.tree">ForStatement</a></span>&nbsp;<span class="memberName">for_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="forEach(org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">forEach</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ForEachStatement.html" title="class in org.apache.calcite.linq4j.tree">ForEachStatement</a></span>&nbsp;<span class="memberName">forEach</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="makeBinary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">makeBinary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">makeBinary</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="box(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">box</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">box</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="box(org.apache.calcite.linq4j.tree.Expression)">box</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">box</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="unbox(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Primitive)">unbox</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">unbox</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>Number</code></a>)."Value</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="unbox(org.apache.calcite.linq4j.tree.Expression)">unbox</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">unbox</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a 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)">makeBinary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">makeBinary</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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)">makeBinary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">makeBinary</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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)">makeTernary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TernaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TernaryExpression</a></span>&nbsp;<span class="memberName">makeTernary</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="makeCatchBlock(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">makeCatchBlock</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="CatchBlock.html" title="class in org.apache.calcite.linq4j.tree">CatchBlock</a></span>&nbsp;<span class="memberName">makeCatchBlock</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,java.lang.Iterable)">makeDynamic</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="memberName">makeDynamic</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="makeDynamic(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.CallSiteBinder,org.apache.calcite.linq4j.tree.Expression...)">makeDynamic</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DynamicExpression.html" title="class in org.apache.calcite.linq4j.tree">DynamicExpression</a></span>&nbsp;<span class="memberName">makeDynamic</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">makeGoto</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">makeGoto</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="makeMemberAccess(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.PseudoField)">makeMemberAccess</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">makeMemberAccess</span>&#8203;(<span class="arguments">@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 class="blockList">
<section class="detail">
<h3><a 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)">makeTry</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">makeTry</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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...)">makeTry</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">makeTry</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression)">makeUnary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">makeUnary</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="makeUnary(org.apache.calcite.linq4j.tree.ExpressionType,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.reflect.Method)">makeUnary</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">makeUnary</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberBind(java.lang.reflect.Member,java.lang.Iterable)">memberBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="memberName">memberBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Member</a>&nbsp;member,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberBind(java.lang.reflect.Member,org.apache.calcite.linq4j.tree.MemberBinding...)">memberBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="memberName">memberBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Member.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberBind(java.lang.reflect.Method,java.lang.Iterable)">memberBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="memberName">memberBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberBind(java.lang.reflect.Method,org.apache.calcite.linq4j.tree.MemberBinding...)">memberBind</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberMemberBinding.html" title="class in org.apache.calcite.linq4j.tree">MemberMemberBinding</a></span>&nbsp;<span class="memberName">memberBind</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberInit(org.apache.calcite.linq4j.tree.NewExpression,java.lang.Iterable)">memberInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></span>&nbsp;<span class="memberName">memberInit</span>&#8203;(<span class="arguments"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a>&nbsp;newExpression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="memberInit(org.apache.calcite.linq4j.tree.NewExpression,org.apache.calcite.linq4j.tree.MemberBinding...)">memberInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberInitExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberInitExpression</a></span>&nbsp;<span class="memberName">memberInit</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="methodDecl(int,java.lang.reflect.Type,java.lang.String,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">methodDecl</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MethodDeclaration.html" title="class in org.apache.calcite.linq4j.tree">MethodDeclaration</a></span>&nbsp;<span class="memberName">methodDecl</span>&#8203;(<span class="arguments">int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;resultType,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="constructorDecl(int,java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.BlockStatement)">constructorDecl</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ConstructorDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ConstructorDeclaration</a></span>&nbsp;<span class="memberName">constructorDecl</span>&#8203;(<span class="arguments">int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;declaredAgainst,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">fieldDecl</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></span>&nbsp;<span class="memberName">fieldDecl</span>&#8203;(<span class="arguments">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 class="blockList">
<section class="detail">
<h3><a id="fieldDecl(int,org.apache.calcite.linq4j.tree.ParameterExpression)">fieldDecl</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="FieldDeclaration.html" title="class in org.apache.calcite.linq4j.tree">FieldDeclaration</a></span>&nbsp;<span class="memberName">fieldDecl</span>&#8203;(<span class="arguments">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 class="blockList">
<section class="detail">
<h3><a id="classDecl(int,java.lang.String,java.lang.reflect.Type,java.util.List,java.util.List)">classDecl</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ClassDeclaration.html" title="class in org.apache.calcite.linq4j.tree">ClassDeclaration</a></span>&nbsp;<span class="memberName">classDecl</span>&#8203;(<span class="arguments">int&nbsp;modifier,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name,
@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;extended,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&gt;&nbsp;implemented,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">modulo</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">modulo</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="modulo(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">modulo</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">modulo</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an arithmetic
 remainder operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">moduloAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">moduloAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">moduloAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">moduloAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a remainder
 assignment operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="moduloAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">moduloAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">moduloAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiply</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiply</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="multiply(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiply</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiply</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">multiplyAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssignChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiplyAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">multiplyAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">multiplyChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="multiplyChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">multiplyChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">multiplyChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="negate(org.apache.calcite.linq4j.tree.Expression)">negate</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">negate</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="negate(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">negate</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">negate</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents an arithmetic
 negation operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="negateChecked(org.apache.calcite.linq4j.tree.Expression)">negateChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">negateChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="negateChecked(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">negateChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">negateChecked</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Constructor)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Type)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Type,java.lang.Iterable)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Type,java.lang.Iterable,java.lang.Iterable)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Type,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Constructor,java.lang.Iterable)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Constructor,org.apache.calcite.linq4j.tree.Expression...)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Constructor,java.lang.Iterable,java.lang.Iterable)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="new_(java.lang.reflect.Constructor,java.lang.Iterable,org.apache.calcite.linq4j.tree.MemberDeclaration...)">new_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewExpression.html" title="class in org.apache.calcite.linq4j.tree">NewExpression</a></span>&nbsp;<span class="memberName">new_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Constructor.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Constructor</a>&nbsp;constructor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="newArrayBounds(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression)">newArrayBounds</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="memberName">newArrayBounds</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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>
<dt><span class="paramLabel">Parameters:</span></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 class="blockList">
<section class="detail">
<h3><a id="newArrayInit(java.lang.reflect.Type,java.lang.Iterable)">newArrayInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="memberName">newArrayInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="newArrayInit(java.lang.reflect.Type,org.apache.calcite.linq4j.tree.Expression...)">newArrayInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="memberName">newArrayInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>type</code> - Element type of the array</dd>
<dd><code>expressions</code> - Initializer expressions</dd>
</dl>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="newArrayInit(java.lang.reflect.Type,int,java.lang.Iterable)">newArrayInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="memberName">newArrayInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
int&nbsp;dimension,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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>
<dt><span class="paramLabel">Parameters:</span></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 class="blockList">
<section class="detail">
<h3><a id="newArrayInit(java.lang.reflect.Type,int,org.apache.calcite.linq4j.tree.Expression...)">newArrayInit</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="NewArrayExpression.html" title="class in org.apache.calcite.linq4j.tree">NewArrayExpression</a></span>&nbsp;<span class="memberName">newArrayInit</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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>
<dt><span class="paramLabel">Parameters:</span></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 class="blockList">
<section class="detail">
<h3><a id="not(org.apache.calcite.linq4j.tree.Expression)">not</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">not</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="not(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">not</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">not</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">notEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">notEqual</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="notEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,boolean,java.lang.reflect.Method)">notEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">notEqual</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents an inequality
 comparison.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="onesComplement(org.apache.calcite.linq4j.tree.Expression)">onesComplement</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">onesComplement</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="onesComplement(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">onesComplement</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">onesComplement</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Returns the expression representing the ones complement.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">or</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">or</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="or(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">or</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">or</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">orAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">orAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">orAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">orAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise OR
 assignment operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="orAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">orAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">orAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">orElse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">orElse</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="orElse(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">orElse</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">orElse</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="parameter(java.lang.reflect.Type)">parameter</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="memberName">parameter</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="parameter(java.lang.reflect.Type,java.lang.String)">parameter</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="memberName">parameter</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="parameter(int,java.lang.reflect.Type,java.lang.String)">parameter</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="memberName">parameter</span>&#8203;(<span class="arguments">int&nbsp;modifiers,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</span></div>
<div class="block">Creates a ParameterExpression.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="postDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">postDecrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">postDecrementAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="postDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">postDecrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">postDecrementAssign</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="postIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">postIncrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">postIncrementAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="postIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">postIncrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">postIncrementAssign</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">power</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">power</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="power(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">power</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">power</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents raising a number to
 a power.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">powerAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">powerAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">powerAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">powerAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="powerAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">powerAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">powerAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="preDecrementAssign(org.apache.calcite.linq4j.tree.Expression)">preDecrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">preDecrementAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="preDecrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">preDecrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">preDecrementAssign</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="preIncrementAssign(org.apache.calcite.linq4j.tree.Expression)">preIncrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">preIncrementAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="preIncrementAssign(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">preIncrementAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">preIncrementAssign</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,java.lang.Iterable)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expressions.PropertyInfo,org.apache.calcite.linq4j.tree.Expression...)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.String,org.apache.calcite.linq4j.tree.Expression...)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="IndexExpression.html" title="class in org.apache.calcite.linq4j.tree">IndexExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="property(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type,java.lang.String)">property</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">property</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;name)</span></div>
<div class="block">Creates a MemberExpression accessing a property.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="propertyOrField(org.apache.calcite.linq4j.tree.Expression,java.lang.String)">propertyOrField</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="MemberExpression.html" title="class in org.apache.calcite.linq4j.tree">MemberExpression</a></span>&nbsp;<span class="memberName">propertyOrField</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;propertyOfFieldName)</span></div>
<div class="block">Creates a MemberExpression that represents accessing a
 property or field.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="quote(org.apache.calcite.linq4j.tree.Expression)">quote</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">quote</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="reduce(org.apache.calcite.linq4j.tree.Expression)">reduce</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">reduce</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="reduceAndCheck(org.apache.calcite.linq4j.tree.Expression)">reduceAndCheck</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">reduceAndCheck</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="reduceExtensions(org.apache.calcite.linq4j.tree.Expression)">reduceExtensions</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">reduceExtensions</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="referenceEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">referenceEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">referenceEqual</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="referenceNotEqual(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">referenceNotEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">referenceNotEqual</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="rethrow()">rethrow</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">rethrow</span>()</div>
<div class="block">Creates a UnaryExpression that represents a rethrowing of an
 exception.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="rethrow(java.lang.reflect.Type)">rethrow</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">rethrow</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="return_(org.apache.calcite.linq4j.tree.LabelTarget)">return_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">return_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">return_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">return_</span>&#8203;(<span class="arguments">@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 class="blockList">
<section class="detail">
<h3><a id="makeGoto(org.apache.calcite.linq4j.tree.GotoExpressionKind,org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression)">makeGoto</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">makeGoto</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="return_(org.apache.calcite.linq4j.tree.LabelTarget,java.lang.reflect.Type)">return_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">return_</span>&#8203;(<span class="arguments"><a href="LabelTarget.html" title="class in org.apache.calcite.linq4j.tree">LabelTarget</a>&nbsp;labelTarget,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a GotoExpression representing a return statement with
 the specified type.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="return_(org.apache.calcite.linq4j.tree.LabelTarget,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">return_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="GotoStatement.html" title="class in org.apache.calcite.linq4j.tree">GotoStatement</a></span>&nbsp;<span class="memberName">return_</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">rightShift</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">rightShift</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="rightShift(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">rightShift</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">rightShift</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">rightShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">rightShiftAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">rightShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">rightShiftAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a BinaryExpression that represents a bitwise
 right-shift assignment operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="rightShiftAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">rightShiftAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">rightShiftAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="runtimeVariables(java.lang.Iterable)">runtimeVariables</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</span>&nbsp;<span class="memberName">runtimeVariables</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="runtimeVariables(org.apache.calcite.linq4j.tree.ParameterExpression...)">runtimeVariables</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.RuntimeVariablesExpression</span>&nbsp;<span class="memberName">runtimeVariables</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtract</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtract</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="subtract(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtract</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtract</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssign</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="subtractAssign(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">subtractAssign</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssign</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssignChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="subtractAssignChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.LambdaExpression)">subtractAssignChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractAssignChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression)">subtractChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractChecked</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="subtractChecked(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">subtractChecked</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="BinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">BinaryExpression</a></span>&nbsp;<span class="memberName">subtractChecked</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.SwitchCase...)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,java.lang.Iterable)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="switch_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method,org.apache.calcite.linq4j.tree.SwitchCase...)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a 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...)">switch_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchStatement.html" title="class in org.apache.calcite.linq4j.tree">SwitchStatement</a></span>&nbsp;<span class="memberName">switch_</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="switchCase(org.apache.calcite.linq4j.tree.Expression,java.lang.Iterable)">switchCase</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></span>&nbsp;<span class="memberName">switchCase</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="switchCase(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Expression...)">switchCase</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="SwitchCase.html" title="class in org.apache.calcite.linq4j.tree">SwitchCase</a></span>&nbsp;<span class="memberName">switchCase</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="symbolDocument(java.lang.String)">symbolDocument</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="memberName">symbolDocument</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="symbolDocument(java.lang.String,java.util.UUID)">symbolDocument</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="memberName">symbolDocument</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="symbolDocument(java.lang.String,java.util.UUID,java.util.UUID)">symbolDocument</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="memberName">symbolDocument</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;fileName,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;vendor)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="symbolDocument(java.lang.String,java.util.UUID,java.util.UUID,java.util.UUID)">symbolDocument</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">org.apache.calcite.linq4j.tree.Expressions.SymbolDocumentInfo</span>&nbsp;<span class="memberName">symbolDocument</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;filename,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;language,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;vendor,
<a href="https://docs.oracle.com/javase/9/docs/api/java/util/UUID.html?is-external=true" title="class or interface in java.util" class="externalLink">UUID</a>&nbsp;documentType)</span></div>
<div class="block">Creates an instance of SymbolDocumentInfo.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="throw_(org.apache.calcite.linq4j.tree.Expression)">throw_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ThrowStatement.html" title="class in org.apache.calcite.linq4j.tree">ThrowStatement</a></span>&nbsp;<span class="memberName">throw_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="tryCatch(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable)">tryCatch</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">tryCatch</span>&#8203;(<span class="arguments"><a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="tryCatch(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">tryCatch</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">tryCatch</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,java.lang.Iterable,org.apache.calcite.linq4j.tree.Statement)">tryCatchFinally</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">tryCatchFinally</span>&#8203;(<span class="arguments"><a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a>&nbsp;body,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="tryCatchFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.CatchBlock...)">tryCatchFinally</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">tryCatchFinally</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="tryFinally(org.apache.calcite.linq4j.tree.Statement,org.apache.calcite.linq4j.tree.Statement)">tryFinally</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TryStatement.html" title="class in org.apache.calcite.linq4j.tree">TryStatement</a></span>&nbsp;<span class="memberName">tryFinally</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="typeAs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeAs</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">typeAs</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="typeEqual(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeEqual</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></span>&nbsp;<span class="memberName">typeEqual</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a TypeBinaryExpression that compares run-time type
 identity.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="typeIs(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">typeIs</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="TypeBinaryExpression.html" title="class in org.apache.calcite.linq4j.tree">TypeBinaryExpression</a></span>&nbsp;<span class="memberName">typeIs</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a TypeBinaryExpression.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="unaryPlus(org.apache.calcite.linq4j.tree.Expression)">unaryPlus</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">unaryPlus</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="unaryPlus(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Method)">unaryPlus</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">unaryPlus</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Method.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Method</a>&nbsp;method)</span></div>
<div class="block">Creates a UnaryExpression that represents a unary plus
 operation.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="unbox(org.apache.calcite.linq4j.tree.Expression,java.lang.reflect.Type)">unbox</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="UnaryExpression.html" title="class in org.apache.calcite.linq4j.tree">UnaryExpression</a></span>&nbsp;<span class="memberName">unbox</span>&#8203;(<span class="arguments"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a>&nbsp;expression,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type)</span></div>
<div class="block">Creates a UnaryExpression that represents an explicit
 unboxing.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="variable(java.lang.reflect.Type)">variable</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="memberName">variable</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="variable(java.lang.reflect.Type,java.lang.String)">variable</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="ParameterExpression.html" title="class in org.apache.calcite.linq4j.tree">ParameterExpression</a></span>&nbsp;<span class="memberName">variable</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/reflect/Type.html?is-external=true" title="class or interface in java.lang.reflect" class="externalLink">Type</a>&nbsp;type,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="visitChildren(org.apache.calcite.linq4j.tree.ExpressionVisitor)">visitChildren</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">visitChildren</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="while_(org.apache.calcite.linq4j.tree.Expression,org.apache.calcite.linq4j.tree.Statement)">while_</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="WhileStatement.html" title="class in org.apache.calcite.linq4j.tree">WhileStatement</a></span>&nbsp;<span class="memberName">while_</span>&#8203;(<span class="arguments"><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 class="blockList">
<section class="detail">
<h3><a id="declare(int,org.apache.calcite.linq4j.tree.ParameterExpression,org.apache.calcite.linq4j.tree.Expression)">declare</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></span>&nbsp;<span class="memberName">declare</span>&#8203;(<span class="arguments">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 class="blockList">
<section class="detail">
<h3><a id="declare(int,java.lang.String,org.apache.calcite.linq4j.tree.Expression)">declare</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="DeclarationStatement.html" title="class in org.apache.calcite.linq4j.tree">DeclarationStatement</a></span>&nbsp;<span class="memberName">declare</span>&#8203;(<span class="arguments">int&nbsp;modifiers,
<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="statement(org.apache.calcite.linq4j.tree.Expression)">statement</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Statement.html" title="class in org.apache.calcite.linq4j.tree">Statement</a></span>&nbsp;<span class="memberName">statement</span>&#8203;(<span class="arguments">@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 class="blockList">
<section class="detail">
<h3><a id="foldAnd(java.util.List)">foldAnd</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">foldAnd</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="foldOr(java.util.List)">foldOr</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType"><a href="Expression.html" title="class in org.apache.calcite.linq4j.tree">Expression</a></span>&nbsp;<span class="memberName">foldOr</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="list()">list</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T&gt;</span>&nbsp;<span class="returnType"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="memberName">list</span>()</div>
<div class="block">Creates an empty fluent list.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="list(java.lang.Object[])">
<!--   -->
</a><a id="list(T...)">list</a></h3>
<div class="memberSignature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/SafeVarargs.html?is-external=true" title="class or interface in java.lang" class="externalLink">@SafeVarargs</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T&gt;</span>&nbsp;<span class="returnType"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="memberName">list</span>&#8203;(<span class="arguments">T...&nbsp;ts)</span></div>
<div class="block">Creates a fluent list with given elements.</div>
</section>
</li>
<li class="blockList">
<section class="detail">
<h3><a id="list(java.lang.Iterable)">list</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="typeParameters">&lt;T&gt;</span>&nbsp;<span class="returnType"><a href="Expressions.FluentList.html" title="interface in org.apache.calcite.linq4j.tree">Expressions.FluentList</a>&lt;T&gt;</span>&nbsp;<span class="memberName">list</span>&#8203;(<span class="arguments"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html?is-external=true" title="class or interface in java.lang" class="externalLink">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 class="blockList">
<section class="detail">
<h3><a id="evaluate(org.apache.calcite.linq4j.tree.Node)">evaluate</a></h3>
<div class="memberSignature"><span class="modifiers">public static</span>&nbsp;<span class="returnType">@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></span>&nbsp;<span class="memberName">evaluate</span>&#8203;(<span class="arguments"><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>
</div>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">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">Help</a></li>
</ul>
<div class="aboutLanguage"><b>Apache Calcite</b></div>
</div>
<div class="subNav">
<div>
<ul class="subNavList">
<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="subNavList">
<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>
<a id="skip.navbar.bottom">
<!--   -->
</a>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &copy; 2012-2021 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
