<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlOperatorFixture (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.sql.test, interface: SqlOperatorFixture">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql.test</a></div>
<h1 title="Interface SqlOperatorFixture" class="title">Interface SqlOperatorFixture</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Superinterfaces:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">SqlOperatorFixture</span><span class="extends-implements">
extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></span></div>
<div class="block">A fixture for testing the SQL operators.

 <p>It provides a fluent API so that you can write tests by chaining method
 calls.

 <p>It is immutable. If you have two test cases that require a similar set up
 (for example, the same SQL expression and parser configuration), it is safe
 to use the same fixture object as a starting point for both tests.

 <p>The idea is that when you define an operator (or another piece of SQL
 functionality), you can define the logical behavior of that operator once, as
 part of that operator. Later you can define one or more physical
 implementations of that operator, and test them all using the same set of
 tests.

 <p>Depending on the implementation of <a href="SqlTester.html" title="interface in org.apache.calcite.sql.test"><code>SqlTester</code></a> used
 (see <a href="#withTester(java.util.function.UnaryOperator)"><code>withTester(UnaryOperator)</code></a>), the fixture may or may not
 evaluate expressions and check their results.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Interface</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlOperatorFixture.VmName.html" class="type-name-link" title="enum in org.apache.calcite.sql.test">SqlOperatorFixture.VmName</a></code></div>
<div class="col-last even-row-color">
<div class="block">Name of a virtual machine that can potentially implement an operator.</div>
</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#BAD_DATETIME_MESSAGE" class="member-name-link">BAD_DATETIME_MESSAGE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#DIVISION_BY_ZERO_MESSAGE" class="member-name-link">DIVISION_BY_ZERO_MESSAGE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#INVALID_ARGUMENTS_NUMBER" class="member-name-link">INVALID_ARGUMENTS_NUMBER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INVALID_CHAR_MESSAGE" class="member-name-link">INVALID_CHAR_MESSAGE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#INVALID_EXTRACT_UNIT_CONVERTLET_ERROR" class="member-name-link">INVALID_EXTRACT_UNIT_CONVERTLET_ERROR</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#INVALID_EXTRACT_UNIT_VALIDATION_ERROR" class="member-name-link">INVALID_EXTRACT_UNIT_VALIDATION_ERROR</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#LITERAL_OUT_OF_RANGE_MESSAGE" class="member-name-link">LITERAL_OUT_OF_RANGE_MESSAGE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#OUT_OF_RANGE_MESSAGE" class="member-name-link">OUT_OF_RANGE_MESSAGE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#STRING_TRUNC_MESSAGE" class="member-name-link">STRING_TRUNC_MESSAGE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button><button id="method-summary-table-tab5" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab5', 3)" class="table-tab">Default Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#brokenTestsEnabled()" class="member-name-link">brokenTestsEnabled</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns whether to run tests that are considered 'broken'.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#check(java.lang.String,java.lang.String,java.lang.Object)" class="member-name-link">check</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#check(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,java.lang.Object)" class="member-name-link">check</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Tests that a SQL query returns a single column with the given type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#check(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,org.apache.calcite.sql.test.SqlTester.ParameterChecker,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">check</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="SqlTester.ParameterChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ParameterChecker</a>&nbsp;parameterChecker,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Tests that a SQL query returns a result of expected type and value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkAgg(java.lang.String,java.lang.String%5B%5D,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">checkAgg</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;checker)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Checks that an aggregate expression returns the expected result.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkAggFails(java.lang.String,java.lang.String%5B%5D,java.lang.String,boolean)" class="member-name-link">checkAggFails</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that an aggregate expression fails at run time.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkAggType(java.lang.String,java.lang.String)" class="member-name-link">checkAggType</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Very similar to <a href="#checkType(java.lang.String,java.lang.String)"><code>checkType(java.lang.String, java.lang.String)</code></a>, but generates inside a SELECT
 with a non-empty GROUP BY.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkAggWithMultipleArgs(java.lang.String,java.lang.String%5B%5D%5B%5D,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">checkAggWithMultipleArgs</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[][]&nbsp;inputValues,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Checks that an aggregate expression with multiple args returns the expected
 result.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkBoolean(java.lang.String,java.lang.Boolean)" class="member-name-link">checkBoolean</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;result)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a scalar SQL expression returns the expected boolean result.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastFails(java.lang.String,java.lang.String,java.lang.String,boolean)" class="member-name-link">checkCastFails</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastToApproxOkay(java.lang.String,java.lang.String,java.lang.Object)" class="member-name-link">checkCastToApproxOkay</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;expected)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastToScalarOkay(java.lang.String,java.lang.String)" class="member-name-link">checkCastToScalarOkay</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastToScalarOkay(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">checkCastToScalarOkay</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastToString(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">checkCastToString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkCastToStringOkay(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">checkCastToStringOkay</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkColumnType(java.lang.String,java.lang.String)" class="member-name-link">checkColumnType</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sql,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Checks that a query returns one column of an expected type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkFails(java.lang.String,java.lang.String,boolean)" class="member-name-link">checkFails</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">As <a href="#checkFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String,boolean)"><code>checkFails(StringAndPos, String, boolean)</code></a>, but with a string
 that contains carets.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String,boolean)" class="member-name-link">checkFails</a><wbr>(<a href="../parser/StringAndPos.html" title="class in org.apache.calcite.sql.parser">StringAndPos</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a scalar SQL expression fails at run time.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkNull(java.lang.String)" class="member-name-link">checkNull</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a SQL expression returns the SQL NULL value.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkQuery(java.lang.String)" class="member-name-link">checkQuery</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sql)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a SQL query succeeds at prepare time.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkQueryFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String)" class="member-name-link">checkQueryFails</a><wbr>(<a href="../parser/StringAndPos.html" title="class in org.apache.calcite.sql.parser">StringAndPos</a>&nbsp;sap,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a SQL query fails at prepare time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkScalar(java.lang.String,java.lang.Object,java.lang.String)" class="member-name-link">checkScalar</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resultType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Tests that a scalar SQL expression returns the expected result and the
 expected type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkScalar(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">checkScalar</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkScalarApprox(java.lang.String,java.lang.String,java.lang.Object)" class="member-name-link">checkScalarApprox</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a scalar SQL expression returns expected approximate numeric
 result.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkScalarExact(java.lang.String,int)" class="member-name-link">checkScalarExact</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;result)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Tests that a scalar SQL expression returns the expected exact numeric
 result as an integer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#checkScalarExact(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">checkScalarExact</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;result)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Tests that a scalar SQL expression returns the expected exact numeric
 result.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkScalarExact(java.lang.String,java.lang.String,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">checkScalarExact</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkString(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">checkString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;result,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resultType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a scalar SQL expression returns the expected string result.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkType(java.lang.String,java.lang.String)" class="member-name-link">checkType</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Tests that a SQL expression has a given type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#checkWinAgg(java.lang.String,java.lang.String%5B%5D,java.lang.String,java.lang.String,org.apache.calcite.sql.test.SqlTester.ResultChecker)" class="member-name-link">checkWinAgg</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;windowSpec,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Checks that a windowed aggregate expression returns the expected result.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#conformance()" class="member-name-link">conformance</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns the conformance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#enableTypeCoercion(boolean)" class="member-name-link">enableTypeCoercion</a><wbr>(boolean&nbsp;enabled)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that tests with implicit type coercion on/off.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#forOracle(org.apache.calcite.sql.validate.SqlConformance)" class="member-name-link">forOracle</a><wbr>(<a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a>&nbsp;conformance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#getCastString(java.lang.String,java.lang.String,boolean)" class="member-name-link">getCastString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 boolean&nbsp;errorLoc)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlTestFactory.html" title="class in org.apache.calcite.sql.test">SqlTestFactory</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getFactory()" class="member-name-link">getFactory</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns the test factory.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlTester.html" title="interface in org.apache.calcite.sql.test">SqlTester</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getTester()" class="member-name-link">getTester</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns the tester.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setFor(org.apache.calcite.sql.SqlOperator,org.apache.calcite.sql.test.SqlOperatorFixture.VmName...)" class="member-name-link">setFor</a><wbr>(<a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator,
 <a href="SqlOperatorFixture.VmName.html" title="enum in org.apache.calcite.sql.test">SqlOperatorFixture.VmName</a>...&nbsp;unimplementedVmNames)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Declares that this test is for a given operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#withBrokenTestsEnabled(boolean)" class="member-name-link">withBrokenTestsEnabled</a><wbr>(boolean&nbsp;enableBrokenTests)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets <a href="#brokenTestsEnabled()"><code>brokenTestsEnabled()</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withCaseSensitive(boolean)" class="member-name-link">withCaseSensitive</a><wbr>(boolean&nbsp;sensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that matches identifiers by case-sensitive or
 case-insensitive.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withConformance(org.apache.calcite.sql.validate.SqlConformance)" class="member-name-link">withConformance</a><wbr>(<a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a>&nbsp;conformance)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that tests conformance to a particular SQL language
 version.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withConnectionFactory(java.util.function.UnaryOperator)" class="member-name-link">withConnectionFactory</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../../test/ConnectionFactory.html" title="interface in org.apache.calcite.test">ConnectionFactory</a>&gt;&nbsp;transform)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that gets connections from a given factory.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#withFactory(java.util.function.UnaryOperator)" class="member-name-link">withFactory</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="SqlTestFactory.html" title="class in org.apache.calcite.sql.test">SqlTestFactory</a>&gt;&nbsp;transform)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a copy of this fixture with a new test factory.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withLenientOperatorLookup(boolean)" class="member-name-link">withLenientOperatorLookup</a><wbr>(boolean&nbsp;lenient)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that does not fail validation if it encounters an
 unknown function.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withLex(org.apache.calcite.config.Lex)" class="member-name-link">withLex</a><wbr>(<a href="../../config/Lex.html" title="enum in org.apache.calcite.config">Lex</a>&nbsp;lex)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that follows a given lexical policy.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withLibrary(org.apache.calcite.sql.fun.SqlLibrary)" class="member-name-link">withLibrary</a><wbr>(<a href="../fun/SqlLibrary.html" title="enum in org.apache.calcite.sql.fun">SqlLibrary</a>&nbsp;library)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withOperatorTable(org.apache.calcite.sql.SqlOperatorTable)" class="member-name-link">withOperatorTable</a><wbr>(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;operatorTable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that uses a given operator table.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withParserConfig(java.util.function.UnaryOperator)" class="member-name-link">withParserConfig</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a>&gt;&nbsp;transform)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Creates a copy of this fixture with a new parser configuration.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withQuotedCasing(org.apache.calcite.avatica.util.Casing)" class="member-name-link">withQuotedCasing</a><wbr>(org.apache.calcite.avatica.util.Casing&nbsp;casing)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that applies a given casing policy to quoted
 identifiers.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withQuoting(org.apache.calcite.avatica.util.Quoting)" class="member-name-link">withQuoting</a><wbr>(org.apache.calcite.avatica.util.Quoting&nbsp;quoting)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that tests a given SQL quoting style.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#withTester(java.util.function.UnaryOperator)" class="member-name-link">withTester</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="SqlTester.html" title="interface in org.apache.calcite.sql.test">SqlTester</a>&gt;&nbsp;transform)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a copy of this fixture with a new tester.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withUnquotedCasing(org.apache.calcite.avatica.util.Casing)" class="member-name-link">withUnquotedCasing</a><wbr>(org.apache.calcite.avatica.util.Casing&nbsp;casing)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture that applies a given casing policy to unquoted
 identifiers.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#withValidatorConfig(java.util.function.UnaryOperator)" class="member-name-link">withValidatorConfig</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../validate/SqlValidator.Config.html" title="interface in org.apache.calcite.sql.validate">SqlValidator.Config</a>&gt;&nbsp;transform)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Returns a fixture with a given validator configuration.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.AutoCloseable">Methods inherited from interface&nbsp;java.lang.<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AutoCloseable.html#close()" title="class or interface in java.lang" class="external-link">close</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="INVALID_CHAR_MESSAGE">
<h3>INVALID_CHAR_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">INVALID_CHAR_MESSAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="OUT_OF_RANGE_MESSAGE">
<h3>OUT_OF_RANGE_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">OUT_OF_RANGE_MESSAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="DIVISION_BY_ZERO_MESSAGE">
<h3>DIVISION_BY_ZERO_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">DIVISION_BY_ZERO_MESSAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="STRING_TRUNC_MESSAGE">
<h3>STRING_TRUNC_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">STRING_TRUNC_MESSAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="BAD_DATETIME_MESSAGE">
<h3>BAD_DATETIME_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">BAD_DATETIME_MESSAGE</span></div>
</section>
</li>
<li>
<section class="detail" id="INVALID_EXTRACT_UNIT_CONVERTLET_ERROR">
<h3>INVALID_EXTRACT_UNIT_CONVERTLET_ERROR</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">INVALID_EXTRACT_UNIT_CONVERTLET_ERROR</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.calcite.sql.test.SqlOperatorFixture.INVALID_EXTRACT_UNIT_CONVERTLET_ERROR">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="INVALID_EXTRACT_UNIT_VALIDATION_ERROR">
<h3>INVALID_EXTRACT_UNIT_VALIDATION_ERROR</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">INVALID_EXTRACT_UNIT_VALIDATION_ERROR</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.calcite.sql.test.SqlOperatorFixture.INVALID_EXTRACT_UNIT_VALIDATION_ERROR">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="LITERAL_OUT_OF_RANGE_MESSAGE">
<h3>LITERAL_OUT_OF_RANGE_MESSAGE</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">LITERAL_OUT_OF_RANGE_MESSAGE</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.calcite.sql.test.SqlOperatorFixture.LITERAL_OUT_OF_RANGE_MESSAGE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="INVALID_ARGUMENTS_NUMBER">
<h3>INVALID_ARGUMENTS_NUMBER</h3>
<div class="member-signature"><span class="modifiers">static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">INVALID_ARGUMENTS_NUMBER</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.calcite.sql.test.SqlOperatorFixture.INVALID_ARGUMENTS_NUMBER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getFactory()">
<h3>getFactory</h3>
<div class="member-signature"><span class="return-type"><a href="SqlTestFactory.html" title="class in org.apache.calcite.sql.test">SqlTestFactory</a></span>&nbsp;<span class="element-name">getFactory</span>()</div>
<div class="block">Returns the test factory.</div>
</section>
</li>
<li>
<section class="detail" id="withFactory(java.util.function.UnaryOperator)">
<h3>withFactory</h3>
<div class="member-signature"><span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withFactory</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="SqlTestFactory.html" title="class in org.apache.calcite.sql.test">SqlTestFactory</a>&gt;&nbsp;transform)</span></div>
<div class="block">Creates a copy of this fixture with a new test factory.</div>
</section>
</li>
<li>
<section class="detail" id="getTester()">
<h3>getTester</h3>
<div class="member-signature"><span class="return-type"><a href="SqlTester.html" title="interface in org.apache.calcite.sql.test">SqlTester</a></span>&nbsp;<span class="element-name">getTester</span>()</div>
<div class="block">Returns the tester.</div>
</section>
</li>
<li>
<section class="detail" id="withTester(java.util.function.UnaryOperator)">
<h3>withTester</h3>
<div class="member-signature"><span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withTester</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="SqlTester.html" title="interface in org.apache.calcite.sql.test">SqlTester</a>&gt;&nbsp;transform)</span></div>
<div class="block">Creates a copy of this fixture with a new tester.</div>
</section>
</li>
<li>
<section class="detail" id="withParserConfig(java.util.function.UnaryOperator)">
<h3>withParserConfig</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withParserConfig</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a>&gt;&nbsp;transform)</span></div>
<div class="block">Creates a copy of this fixture with a new parser configuration.</div>
</section>
</li>
<li>
<section class="detail" id="withQuoting(org.apache.calcite.avatica.util.Quoting)">
<h3>withQuoting</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withQuoting</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.Quoting&nbsp;quoting)</span></div>
<div class="block">Returns a fixture that tests a given SQL quoting style.</div>
</section>
</li>
<li>
<section class="detail" id="withQuotedCasing(org.apache.calcite.avatica.util.Casing)">
<h3>withQuotedCasing</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withQuotedCasing</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.Casing&nbsp;casing)</span></div>
<div class="block">Returns a fixture that applies a given casing policy to quoted
 identifiers.</div>
</section>
</li>
<li>
<section class="detail" id="withUnquotedCasing(org.apache.calcite.avatica.util.Casing)">
<h3>withUnquotedCasing</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withUnquotedCasing</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.Casing&nbsp;casing)</span></div>
<div class="block">Returns a fixture that applies a given casing policy to unquoted
 identifiers.</div>
</section>
</li>
<li>
<section class="detail" id="withCaseSensitive(boolean)">
<h3>withCaseSensitive</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withCaseSensitive</span><wbr><span class="parameters">(boolean&nbsp;sensitive)</span></div>
<div class="block">Returns a fixture that matches identifiers by case-sensitive or
 case-insensitive.</div>
</section>
</li>
<li>
<section class="detail" id="withLex(org.apache.calcite.config.Lex)">
<h3>withLex</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withLex</span><wbr><span class="parameters">(<a href="../../config/Lex.html" title="enum in org.apache.calcite.config">Lex</a>&nbsp;lex)</span></div>
<div class="block">Returns a fixture that follows a given lexical policy.</div>
</section>
</li>
<li>
<section class="detail" id="withConformance(org.apache.calcite.sql.validate.SqlConformance)">
<h3>withConformance</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withConformance</span><wbr><span class="parameters">(<a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a>&nbsp;conformance)</span></div>
<div class="block">Returns a fixture that tests conformance to a particular SQL language
 version.</div>
</section>
</li>
<li>
<section class="detail" id="conformance()">
<h3>conformance</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a></span>&nbsp;<span class="element-name">conformance</span>()</div>
<div class="block">Returns the conformance.</div>
</section>
</li>
<li>
<section class="detail" id="withValidatorConfig(java.util.function.UnaryOperator)">
<h3>withValidatorConfig</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withValidatorConfig</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../validate/SqlValidator.Config.html" title="interface in org.apache.calcite.sql.validate">SqlValidator.Config</a>&gt;&nbsp;transform)</span></div>
<div class="block">Returns a fixture with a given validator configuration.</div>
</section>
</li>
<li>
<section class="detail" id="enableTypeCoercion(boolean)">
<h3>enableTypeCoercion</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">enableTypeCoercion</span><wbr><span class="parameters">(boolean&nbsp;enabled)</span></div>
<div class="block">Returns a fixture that tests with implicit type coercion on/off.</div>
</section>
</li>
<li>
<section class="detail" id="withLenientOperatorLookup(boolean)">
<h3>withLenientOperatorLookup</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withLenientOperatorLookup</span><wbr><span class="parameters">(boolean&nbsp;lenient)</span></div>
<div class="block">Returns a fixture that does not fail validation if it encounters an
 unknown function.</div>
</section>
</li>
<li>
<section class="detail" id="withConnectionFactory(java.util.function.UnaryOperator)">
<h3>withConnectionFactory</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withConnectionFactory</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;<a href="../../test/ConnectionFactory.html" title="interface in org.apache.calcite.test">ConnectionFactory</a>&gt;&nbsp;transform)</span></div>
<div class="block">Returns a fixture that gets connections from a given factory.</div>
</section>
</li>
<li>
<section class="detail" id="withOperatorTable(org.apache.calcite.sql.SqlOperatorTable)">
<h3>withOperatorTable</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withOperatorTable</span><wbr><span class="parameters">(<a href="../SqlOperatorTable.html" title="interface in org.apache.calcite.sql">SqlOperatorTable</a>&nbsp;operatorTable)</span></div>
<div class="block">Returns a fixture that uses a given operator table.</div>
</section>
</li>
<li>
<section class="detail" id="brokenTestsEnabled()">
<h3>brokenTestsEnabled</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">brokenTestsEnabled</span>()</div>
<div class="block">Returns whether to run tests that are considered 'broken'.
 Returns false by default, but it is useful to temporarily enable the
 'broken' tests to see whether they are still broken.</div>
</section>
</li>
<li>
<section class="detail" id="withBrokenTestsEnabled(boolean)">
<h3>withBrokenTestsEnabled</h3>
<div class="member-signature"><span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withBrokenTestsEnabled</span><wbr><span class="parameters">(boolean&nbsp;enableBrokenTests)</span></div>
<div class="block">Sets <a href="#brokenTestsEnabled()"><code>brokenTestsEnabled()</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="checkScalar(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>checkScalar</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkScalar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkScalar(java.lang.String,java.lang.Object,java.lang.String)">
<h3>checkScalar</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkScalar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resultType)</span></div>
<div class="block">Tests that a scalar SQL expression returns the expected result and the
 expected type. For example,

 <blockquote>
 <pre>checkScalar("1.1 + 2.9", "4.0", "DECIMAL(2, 1) NOT NULL");</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>result</code> - Expected result</dd>
<dd><code>resultType</code> - Expected result type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkScalarExact(java.lang.String,int)">
<h3>checkScalarExact</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkScalarExact</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 int&nbsp;result)</span></div>
<div class="block">Tests that a scalar SQL expression returns the expected exact numeric
 result as an integer. For example,

 <blockquote>
 <pre>checkScalarExact("1 + 2", 3);</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>result</code> - Expected result</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkScalarExact(java.lang.String,java.lang.String,java.lang.String)">
<h3>checkScalarExact</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkScalarExact</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;result)</span></div>
<div class="block">Tests that a scalar SQL expression returns the expected exact numeric
 result. For example,

 <blockquote>
 <pre>checkScalarExact("1 + 2", "3");</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>expectedType</code> - Type we expect the result to have, including
                     nullability, precision and scale, for example
                     <code>DECIMAL(2, 1) NOT NULL</code>.</dd>
<dd><code>result</code> - Expected result</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkScalarExact(java.lang.String,java.lang.String,org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>checkScalarExact</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkScalarExact</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkScalarApprox(java.lang.String,java.lang.String,java.lang.Object)">
<h3>checkScalarApprox</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkScalarApprox</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</span></div>
<div class="block">Tests that a scalar SQL expression returns expected approximate numeric
 result. For example,

 <blockquote>
 <pre>checkScalarApprox("1.0 + 2.1", "3.1");</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>expectedType</code> - Type we expect the result to have, including
                       nullability, precision and scale, for example
                       <code>DECIMAL(2, 1) NOT NULL</code>.</dd>
<dd><code>result</code> - Expected result, or a matcher</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../../test/Matchers.html#within(T,double)"><code>Matchers.within(Number, double)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkBoolean(java.lang.String,java.lang.Boolean)">
<h3>checkBoolean</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkBoolean</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;result)</span></div>
<div class="block">Tests that a scalar SQL expression returns the expected boolean result.
 For example,

 <blockquote>
 <pre>checkScalarExact("TRUE AND FALSE", Boolean.TRUE);</pre>
 </blockquote>

 <p>The expected result can be null:

 <blockquote>
 <pre>checkScalarExact("NOT UNKNOWN", null);</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>result</code> - Expected result (null signifies NULL).</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkString(java.lang.String,java.lang.String,java.lang.String)">
<h3>checkString</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;result,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;resultType)</span></div>
<div class="block">Tests that a scalar SQL expression returns the expected string result.
 For example,

 <blockquote>
 <pre>checkScalarExact("'ab' || 'c'", "abc");</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>result</code> - Expected result</dd>
<dd><code>resultType</code> - Expected result type</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkNull(java.lang.String)">
<h3>checkNull</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkNull</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression)</span></div>
<div class="block">Tests that a SQL expression returns the SQL NULL value. For example,

 <blockquote>
 <pre>checkNull("CHAR_LENGTH(CAST(NULL AS VARCHAR(3))");</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkType(java.lang.String,java.lang.String)">
<h3>checkType</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</span></div>
<div class="block">Tests that a SQL expression has a given type. For example,

 <blockquote>
 <code>checkType("SUBSTR('hello' FROM 1 FOR 3)",
 "VARCHAR(3) NOT NULL");</code>
 </blockquote>

 <p>This method checks length/precision, scale, and whether the type allows
 NULL values, so is more precise than the type-checking done by methods
 such as <a href="#checkScalarExact(java.lang.String,int)"><code>checkScalarExact(java.lang.String, int)</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - Scalar expression</dd>
<dd><code>type</code> - Type string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkAggType(java.lang.String,java.lang.String)">
<h3>checkAggType</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">checkAggType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</span></div>
<div class="block">Very similar to <a href="#checkType(java.lang.String,java.lang.String)"><code>checkType(java.lang.String, java.lang.String)</code></a>, but generates inside a SELECT
 with a non-empty GROUP BY. Aggregate functions may be nullable if executed
 in a SELECT with an empty GROUP BY.

 <p>Viz: <code>SELECT sum(1) FROM emp</code> has type "INTEGER",
 <code>SELECT sum(1) FROM emp GROUP BY deptno</code> has type "INTEGER NOT NULL",</div>
</section>
</li>
<li>
<section class="detail" id="checkColumnType(java.lang.String,java.lang.String)">
<h3>checkColumnType</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkColumnType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sql,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type)</span></div>
<div class="block">Checks that a query returns one column of an expected type. For example,
 <code>checkType("VALUES (1 + 2)", "INTEGER NOT NULL")</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sql</code> - Query expression</dd>
<dd><code>type</code> - Type string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="check(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,java.lang.Object)">
<h3>check</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">check</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</span></div>
<div class="block">Tests that a SQL query returns a single column with the given type. For
 example,

 <blockquote>
 <pre>check("VALUES (1 + 2)", "3", SqlTypeName.Integer);</pre>
 </blockquote>

 <p>If <code>result</code> is null, the expression must yield the SQL NULL
 value. If <code>result</code> is a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/regex/Pattern.html" title="class or interface in java.util.regex" class="external-link"><code>Pattern</code></a>, the
 result must match that pattern.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - SQL query</dd>
<dd><code>typeChecker</code> - Checks whether the result is the expected type; must
                    not be null</dd>
<dd><code>result</code> - Expected result, or matcher</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="check(java.lang.String,java.lang.String,java.lang.Object)">
<h3>check</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">check</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;result)</span></div>
</section>
</li>
<li>
<section class="detail" id="check(java.lang.String,org.apache.calcite.sql.test.SqlTester.TypeChecker,org.apache.calcite.sql.test.SqlTester.ParameterChecker,org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>check</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">check</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;query,
 <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.TypeChecker</a>&nbsp;typeChecker,
 <a href="SqlTester.ParameterChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ParameterChecker</a>&nbsp;parameterChecker,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</span></div>
<div class="block">Tests that a SQL query returns a result of expected type and value.
 Checking of type and value are abstracted using <a href="SqlTester.TypeChecker.html" title="interface in org.apache.calcite.sql.test"><code>SqlTester.TypeChecker</code></a>
 and <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test"><code>SqlTester.ResultChecker</code></a> functors.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>query</code> - SQL query</dd>
<dd><code>typeChecker</code> - Checks whether the result is the expected type</dd>
<dd><code>parameterChecker</code> - Checks whether the parameters are of expected
                      types</dd>
<dd><code>resultChecker</code> - Checks whether the result has the expected value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setFor(org.apache.calcite.sql.SqlOperator,org.apache.calcite.sql.test.SqlOperatorFixture.VmName...)">
<h3>setFor</h3>
<div class="member-signature"><span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">setFor</span><wbr><span class="parameters">(<a href="../SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator,
 <a href="SqlOperatorFixture.VmName.html" title="enum in org.apache.calcite.sql.test">SqlOperatorFixture.VmName</a>...&nbsp;unimplementedVmNames)</span></div>
<div class="block">Declares that this test is for a given operator. So we can check that all
 operators are tested.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>operator</code> - Operator</dd>
<dd><code>unimplementedVmNames</code> - Names of virtual machines for which this</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkAgg(java.lang.String,java.lang.String[],org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>checkAgg</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkAgg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;checker)</span></div>
<div class="block">Checks that an aggregate expression returns the expected result.

 <p>For example, <code>checkAgg("AVG(DISTINCT x)", new String[] {"2", "3",
 null, "3" }, new Double(2.5), 0);</code></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expr</code> - Aggregate expression, e.g. <code>SUM(DISTINCT x)</code></dd>
<dd><code>inputValues</code> - Array of input values, e.g. <code>["1", null,
                    "2"]</code>.</dd>
<dd><code>checker</code> - Result checker</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkAggWithMultipleArgs(java.lang.String,java.lang.String[][],org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>checkAggWithMultipleArgs</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkAggWithMultipleArgs</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[][]&nbsp;inputValues,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</span></div>
<div class="block">Checks that an aggregate expression with multiple args returns the expected
 result.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expr</code> - Aggregate expression, e.g. <code>AGG_FUNC(x, x2, x3)</code></dd>
<dd><code>inputValues</code> - Nested array of input values, e.g. <code>[
                    ["1", null, "2"]
                    ["3", "4", null]
                    ]</code></dd>
<dd><code>resultChecker</code> - Checks whether the result has the expected value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkWinAgg(java.lang.String,java.lang.String[],java.lang.String,java.lang.String,org.apache.calcite.sql.test.SqlTester.ResultChecker)">
<h3>checkWinAgg</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkWinAgg</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;windowSpec,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type,
 <a href="SqlTester.ResultChecker.html" title="interface in org.apache.calcite.sql.test">SqlTester.ResultChecker</a>&nbsp;resultChecker)</span></div>
<div class="block">Checks that a windowed aggregate expression returns the expected result.

 <p>For example, <code>checkWinAgg("FIRST_VALUE(x)", new String[] {"2",
 "3", null, "3" }, "INTEGER NOT NULL", 2, 0d);</code></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expr</code> - Aggregate expression, e.g. <code>SUM(DISTINCT x)</code></dd>
<dd><code>inputValues</code> - Array of input values, e.g. <code>["1", null, "2"]</code></dd>
<dd><code>type</code> - Expected result type</dd>
<dd><code>resultChecker</code> - Checks whether the result has the expected value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkAggFails(java.lang.String,java.lang.String[],java.lang.String,boolean)">
<h3>checkAggFails</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkAggFails</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expr,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;inputValues,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</span></div>
<div class="block">Tests that an aggregate expression fails at run time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expr</code> - An aggregate expression</dd>
<dd><code>inputValues</code> - Array of input values</dd>
<dd><code>expectedError</code> - Pattern for expected error</dd>
<dd><code>runtime</code> - If true, must fail at runtime; if false, must fail at
                      validate time</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String,boolean)">
<h3>checkFails</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkFails</span><wbr><span class="parameters">(<a href="../parser/StringAndPos.html" title="class in org.apache.calcite.sql.parser">StringAndPos</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</span></div>
<div class="block">Tests that a scalar SQL expression fails at run time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expression</code> - SQL scalar expression</dd>
<dd><code>expectedError</code> - Pattern for expected error. If !runtime, must
                      include an error location.</dd>
<dd><code>runtime</code> - If true, must fail at runtime; if false, must fail at
                      validate time</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkFails(java.lang.String,java.lang.String,boolean)">
<h3>checkFails</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkFails</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expression,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</span></div>
<div class="block">As <a href="#checkFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String,boolean)"><code>checkFails(StringAndPos, String, boolean)</code></a>, but with a string
 that contains carets.</div>
</section>
</li>
<li>
<section class="detail" id="checkQueryFails(org.apache.calcite.sql.parser.StringAndPos,java.lang.String)">
<h3>checkQueryFails</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkQueryFails</span><wbr><span class="parameters">(<a href="../parser/StringAndPos.html" title="class in org.apache.calcite.sql.parser">StringAndPos</a>&nbsp;sap,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError)</span></div>
<div class="block">Tests that a SQL query fails at prepare time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sap</code> - SQL query and error position</dd>
<dd><code>expectedError</code> - Pattern for expected error. Must
                      include an error location.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="checkQuery(java.lang.String)">
<h3>checkQuery</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">checkQuery</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sql)</span></div>
<div class="block">Tests that a SQL query succeeds at prepare time.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sql</code> - SQL query</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="withLibrary(org.apache.calcite.sql.fun.SqlLibrary)">
<h3>withLibrary</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">withLibrary</span><wbr><span class="parameters">(<a href="../fun/SqlLibrary.html" title="enum in org.apache.calcite.sql.fun">SqlLibrary</a>&nbsp;library)</span></div>
</section>
</li>
<li>
<section class="detail" id="forOracle(org.apache.calcite.sql.validate.SqlConformance)">
<h3>forOracle</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="SqlOperatorFixture.html" title="interface in org.apache.calcite.sql.test">SqlOperatorFixture</a></span>&nbsp;<span class="element-name">forOracle</span><wbr><span class="parameters">(<a href="../validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a>&nbsp;conformance)</span></div>
</section>
</li>
<li>
<section class="detail" id="getCastString(java.lang.String,java.lang.String,boolean)">
<h3>getCastString</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getCastString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 boolean&nbsp;errorLoc)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastToApproxOkay(java.lang.String,java.lang.String,java.lang.Object)">
<h3>checkCastToApproxOkay</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastToApproxOkay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;expected)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastToStringOkay(java.lang.String,java.lang.String,java.lang.String)">
<h3>checkCastToStringOkay</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastToStringOkay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastToScalarOkay(java.lang.String,java.lang.String,java.lang.String)">
<h3>checkCastToScalarOkay</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastToScalarOkay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastToScalarOkay(java.lang.String,java.lang.String)">
<h3>checkCastToScalarOkay</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastToScalarOkay</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastFails(java.lang.String,java.lang.String,java.lang.String,boolean)">
<h3>checkCastFails</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastFails</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;targetType,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expectedError,
 boolean&nbsp;runtime)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkCastToString(java.lang.String,java.lang.String,java.lang.String)">
<h3>checkCastToString</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkCastToString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;type,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;expected)</span></div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
