<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SqlDialect (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, class: SqlDialect">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.sql</a></div>
<h1 title="Class SqlDialect" class="title">Class SqlDialect</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.sql.SqlDialect</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="dialect/AccessSqlDialect.html" title="class in org.apache.calcite.sql.dialect">AccessSqlDialect</a></code>, <code><a href="dialect/AnsiSqlDialect.html" title="class in org.apache.calcite.sql.dialect">AnsiSqlDialect</a></code>, <code><a href="dialect/BigQuerySqlDialect.html" title="class in org.apache.calcite.sql.dialect">BigQuerySqlDialect</a></code>, <code><a href="dialect/CalciteSqlDialect.html" title="class in org.apache.calcite.sql.dialect">CalciteSqlDialect</a></code>, <code><a href="dialect/ClickHouseSqlDialect.html" title="class in org.apache.calcite.sql.dialect">ClickHouseSqlDialect</a></code>, <code><a href="dialect/Db2SqlDialect.html" title="class in org.apache.calcite.sql.dialect">Db2SqlDialect</a></code>, <code><a href="dialect/DerbySqlDialect.html" title="class in org.apache.calcite.sql.dialect">DerbySqlDialect</a></code>, <code><a href="dialect/ExasolSqlDialect.html" title="class in org.apache.calcite.sql.dialect">ExasolSqlDialect</a></code>, <code><a href="dialect/FirebirdSqlDialect.html" title="class in org.apache.calcite.sql.dialect">FirebirdSqlDialect</a></code>, <code><a href="dialect/FireboltSqlDialect.html" title="class in org.apache.calcite.sql.dialect">FireboltSqlDialect</a></code>, <code><a href="dialect/H2SqlDialect.html" title="class in org.apache.calcite.sql.dialect">H2SqlDialect</a></code>, <code><a href="dialect/HiveSqlDialect.html" title="class in org.apache.calcite.sql.dialect">HiveSqlDialect</a></code>, <code><a href="dialect/HsqldbSqlDialect.html" title="class in org.apache.calcite.sql.dialect">HsqldbSqlDialect</a></code>, <code><a href="dialect/InfobrightSqlDialect.html" title="class in org.apache.calcite.sql.dialect">InfobrightSqlDialect</a></code>, <code><a href="dialect/InformixSqlDialect.html" title="class in org.apache.calcite.sql.dialect">InformixSqlDialect</a></code>, <code><a href="dialect/IngresSqlDialect.html" title="class in org.apache.calcite.sql.dialect">IngresSqlDialect</a></code>, <code><a href="dialect/InterbaseSqlDialect.html" title="class in org.apache.calcite.sql.dialect">InterbaseSqlDialect</a></code>, <code><a href="dialect/JethroDataSqlDialect.html" title="class in org.apache.calcite.sql.dialect">JethroDataSqlDialect</a></code>, <code><a href="dialect/LucidDbSqlDialect.html" title="class in org.apache.calcite.sql.dialect">LucidDbSqlDialect</a></code>, <code><a href="dialect/MssqlSqlDialect.html" title="class in org.apache.calcite.sql.dialect">MssqlSqlDialect</a></code>, <code><a href="dialect/MysqlSqlDialect.html" title="class in org.apache.calcite.sql.dialect">MysqlSqlDialect</a></code>, <code><a href="dialect/NeoviewSqlDialect.html" title="class in org.apache.calcite.sql.dialect">NeoviewSqlDialect</a></code>, <code><a href="dialect/NetezzaSqlDialect.html" title="class in org.apache.calcite.sql.dialect">NetezzaSqlDialect</a></code>, <code><a href="dialect/OracleSqlDialect.html" title="class in org.apache.calcite.sql.dialect">OracleSqlDialect</a></code>, <code><a href="dialect/ParaccelSqlDialect.html" title="class in org.apache.calcite.sql.dialect">ParaccelSqlDialect</a></code>, <code><a href="dialect/PhoenixSqlDialect.html" title="class in org.apache.calcite.sql.dialect">PhoenixSqlDialect</a></code>, <code><a href="dialect/PostgresqlSqlDialect.html" title="class in org.apache.calcite.sql.dialect">PostgresqlSqlDialect</a></code>, <code><a href="dialect/PrestoSqlDialect.html" title="class in org.apache.calcite.sql.dialect">PrestoSqlDialect</a></code>, <code><a href="dialect/RedshiftSqlDialect.html" title="class in org.apache.calcite.sql.dialect">RedshiftSqlDialect</a></code>, <code><a href="dialect/SnowflakeSqlDialect.html" title="class in org.apache.calcite.sql.dialect">SnowflakeSqlDialect</a></code>, <code><a href="dialect/SparkSqlDialect.html" title="class in org.apache.calcite.sql.dialect">SparkSqlDialect</a></code>, <code><a href="dialect/SybaseSqlDialect.html" title="class in org.apache.calcite.sql.dialect">SybaseSqlDialect</a></code>, <code><a href="dialect/TeradataSqlDialect.html" title="class in org.apache.calcite.sql.dialect">TeradataSqlDialect</a></code>, <code><a href="dialect/VerticaSqlDialect.html" title="class in org.apache.calcite.sql.dialect">VerticaSqlDialect</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">SqlDialect</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block"><code>SqlDialect</code> encapsulates the differences between dialects of SQL.

 <p>It is used by classes such as <a href="SqlWriter.html" title="interface in org.apache.calcite.sql"><code>SqlWriter</code></a> and
 <a href="util/SqlBuilder.html" title="class in org.apache.calcite.sql.util"><code>SqlBuilder</code></a>.

 <p>To add a new <a href="SqlDialect.html" title="class in org.apache.calcite.sql"><code>SqlDialect</code></a> sub-class, extends this class to hold 2 public final
 static member:
 <ul>
   <li>DEFAULT_CONTEXT: a default <a href="SqlDialect.Context.html" title="interface in org.apache.calcite.sql"><code>SqlDialect.Context</code></a> instance, which can be used to customize
   or extending the dialect if the DEFAULT instance does not meet the requests</li>
   <li>DEFAULT: the default <a href="SqlDialect.html" title="class in org.apache.calcite.sql"><code>SqlDialect</code></a> instance with context properties defined with
   <code>DEFAULT_CONTEXT</code></li>
 </ul></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlDialect.CalendarPolicy.html" class="type-name-link" title="enum in org.apache.calcite.sql">SqlDialect.CalendarPolicy</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether this JDBC driver needs you to pass a Calendar object to methods
 such as <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/ResultSet.html#getTimestamp(int,java.util.Calendar)" title="class or interface in java.sql" class="external-link"><code>ResultSet.getTimestamp(int, java.util.Calendar)</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>static interface&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SqlDialect.Context.html" class="type-name-link" title="interface in org.apache.calcite.sql">SqlDialect.Context</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Information for creating a dialect.</div>
</div>
<div class="col-first even-row-color"><code>static enum&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SqlDialect.DatabaseProduct.html" class="type-name-link" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a></code></div>
<div class="col-last even-row-color">
<div class="block">Rough list of flavors of database.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SqlDialect.FakeUtil.html" class="type-name-link" title="class in org.apache.calcite.sql">SqlDialect.FakeUtil</a></code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></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>protected static final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#BUILT_IN_OPERATORS_LIST" class="member-name-link">BUILT_IN_OPERATORS_LIST</a></code></div>
<div class="col-last even-row-color">
<div class="block">Built-in scalar functions and operators common for every dialect.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="SqlDialect.Context.html" title="interface in org.apache.calcite.sql">SqlDialect.Context</a></code></div>
<div class="col-second odd-row-color"><code><a href="#EMPTY_CONTEXT" class="member-name-link">EMPTY_CONTEXT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Empty context.</div>
</div>
<div class="col-first even-row-color"><code>protected final @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#identifierEndQuoteString" class="member-name-link">identifierEndQuoteString</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#identifierEscapedQuote" class="member-name-link">identifierEscapedQuote</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#identifierQuoteString" class="member-name-link">identifierQuoteString</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#literalEndQuoteString" class="member-name-link">literalEndQuoteString</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#literalEscapedQuote" class="member-name-link">literalEscapedQuote</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#literalQuoteString" class="member-name-link">literalQuoteString</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected static final org.slf4j.Logger</code></div>
<div class="col-second even-row-color"><code><a href="#LOGGER" class="member-name-link">LOGGER</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a></code></div>
<div class="col-second odd-row-color"><code><a href="#nullCollation" class="member-name-link">nullCollation</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.sql.SqlDialect.Context)" class="member-name-link">SqlDialect</a><wbr>(<a href="SqlDialect.Context.html" title="interface in org.apache.calcite.sql">SqlDialect.Context</a>&nbsp;context)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a SqlDialect.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.sql.SqlDialect.DatabaseProduct,java.lang.String,java.lang.String)" class="member-name-link">SqlDialect</a><wbr>(<a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a>&nbsp;databaseProduct,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;databaseProductName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;identifierQuoteString)</code></div>
<div class="col-last odd-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.sql.SqlDialect.DatabaseProduct,java.lang.String,java.lang.String,org.apache.calcite.config.NullCollation)" class="member-name-link">SqlDialect</a><wbr>(<a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a>&nbsp;databaseProduct,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;databaseProductName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;identifierQuoteString,
 <a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a>&nbsp;nullCollation)</code></div>
<div class="col-last even-row-color">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#%3Cinit%3E(org.apache.calcite.sql.SqlDialect.Context)"><code>SqlDialect(Context)</code></a></div>
</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#allowsAs()" class="member-name-link">allowsAs</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#configureParser(org.apache.calcite.sql.parser.SqlParser.Config)" class="member-name-link">configureParser</a><wbr>(<a href="parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a>&nbsp;config)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Copies settings from this dialect into a parser configuration.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="parser/SqlParser.ConfigBuilder.html" title="class in org.apache.calcite.sql.parser">SqlParser.ConfigBuilder</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#configureParser(org.apache.calcite.sql.parser.SqlParser.ConfigBuilder)" class="member-name-link">configureParser</a><wbr>(<a href="parser/SqlParser.ConfigBuilder.html" title="class in org.apache.calcite.sql.parser">SqlParser.ConfigBuilder</a>&nbsp;configBuilder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#containsNonAscii(java.lang.String)" class="member-name-link">containsNonAscii</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether the string contains any characters outside the
 comfortable 7-bit ASCII range (32 through 127, plus linefeed (10) and
 carriage return (13)).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="SqlDialect.html" title="class in org.apache.calcite.sql">SqlDialect</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#create(java.sql.DatabaseMetaData)" class="member-name-link">create</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/DatabaseMetaData.html" title="class or interface in java.sql" class="external-link">DatabaseMetaData</a>&nbsp;databaseMetaData)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Replaced by <a href="SqlDialectFactory.html" title="interface in org.apache.calcite.sql"><code>SqlDialectFactory</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/RelFieldCollation.NullDirection.html" title="enum in org.apache.calcite.rel">RelFieldCollation.NullDirection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#defaultNullDirection(org.apache.calcite.rel.RelFieldCollation.Direction)" class="member-name-link">defaultNullDirection</a><wbr>(<a href="../rel/RelFieldCollation.Direction.html" title="enum in org.apache.calcite.rel">RelFieldCollation.Direction</a>&nbsp;direction)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether NULL values are sorted first or last, in this dialect,
 in an ORDER BY item of a given direction.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="JoinType.html" title="enum in org.apache.calcite.sql">JoinType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#emulateJoinTypeForCrossJoin()" class="member-name-link">emulateJoinTypeForCrossJoin</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>@Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#emulateNullDirection(org.apache.calcite.sql.SqlNode,boolean,boolean)" class="member-name-link">emulateNullDirection</a><wbr>(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 boolean&nbsp;nullsFirst,
 boolean&nbsp;desc)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the SqlNode for emulating the null direction for the given field
 or <code>null</code> if no emulation needs to be done.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#emulateNullDirectionWithIsNull(org.apache.calcite.sql.SqlNode,boolean,boolean)" class="member-name-link">emulateNullDirectionWithIsNull</a><wbr>(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 boolean&nbsp;nullsFirst,
 boolean&nbsp;desc)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="SqlDialect.CalendarPolicy.html" title="enum in org.apache.calcite.sql">SqlDialect.CalendarPolicy</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCalendarPolicy()" class="member-name-link">getCalendarPolicy</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>@Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCastSpec(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">getCastSpec</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns SqlNode for type in "cast(column as type)", which might be
 different between databases by type name, precision etc.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate">SqlConformance</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getConformance()" class="member-name-link">getConformance</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the <a href="validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate"><code>SqlConformance</code></a> that matches this dialect.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getDatabaseProduct()" class="member-name-link">getDatabaseProduct</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">To be removed without replacement</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNullCollation()" class="member-name-link">getNullCollation</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns how NULL values are sorted if an ORDER BY item does not contain
 NULLS ASCENDING or NULLS DESCENDING.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getProduct(java.lang.String,java.lang.String)" class="member-name-link">getProduct</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;productName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;productVersion)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.calcite.avatica.util.Casing</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getQuotedCasing()" class="member-name-link">getQuotedCasing</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns how quoted identifiers are stored.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected @Nullable org.apache.calcite.avatica.util.Quoting</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getQuoting()" class="member-name-link">getQuoting</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the quoting scheme, or null if the combination of
 <a href="#identifierQuoteString"><code>identifierQuoteString</code></a> and <a href="#identifierEndQuoteString"><code>identifierEndQuoteString</code></a>
 does not correspond to any known quoting scheme.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSingleRowTableName()" class="member-name-link">getSingleRowTableName</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the name of the system table that has precisely one row.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../rel/type/RelDataTypeSystem.html" title="interface in org.apache.calcite.rel.type">RelDataTypeSystem</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTypeSystem()" class="member-name-link">getTypeSystem</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the type system implementation for this dialect.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.calcite.avatica.util.Casing</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getUnquotedCasing()" class="member-name-link">getUnquotedCasing</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns how unquoted identifiers are stored.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#hasImplicitTableAlias()" class="member-name-link">hasImplicitTableAlias</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether a qualified table in the FROM clause has an implicit alias
 which consists of just the table name.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#identifierNeedsQuote(java.lang.String)" class="member-name-link">identifierNeedsQuote</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether to quote an identifier.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isCaseSensitive()" class="member-name-link">isCaseSensitive</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether matching of identifiers is case-sensitive.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteIdentifier(java.lang.String)" class="member-name-link">quoteIdentifier</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Encloses an identifier in quotation marks appropriate for the current SQL
 dialect.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteIdentifier(java.lang.StringBuilder,java.lang.String)" class="member-name-link">quoteIdentifier</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Encloses an identifier in quotation marks appropriate for the current SQL
 dialect, writing the result to a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link"><code>StringBuilder</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteIdentifier(java.lang.StringBuilder,java.util.List)" class="member-name-link">quoteIdentifier</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;identifiers)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Quotes a multi-part identifier.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteStringLiteral(java.lang.String)" class="member-name-link">quoteStringLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a string into a string literal.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteStringLiteral(java.lang.StringBuilder,java.lang.String,java.lang.String)" class="member-name-link">quoteStringLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;charsetName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends a string literal to a buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteStringLiteralUnicode(java.lang.StringBuilder,java.lang.String)" class="member-name-link">quoteStringLiteralUnicode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a string into a unicode string literal.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#quoteTimestampLiteral(java.sql.Timestamp)" class="member-name-link">quoteTimestampLiteral</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;timestamp)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a timestamp to a SQL timestamp literal, e.g.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#requiresAliasForFromItems()" class="member-name-link">requiresAliasForFromItems</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Whether a sub-query in the FROM clause must have an alias.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#rewriteSingleValueExpr(org.apache.calcite.sql.SqlNode)" class="member-name-link">rewriteSingleValueExpr</a><wbr>(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;aggCall)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Rewrite SINGLE_VALUE into expression based on database variants
  E.g.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsAggregateFunction(org.apache.calcite.sql.SqlKind)" class="member-name-link">supportsAggregateFunction</a><wbr>(<a href="SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsAggregateFunctionFilter()" class="member-name-link">supportsAggregateFunctionFilter</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports the use of FILTER clauses for
 aggregate functions.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsAliasedValues()" class="member-name-link">supportsAliasedValues</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether the dialect supports VALUES in a sub-query with
 and an "AS t(column, ...)" values to define column names.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsApproxCountDistinct()" class="member-name-link">supportsApproxCountDistinct</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports APPROX_COUNT_DISTINCT functions.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsCharSet()" class="member-name-link">supportsCharSet</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether the dialect supports character set names as part of a
 data type, for instance <code>VARCHAR(30) CHARACTER SET `ISO-8859-1`</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsDataType(org.apache.calcite.rel.type.RelDataType)" class="member-name-link">supportsDataType</a><wbr>(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports a given type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsFunction(org.apache.calcite.sql.SqlOperator,org.apache.calcite.rel.type.RelDataType,java.util.List)" class="member-name-link">supportsFunction</a><wbr>(<a href="SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;&nbsp;paramTypes)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports a given function or operator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsGroupByLiteral()" class="member-name-link">supportsGroupByLiteral</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether the dialect supports GROUP BY literals.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsGroupByWithCube()" class="member-name-link">supportsGroupByWithCube</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports "WITH CUBE" in "GROUP BY" clause.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsGroupByWithRollup()" class="member-name-link">supportsGroupByWithRollup</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports "WITH ROLLUP" in the "GROUP BY"
 clause.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsImplicitTypeCoercion(org.apache.calcite.rex.RexCall)" class="member-name-link">supportsImplicitTypeCoercion</a><wbr>(<a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether the dialect supports implicit type coercion.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsJoinType(org.apache.calcite.rel.core.JoinRelType)" class="member-name-link">supportsJoinType</a><wbr>(<a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect support the specified type of join.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsNestedAggregations()" class="member-name-link">supportsNestedAggregations</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether the dialect supports nested aggregations, for instance
 <code>SELECT SUM(SUM(1)) </code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#supportsOffsetFetch()" class="member-name-link">supportsOffsetFetch</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">This method is no longer used.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#supportsWindowFunctions()" class="member-name-link">supportsWindowFunctions</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns whether this dialect supports window functions (OVER clause).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseCall(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlCall,int,int)" class="member-name-link">unparseCall</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseDateTimeLiteral(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlAbstractDateTimeLiteral,int,int)" class="member-name-link">unparseDateTimeLiteral</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlAbstractDateTimeLiteral.html" title="class in org.apache.calcite.sql">SqlAbstractDateTimeLiteral</a>&nbsp;literal,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unparseFetchUsingAnsi(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseFetchUsingAnsi</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unparses offset/fetch using ANSI standard "OFFSET offset ROWS FETCH NEXT
 fetch ROWS ONLY" syntax.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unparseFetchUsingLimit(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseFetchUsingLimit</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unparses offset/fetch using "LIMIT fetch OFFSET offset" syntax.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unparseLimit(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseLimit</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>protected static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unparseOffset(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseOffset</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseOffsetFetch(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseOffsetFetch</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts an offset and fetch into SQL.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseSqlDatetimeArithmetic(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlCall,org.apache.calcite.sql.SqlKind,int,int)" class="member-name-link">unparseSqlDatetimeArithmetic</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 <a href="SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;sqlKind,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseSqlIntervalLiteral(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlIntervalLiteral,int,int)" class="member-name-link">unparseSqlIntervalLiteral</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlIntervalLiteral.html" title="class in org.apache.calcite.sql">SqlIntervalLiteral</a>&nbsp;literal,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts an interval literal to a SQL string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseSqlIntervalQualifier(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlIntervalQualifier,org.apache.calcite.rel.type.RelDataTypeSystem)" class="member-name-link">unparseSqlIntervalQualifier</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlIntervalQualifier.html" title="class in org.apache.calcite.sql">SqlIntervalQualifier</a>&nbsp;qualifier,
 <a href="../rel/type/RelDataTypeSystem.html" title="interface in org.apache.calcite.rel.type">RelDataTypeSystem</a>&nbsp;typeSystem)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts an interval qualifier to a SQL string.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseTableScanHints(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNodeList,int,int)" class="member-name-link">unparseTableScanHints</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;hints,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts table scan hints.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unparseTopN(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)" class="member-name-link">unparseTopN</a><wbr>(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a fetch into a "SELECT TOP(fetch)".</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unquoteStringLiteral(java.lang.String)" class="member-name-link">unquoteStringLiteral</a><wbr>(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts a string literal back into a string.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="LOGGER">
<h3>LOGGER</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type">org.slf4j.Logger</span>&nbsp;<span class="element-name">LOGGER</span></div>
</section>
</li>
<li>
<section class="detail" id="EMPTY_CONTEXT">
<h3>EMPTY_CONTEXT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="SqlDialect.Context.html" title="interface in org.apache.calcite.sql">SqlDialect.Context</a></span>&nbsp;<span class="element-name">EMPTY_CONTEXT</span></div>
<div class="block">Empty context.</div>
</section>
</li>
<li>
<section class="detail" id="BUILT_IN_OPERATORS_LIST">
<h3>BUILT_IN_OPERATORS_LIST</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&gt;</span>&nbsp;<span class="element-name">BUILT_IN_OPERATORS_LIST</span></div>
<div class="block">Built-in scalar functions and operators common for every dialect.</div>
</section>
</li>
<li>
<section class="detail" id="identifierQuoteString">
<h3>identifierQuoteString</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">identifierQuoteString</span></div>
</section>
</li>
<li>
<section class="detail" id="identifierEndQuoteString">
<h3>identifierEndQuoteString</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">identifierEndQuoteString</span></div>
</section>
</li>
<li>
<section class="detail" id="identifierEscapedQuote">
<h3>identifierEscapedQuote</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">identifierEscapedQuote</span></div>
</section>
</li>
<li>
<section class="detail" id="literalQuoteString">
<h3>literalQuoteString</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">literalQuoteString</span></div>
</section>
</li>
<li>
<section class="detail" id="literalEndQuoteString">
<h3>literalEndQuoteString</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">literalEndQuoteString</span></div>
</section>
</li>
<li>
<section class="detail" id="literalEscapedQuote">
<h3>literalEscapedQuote</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">literalEscapedQuote</span></div>
</section>
</li>
<li>
<section class="detail" id="nullCollation">
<h3>nullCollation</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a></span>&nbsp;<span class="element-name">nullCollation</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.sql.SqlDialect.DatabaseProduct,java.lang.String,java.lang.String)">
<h3>SqlDialect</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlDialect</span><wbr><span class="parameters">(<a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a>&nbsp;databaseProduct,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;databaseProductName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;identifierQuoteString)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.sql.SqlDialect.DatabaseProduct,java.lang.String,java.lang.String,org.apache.calcite.config.NullCollation)">
<h3>SqlDialect</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlDialect</span><wbr><span class="parameters">(<a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a>&nbsp;databaseProduct,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;databaseProductName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;identifierQuoteString,
 <a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a>&nbsp;nullCollation)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="#%3Cinit%3E(org.apache.calcite.sql.SqlDialect.Context)"><code>SqlDialect(Context)</code></a></div>
</div>
<div class="block">Creates a SqlDialect.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>databaseProduct</code> - Database product; may be UNKNOWN, never null</dd>
<dd><code>databaseProductName</code> - Database product name from JDBC driver</dd>
<dd><code>identifierQuoteString</code> - String to quote identifiers. Null if quoting
                              is not supported. If "[", close quote is
                              deemed to be "]".</dd>
<dd><code>nullCollation</code> - Whether NULL values appear first or last</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.calcite.sql.SqlDialect.Context)">
<h3>SqlDialect</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">SqlDialect</span><wbr><span class="parameters">(<a href="SqlDialect.Context.html" title="interface in org.apache.calcite.sql">SqlDialect.Context</a>&nbsp;context)</span></div>
<div class="block">Creates a SqlDialect.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>context</code> - All the information necessary to create a dialect</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="create(java.sql.DatabaseMetaData)">
<h3>create</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlDialect.html" title="class in org.apache.calcite.sql">SqlDialect</a></span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/DatabaseMetaData.html" title="class or interface in java.sql" class="external-link">DatabaseMetaData</a>&nbsp;databaseMetaData)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Replaced by <a href="SqlDialectFactory.html" title="interface in org.apache.calcite.sql"><code>SqlDialectFactory</code></a></div>
</div>
<div class="block">Creates a <code>SqlDialect</code> from a DatabaseMetaData.

 <p>Does not maintain a reference to the DatabaseMetaData -- or, more
 importantly, to its <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Connection.html" title="class or interface in java.sql" class="external-link"><code>Connection</code></a> -- after this call has
 returned.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>databaseMetaData</code> - used to determine which dialect of SQL to generate</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProduct(java.lang.String,java.lang.String)">
<h3>getProduct</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a></span>&nbsp;<span class="element-name">getProduct</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;productName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;productVersion)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Converts a product name and version (per the JDBC driver) into a product
 enumeration.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>productName</code> - Product name</dd>
<dd><code>productVersion</code> - Product version</dd>
<dt>Returns:</dt>
<dd>database product</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTypeSystem()">
<h3>getTypeSystem</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/type/RelDataTypeSystem.html" title="interface in org.apache.calcite.rel.type">RelDataTypeSystem</a></span>&nbsp;<span class="element-name">getTypeSystem</span>()</div>
<div class="block">Returns the type system implementation for this dialect.</div>
</section>
</li>
<li>
<section class="detail" id="quoteIdentifier(java.lang.String)">
<h3>quoteIdentifier</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">quoteIdentifier</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Encloses an identifier in quotation marks appropriate for the current SQL
 dialect.

 <p>For example, <code>quoteIdentifier("emp")</code> yields a string
 containing <code>"emp"</code> in Oracle, and a string containing <code>
 [emp]</code> in Access.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>val</code> - Identifier to quote</dd>
<dt>Returns:</dt>
<dd>Quoted identifier</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="quoteIdentifier(java.lang.StringBuilder,java.lang.String)">
<h3>quoteIdentifier</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></span>&nbsp;<span class="element-name">quoteIdentifier</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Encloses an identifier in quotation marks appropriate for the current SQL
 dialect, writing the result to a <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link"><code>StringBuilder</code></a>.

 <p>For example, <code>quoteIdentifier("emp")</code> yields a string
 containing <code>"emp"</code> in Oracle, and a string containing <code>
 [emp]</code> in Access.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buf</code> - Buffer</dd>
<dd><code>val</code> - Identifier to quote</dd>
<dt>Returns:</dt>
<dd>The buffer</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="quoteIdentifier(java.lang.StringBuilder,java.util.List)">
<h3>quoteIdentifier</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></span>&nbsp;<span class="element-name">quoteIdentifier</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;identifiers)</span></div>
<div class="block">Quotes a multi-part identifier.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buf</code> - Buffer</dd>
<dd><code>identifiers</code> - List of parts of the identifier to quote</dd>
<dt>Returns:</dt>
<dd>The buffer</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="identifierNeedsQuote(java.lang.String)">
<h3>identifierNeedsQuote</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">identifierNeedsQuote</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Returns whether to quote an identifier.
 By default, all identifiers are quoted.</div>
</section>
</li>
<li>
<section class="detail" id="quoteStringLiteral(java.lang.String)">
<h3>quoteStringLiteral</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">quoteStringLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Converts a string into a string literal.

 <p>For example, <code>"can't run"</code> becomes <code>"'can''t run'"</code>.</div>
</section>
</li>
<li>
<section class="detail" id="quoteStringLiteral(java.lang.StringBuilder,java.lang.String,java.lang.String)">
<h3>quoteStringLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">quoteStringLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;charsetName,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Appends a string literal to a buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buf</code> - Buffer</dd>
<dd><code>charsetName</code> - Character set name, e.g. "utf16", or null</dd>
<dd><code>val</code> - String value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unparseCall(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlCall,int,int)">
<h3>unparseCall</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseCall</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</span></div>
</section>
</li>
<li>
<section class="detail" id="unparseDateTimeLiteral(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlAbstractDateTimeLiteral,int,int)">
<h3>unparseDateTimeLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseDateTimeLiteral</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlAbstractDateTimeLiteral.html" title="class in org.apache.calcite.sql">SqlAbstractDateTimeLiteral</a>&nbsp;literal,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</span></div>
</section>
</li>
<li>
<section class="detail" id="unparseSqlDatetimeArithmetic(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlCall,org.apache.calcite.sql.SqlKind,int,int)">
<h3>unparseSqlDatetimeArithmetic</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseSqlDatetimeArithmetic</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call,
 <a href="SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;sqlKind,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</span></div>
</section>
</li>
<li>
<section class="detail" id="unparseSqlIntervalQualifier(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlIntervalQualifier,org.apache.calcite.rel.type.RelDataTypeSystem)">
<h3>unparseSqlIntervalQualifier</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseSqlIntervalQualifier</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlIntervalQualifier.html" title="class in org.apache.calcite.sql">SqlIntervalQualifier</a>&nbsp;qualifier,
 <a href="../rel/type/RelDataTypeSystem.html" title="interface in org.apache.calcite.rel.type">RelDataTypeSystem</a>&nbsp;typeSystem)</span></div>
<div class="block">Converts an interval qualifier to a SQL string. The default implementation
 returns strings such as
 <code>INTERVAL '1 2:3:4' DAY(4) TO SECOND(4)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="unparseSqlIntervalLiteral(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlIntervalLiteral,int,int)">
<h3>unparseSqlIntervalLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseSqlIntervalLiteral</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlIntervalLiteral.html" title="class in org.apache.calcite.sql">SqlIntervalLiteral</a>&nbsp;literal,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</span></div>
<div class="block">Converts an interval literal to a SQL string. The default implementation
 returns strings such as
 <code>INTERVAL '1 2:3:4' DAY(4) TO SECOND(4)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="unparseTableScanHints(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNodeList,int,int)">
<h3>unparseTableScanHints</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseTableScanHints</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 <a href="SqlNodeList.html" title="class in org.apache.calcite.sql">SqlNodeList</a>&nbsp;hints,
 int&nbsp;leftPrec,
 int&nbsp;rightPrec)</span></div>
<div class="block">Converts table scan hints. The default implementation suppresses all hints.</div>
</section>
</li>
<li>
<section class="detail" id="containsNonAscii(java.lang.String)">
<h3>containsNonAscii</h3>
<div class="member-signature"><span class="modifiers">protected static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">containsNonAscii</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">Returns whether the string contains any characters outside the
 comfortable 7-bit ASCII range (32 through 127, plus linefeed (10) and
 carriage return (13)).

 <p>Such characters can be used unquoted in SQL character literals.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>s</code> - String</dd>
<dt>Returns:</dt>
<dd>Whether string contains any non-7-bit-ASCII characters</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="quoteStringLiteralUnicode(java.lang.StringBuilder,java.lang.String)">
<h3>quoteStringLiteralUnicode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">quoteStringLiteralUnicode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;buf,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Converts a string into a unicode string literal. For example,
 <code>can't{tab}run\</code> becomes <code>u'can''t\0009run\\'</code>.</div>
</section>
</li>
<li>
<section class="detail" id="unquoteStringLiteral(java.lang.String)">
<h3>unquoteStringLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">unquoteStringLiteral</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;val)</span></div>
<div class="block">Converts a string literal back into a string. For example, <code>'can''t
 run'</code> becomes <code>can't run</code>.</div>
</section>
</li>
<li>
<section class="detail" id="allowsAs()">
<h3>allowsAs</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">allowsAs</span>()</div>
</section>
</li>
<li>
<section class="detail" id="requiresAliasForFromItems()">
<h3>requiresAliasForFromItems</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">requiresAliasForFromItems</span>()</div>
<div class="block">Whether a sub-query in the FROM clause must have an alias.

 <p>For example, in PostgreSQL, this query is legal:

 <blockquote><code>SELECT * FROM (SELECT * FROM Emp) As e</code></blockquote>

 <p>but remove the alias <code>e</code> and it is not:

 <blockquote><code>SELECT * FROM (SELECT * FROM Emp)</code></blockquote>

 <p>In Oracle, both queries are legal.</div>
</section>
</li>
<li>
<section class="detail" id="hasImplicitTableAlias()">
<h3>hasImplicitTableAlias</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasImplicitTableAlias</span>()</div>
<div class="block">Returns whether a qualified table in the FROM clause has an implicit alias
 which consists of just the table name.

 <p>For example, in <a href="SqlDialect.DatabaseProduct.html#ORACLE"><code>SqlDialect.DatabaseProduct.ORACLE</code></a>

 <blockquote>SELECT * FROM sales.emp</blockquote>

 <p>is equivalent to

 <blockquote>SELECT * FROM sales.emp AS emp</blockquote>

 <p>and therefore

 <blockquote>SELECT emp.empno FROM sales.emp</blockquote>

 <p>is valid. But <a href="SqlDialect.DatabaseProduct.html#DB2"><code>SqlDialect.DatabaseProduct.DB2</code></a> does not have an implicit
 alias, so the previous query it not valid; you need to write

 <blockquote>SELECT sales.emp.empno FROM sales.emp</blockquote>

 <p>Returns true for all databases except DB2.</div>
</section>
</li>
<li>
<section class="detail" id="quoteTimestampLiteral(java.sql.Timestamp)">
<h3>quoteTimestampLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">quoteTimestampLiteral</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/Timestamp.html" title="class or interface in java.sql" class="external-link">Timestamp</a>&nbsp;timestamp)</span></div>
<div class="block">Converts a timestamp to a SQL timestamp literal, e.g.
 <code>TIMESTAMP '2009-12-17 12:34:56'</code>.

 <p>Timestamp values do not have a time zone. We therefore interpret them
 as the number of milliseconds after the UTC epoch, and the formatted
 value is that time in UTC.

 <p>In particular,

 <blockquote><code>quoteTimestampLiteral(new Timestamp(0));</code>
 </blockquote>

 <p>returns <code>TIMESTAMP '1970-01-01 00:00:00'</code>, regardless of the JVM's
 time zone.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timestamp</code> - Timestamp</dd>
<dt>Returns:</dt>
<dd>SQL timestamp literal</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDatabaseProduct()">
<h3>getDatabaseProduct</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="SqlDialect.DatabaseProduct.html" title="enum in org.apache.calcite.sql">SqlDialect.DatabaseProduct</a></span>&nbsp;<span class="element-name">getDatabaseProduct</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">To be removed without replacement</div>
</div>
<div class="block">Returns the database this dialect belongs to,
 <a href="SqlDialect.DatabaseProduct.html#UNKNOWN"><code>SqlDialect.DatabaseProduct.UNKNOWN</code></a> if not known, never null.

 <p>Please be judicious in how you use this method. If you wish to determine
 whether a dialect has a particular capability or behavior, it is usually
 better to add a method to SqlDialect and override that method in particular
 sub-classes of SqlDialect.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Database product</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="supportsCharSet()">
<h3>supportsCharSet</h3>
<div class="member-signature"><span class="annotations">@Pure
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsCharSet</span>()</div>
<div class="block">Returns whether the dialect supports character set names as part of a
 data type, for instance <code>VARCHAR(30) CHARACTER SET `ISO-8859-1`</code>.</div>
</section>
</li>
<li>
<section class="detail" id="supportsGroupByLiteral()">
<h3>supportsGroupByLiteral</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsGroupByLiteral</span>()</div>
<div class="block">Returns whether the dialect supports GROUP BY literals.

 <p>For instance, in <a href="SqlDialect.DatabaseProduct.html#REDSHIFT"><code>SqlDialect.DatabaseProduct.REDSHIFT</code></a>, the following queries are illegal.</p>
 <pre><code>
 select avg(salary)
 from emp
 group by true
 </code></pre>

  <pre><code>
 select avg(salary)
 from emp
 group by 'a', DATE '2022-01-01'
 </code></pre></div>
</section>
</li>
<li>
<section class="detail" id="supportsAggregateFunction(org.apache.calcite.sql.SqlKind)">
<h3>supportsAggregateFunction</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsAggregateFunction</span><wbr><span class="parameters">(<a href="SqlKind.html" title="enum in org.apache.calcite.sql">SqlKind</a>&nbsp;kind)</span></div>
</section>
</li>
<li>
<section class="detail" id="supportsApproxCountDistinct()">
<h3>supportsApproxCountDistinct</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsApproxCountDistinct</span>()</div>
<div class="block">Returns whether this dialect supports APPROX_COUNT_DISTINCT functions.</div>
</section>
</li>
<li>
<section class="detail" id="supportsAggregateFunctionFilter()">
<h3>supportsAggregateFunctionFilter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsAggregateFunctionFilter</span>()</div>
<div class="block">Returns whether this dialect supports the use of FILTER clauses for
 aggregate functions. e.g. <code>COUNT(*) FILTER (WHERE a = 2)</code>.</div>
</section>
</li>
<li>
<section class="detail" id="supportsWindowFunctions()">
<h3>supportsWindowFunctions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsWindowFunctions</span>()</div>
<div class="block">Returns whether this dialect supports window functions (OVER clause).</div>
</section>
</li>
<li>
<section class="detail" id="supportsFunction(org.apache.calcite.sql.SqlOperator,org.apache.calcite.rel.type.RelDataType,java.util.List)">
<h3>supportsFunction</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsFunction</span><wbr><span class="parameters">(<a href="SqlOperator.html" title="class in org.apache.calcite.sql">SqlOperator</a>&nbsp;operator,
 <a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&gt;&nbsp;paramTypes)</span></div>
<div class="block">Returns whether this dialect supports a given function or operator.
 It only applies to built-in scalar functions and operators, since
 user-defined functions and procedures should be read by JdbcSchema.</div>
</section>
</li>
<li>
<section class="detail" id="getCalendarPolicy()">
<h3>getCalendarPolicy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="SqlDialect.CalendarPolicy.html" title="enum in org.apache.calcite.sql">SqlDialect.CalendarPolicy</a></span>&nbsp;<span class="element-name">getCalendarPolicy</span>()</div>
</section>
</li>
<li>
<section class="detail" id="supportsDataType(org.apache.calcite.rel.type.RelDataType)">
<h3>supportsDataType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsDataType</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</span></div>
<div class="block">Returns whether this dialect supports a given type.</div>
</section>
</li>
<li>
<section class="detail" id="getCastSpec(org.apache.calcite.rel.type.RelDataType)">
<h3>getCastSpec</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">@Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">getCastSpec</span><wbr><span class="parameters">(<a href="../rel/type/RelDataType.html" title="interface in org.apache.calcite.rel.type">RelDataType</a>&nbsp;type)</span></div>
<div class="block">Returns SqlNode for type in "cast(column as type)", which might be
 different between databases by type name, precision etc.

 <p>If this method returns null, the cast will be omitted. In the default
 implementation, this is the case for the NULL type, and therefore
 <code>CAST(NULL AS &lt;nulltype&gt;)</code> is rendered as <code>NULL</code>.</div>
</section>
</li>
<li>
<section class="detail" id="rewriteSingleValueExpr(org.apache.calcite.sql.SqlNode)">
<h3>rewriteSingleValueExpr</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">rewriteSingleValueExpr</span><wbr><span class="parameters">(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;aggCall)</span></div>
<div class="block">Rewrite SINGLE_VALUE into expression based on database variants
  E.g. HSQLDB, MYSQL, ORACLE, etc</div>
</section>
</li>
<li>
<section class="detail" id="emulateNullDirection(org.apache.calcite.sql.SqlNode,boolean,boolean)">
<h3>emulateNullDirection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">@Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">emulateNullDirection</span><wbr><span class="parameters">(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 boolean&nbsp;nullsFirst,
 boolean&nbsp;desc)</span></div>
<div class="block">Returns the SqlNode for emulating the null direction for the given field
 or <code>null</code> if no emulation needs to be done.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - The SqlNode representing the expression</dd>
<dd><code>nullsFirst</code> - Whether nulls should come first</dd>
<dd><code>desc</code> - Whether the sort direction is
 <a href="../rel/RelFieldCollation.Direction.html#DESCENDING"><code>RelFieldCollation.Direction.DESCENDING</code></a> or
 <a href="../rel/RelFieldCollation.Direction.html#STRICTLY_DESCENDING"><code>RelFieldCollation.Direction.STRICTLY_DESCENDING</code></a></dd>
<dt>Returns:</dt>
<dd>A SqlNode for null direction emulation or <code>null</code> if not required</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="emulateJoinTypeForCrossJoin()">
<h3>emulateJoinTypeForCrossJoin</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="JoinType.html" title="enum in org.apache.calcite.sql">JoinType</a></span>&nbsp;<span class="element-name">emulateJoinTypeForCrossJoin</span>()</div>
</section>
</li>
<li>
<section class="detail" id="emulateNullDirectionWithIsNull(org.apache.calcite.sql.SqlNode,boolean,boolean)">
<h3>emulateNullDirectionWithIsNull</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">@Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a></span>&nbsp;<span class="element-name">emulateNullDirectionWithIsNull</span><wbr><span class="parameters">(<a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;node,
 boolean&nbsp;nullsFirst,
 boolean&nbsp;desc)</span></div>
</section>
</li>
<li>
<section class="detail" id="supportsOffsetFetch()">
<h3>supportsOffsetFetch</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsOffsetFetch</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">This method is no longer used. To change how the dialect
 unparses offset/fetch, override the <a href="#unparseOffsetFetch(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)"><code>unparseOffsetFetch(org.apache.calcite.sql.SqlWriter, org.apache.calcite.sql.SqlNode, org.apache.calcite.sql.SqlNode)</code></a> method.</div>
</div>
<div class="block">Returns whether the dialect supports OFFSET/FETCH clauses
 introduced by SQL:2008, for instance
 <code>OFFSET 10 ROWS FETCH NEXT 20 ROWS ONLY</code>.
 If false, we assume that the dialect supports the alternative syntax
 <code>LIMIT 20 OFFSET 10</code>.</div>
</section>
</li>
<li>
<section class="detail" id="unparseOffsetFetch(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)">
<h3>unparseOffsetFetch</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseOffsetFetch</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
<div class="block">Converts an offset and fetch into SQL.

 <p>At least one of <code>offset</code> and <code>fetch</code> must be provided.

 <p>Common options:
 <ul>
   <li><code>OFFSET offset ROWS FETCH NEXT fetch ROWS ONLY</code>
   (ANSI standard SQL, Oracle, PostgreSQL, and the default)
   <li><code>LIMIT fetch OFFSET offset</code> (Apache Hive, MySQL, Redshift)
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>writer</code> - Writer</dd>
<dd><code>offset</code> - Number of rows to skip before emitting, or null</dd>
<dd><code>fetch</code> - Number of rows to fetch, or null</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#unparseFetchUsingAnsi(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)"><code>unparseFetchUsingAnsi(SqlWriter, SqlNode, SqlNode)</code></a></li>
<li><a href="#unparseFetchUsingLimit(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)"><code>unparseFetchUsingLimit(SqlWriter, SqlNode, SqlNode)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unparseTopN(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)">
<h3>unparseTopN</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseTopN</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
<div class="block">Converts a fetch into a "SELECT TOP(fetch)".

 <p>A dialect that uses "TOP" syntax should override this method to print
 "TOP(fetch)", and override <a href="#unparseOffsetFetch(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)"><code>unparseOffsetFetch(org.apache.calcite.sql.SqlWriter, org.apache.calcite.sql.SqlNode, org.apache.calcite.sql.SqlNode)</code></a> to no-op.

 <p>The default implementation of this method is no-op.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>writer</code> - Writer</dd>
<dd><code>offset</code> - Number of rows to skip before emitting, or null</dd>
<dd><code>fetch</code> - Number of rows to fetch, or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unparseFetchUsingAnsi(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)">
<h3>unparseFetchUsingAnsi</h3>
<div class="member-signature"><span class="modifiers">protected static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseFetchUsingAnsi</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
<div class="block">Unparses offset/fetch using ANSI standard "OFFSET offset ROWS FETCH NEXT
 fetch ROWS ONLY" syntax.</div>
</section>
</li>
<li>
<section class="detail" id="unparseFetchUsingLimit(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode,org.apache.calcite.sql.SqlNode)">
<h3>unparseFetchUsingLimit</h3>
<div class="member-signature"><span class="modifiers">protected static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseFetchUsingLimit</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
<div class="block">Unparses offset/fetch using "LIMIT fetch OFFSET offset" syntax.</div>
</section>
</li>
<li>
<section class="detail" id="unparseLimit(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode)">
<h3>unparseLimit</h3>
<div class="member-signature"><span class="modifiers">protected static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseLimit</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;fetch)</span></div>
</section>
</li>
<li>
<section class="detail" id="unparseOffset(org.apache.calcite.sql.SqlWriter,org.apache.calcite.sql.SqlNode)">
<h3>unparseOffset</h3>
<div class="member-signature"><span class="modifiers">protected static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unparseOffset</span><wbr><span class="parameters">(<a href="SqlWriter.html" title="interface in org.apache.calcite.sql">SqlWriter</a>&nbsp;writer,
 @Nullable <a href="SqlNode.html" title="class in org.apache.calcite.sql">SqlNode</a>&nbsp;offset)</span></div>
</section>
</li>
<li>
<section class="detail" id="supportsNestedAggregations()">
<h3>supportsNestedAggregations</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsNestedAggregations</span>()</div>
<div class="block">Returns whether the dialect supports nested aggregations, for instance
 <code>SELECT SUM(SUM(1)) </code>.</div>
</section>
</li>
<li>
<section class="detail" id="supportsGroupByWithRollup()">
<h3>supportsGroupByWithRollup</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsGroupByWithRollup</span>()</div>
<div class="block">Returns whether this dialect supports "WITH ROLLUP" in the "GROUP BY"
 clause.

 <p>For instance, in MySQL version 5,

 <blockquote>
   <code>
     SELECT deptno, job, COUNT(*) AS c
     FROM emp
     GROUP BY deptno, job WITH ROLLUP
   </code>
 </blockquote>

 <p>is equivalent to standard SQL

 <blockquote>
   <code>
     SELECT deptno, job, COUNT(*) AS c
     FROM emp
     GROUP BY ROLLUP(deptno, job)
     ORDER BY deptno, job
   </code>
 </blockquote>

 <p>The "WITH ROLLUP" clause was introduced in MySQL and is not standard
 SQL.

 <p>See also <a href="#supportsAggregateFunction(org.apache.calcite.sql.SqlKind)"><code>supportsAggregateFunction(SqlKind)</code></a> applied to
 <a href="SqlKind.html#ROLLUP"><code>SqlKind.ROLLUP</code></a>, which returns true in MySQL 8 and higher.</div>
</section>
</li>
<li>
<section class="detail" id="supportsGroupByWithCube()">
<h3>supportsGroupByWithCube</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsGroupByWithCube</span>()</div>
<div class="block">Returns whether this dialect supports "WITH CUBE" in "GROUP BY" clause.</div>
</section>
</li>
<li>
<section class="detail" id="supportsJoinType(org.apache.calcite.rel.core.JoinRelType)">
<h3>supportsJoinType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsJoinType</span><wbr><span class="parameters">(<a href="../rel/core/JoinRelType.html" title="enum in org.apache.calcite.rel.core">JoinRelType</a>&nbsp;joinType)</span></div>
<div class="block">Returns whether this dialect support the specified type of join.</div>
</section>
</li>
<li>
<section class="detail" id="getNullCollation()">
<h3>getNullCollation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../config/NullCollation.html" title="enum in org.apache.calcite.config">NullCollation</a></span>&nbsp;<span class="element-name">getNullCollation</span>()</div>
<div class="block">Returns how NULL values are sorted if an ORDER BY item does not contain
 NULLS ASCENDING or NULLS DESCENDING.</div>
</section>
</li>
<li>
<section class="detail" id="defaultNullDirection(org.apache.calcite.rel.RelFieldCollation.Direction)">
<h3>defaultNullDirection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../rel/RelFieldCollation.NullDirection.html" title="enum in org.apache.calcite.rel">RelFieldCollation.NullDirection</a></span>&nbsp;<span class="element-name">defaultNullDirection</span><wbr><span class="parameters">(<a href="../rel/RelFieldCollation.Direction.html" title="enum in org.apache.calcite.rel">RelFieldCollation.Direction</a>&nbsp;direction)</span></div>
<div class="block">Returns whether NULL values are sorted first or last, in this dialect,
 in an ORDER BY item of a given direction.</div>
</section>
</li>
<li>
<section class="detail" id="supportsAliasedValues()">
<h3>supportsAliasedValues</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsAliasedValues</span>()</div>
<div class="block">Returns whether the dialect supports VALUES in a sub-query with
 and an "AS t(column, ...)" values to define column names.

 <p>Currently, only Oracle does not. For this, we generate "SELECT v0 AS c0,
 v1 AS c1 ... UNION ALL ...". We may need to refactor this method when we
 support VALUES for other dialects.</div>
</section>
</li>
<li>
<section class="detail" id="supportsImplicitTypeCoercion(org.apache.calcite.rex.RexCall)">
<h3>supportsImplicitTypeCoercion</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">supportsImplicitTypeCoercion</span><wbr><span class="parameters">(<a href="../rex/RexCall.html" title="class in org.apache.calcite.rex">RexCall</a>&nbsp;call)</span></div>
<div class="block">Returns whether the dialect supports implicit type coercion.

 <p>Most of the sql dialects support implicit type coercion, so we make this method
 default return true. For instance, "cast('10' as integer) &gt; 5"
 can be simplified to "'10' &gt; 5" if the dialect supports implicit type coercion
 for VARCHAR and INTEGER comparison.

 <p>For sql dialect that does not support implicit type coercion, such as the BigQuery,
 we can not convert '10' into INT64 implicitly.

 <p>Now this method is used for some auxiliary decision when translating some <a href="../rex/RexCall.html" title="class in org.apache.calcite.rex"><code>RexCall</code></a>s,
 see SqlImplementor#stripCastFromString for details.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - the call to make decision</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSingleRowTableName()">
<h3>getSingleRowTableName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">getSingleRowTableName</span>()</div>
<div class="block">Returns the name of the system table that has precisely one row.
 If there is no such table, returns null, and we will generate SELECT with
 no FROM clause.

 <p>For <code>VALUES 1</code>,
 Oracle returns ["DUAL"] and we generate "SELECT 1 FROM DUAL";
 MySQL returns null and we generate "SELECT 1".</div>
</section>
</li>
<li>
<section class="detail" id="configureParser(org.apache.calcite.sql.parser.SqlParser.Config)">
<h3>configureParser</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a></span>&nbsp;<span class="element-name">configureParser</span><wbr><span class="parameters">(<a href="parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser">SqlParser.Config</a>&nbsp;config)</span></div>
<div class="block">Copies settings from this dialect into a parser configuration.

 <p><code>SqlDialect</code>, <a href="parser/SqlParser.Config.html" title="interface in org.apache.calcite.sql.parser"><code>SqlParser.Config</code></a> and <a href="validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate"><code>SqlConformance</code></a>
 cover different aspects of the same thing - the dialect of SQL spoken by a
 database - and this method helps to bridge between them. (The aspects are,
 respectively, generating SQL to send to a source database, parsing SQL
 sent to Calcite, and validating queries sent to Calcite. It makes sense to
 keep them as separate interfaces because they are used by different
 modules.)

 <p>The settings copied may differ among dialects, and may change over time,
 but currently include the following:

 <ul>
   <li><a href="#getQuoting()"><code>getQuoting()</code></a>
   <li><a href="#getQuotedCasing()"><code>getQuotedCasing()</code></a>
   <li><a href="#getUnquotedCasing()"><code>getUnquotedCasing()</code></a>
   <li><a href="#isCaseSensitive()"><code>isCaseSensitive()</code></a>
   <li><a href="#getConformance()"><code>getConformance()</code></a>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>config</code> - Parser configuration builder</dd>
<dt>Returns:</dt>
<dd>The configuration builder</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="configureParser(org.apache.calcite.sql.parser.SqlParser.ConfigBuilder)">
<h3>configureParser</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="parser/SqlParser.ConfigBuilder.html" title="class in org.apache.calcite.sql.parser">SqlParser.ConfigBuilder</a></span>&nbsp;<span class="element-name">configureParser</span><wbr><span class="parameters">(<a href="parser/SqlParser.ConfigBuilder.html" title="class in org.apache.calcite.sql.parser">SqlParser.ConfigBuilder</a>&nbsp;configBuilder)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="getConformance()">
<h3>getConformance</h3>
<div class="member-signature"><span class="modifiers">public</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">getConformance</span>()</div>
<div class="block">Returns the <a href="validate/SqlConformance.html" title="interface in org.apache.calcite.sql.validate"><code>SqlConformance</code></a> that matches this dialect.

 <p>The base implementation returns its best guess, based upon
 <code>databaseProduct</code>; sub-classes may override.</div>
</section>
</li>
<li>
<section class="detail" id="getQuoting()">
<h3>getQuoting</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">@Nullable org.apache.calcite.avatica.util.Quoting</span>&nbsp;<span class="element-name">getQuoting</span>()</div>
<div class="block">Returns the quoting scheme, or null if the combination of
 <a href="#identifierQuoteString"><code>identifierQuoteString</code></a> and <a href="#identifierEndQuoteString"><code>identifierEndQuoteString</code></a>
 does not correspond to any known quoting scheme.</div>
</section>
</li>
<li>
<section class="detail" id="getUnquotedCasing()">
<h3>getUnquotedCasing</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.Casing</span>&nbsp;<span class="element-name">getUnquotedCasing</span>()</div>
<div class="block">Returns how unquoted identifiers are stored.</div>
</section>
</li>
<li>
<section class="detail" id="getQuotedCasing()">
<h3>getQuotedCasing</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.calcite.avatica.util.Casing</span>&nbsp;<span class="element-name">getQuotedCasing</span>()</div>
<div class="block">Returns how quoted identifiers are stored.</div>
</section>
</li>
<li>
<section class="detail" id="isCaseSensitive()">
<h3>isCaseSensitive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isCaseSensitive</span>()</div>
<div class="block">Returns whether matching of identifiers is case-sensitive.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
