<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>CalciteSystemProperty (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.config, class: CalciteSystemProperty">
<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>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.config</a></div>
<h1 title="Class CalciteSystemProperty" class="title">Class CalciteSystemProperty&lt;T&gt;</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.config.CalciteSystemProperty&lt;T&gt;</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - the type of the property value</dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">CalciteSystemProperty&lt;T&gt;</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">A Calcite specific system property that is used to configure various aspects of the framework.

 <p>Calcite system properties must always be in the "calcite" root namespace.</p></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#ALLOW_INFINITE_COST_CONVERTERS" class="member-name-link">ALLOW_INFINITE_COST_CONVERTERS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether the optimizer will consider adding converters of infinite cost in
 order to convert a relational expression from one calling convention to
 another.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#BINDABLE_CACHE_CONCURRENCY_LEVEL" class="member-name-link">BINDABLE_CACHE_CONCURRENCY_LEVEL</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The concurrency level of the cache used for storing Bindable objects, instantiated via
 dynamically generated Java classes.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#BINDABLE_CACHE_MAX_SIZE" class="member-name-link">BINDABLE_CACHE_MAX_SIZE</a></code></div>
<div class="col-last even-row-color">
<div class="block">The maximum size of the cache used for storing Bindable objects, instantiated via
 dynamically generated Java classes.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#COMMUTE" class="member-name-link">COMMUTE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to exploit join commutative property.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#DEBUG" class="member-name-link">DEBUG</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to run Calcite in debug mode.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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"><code><a href="#DEFAULT_CHARSET" class="member-name-link">DEFAULT_CHARSET</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The name of the default character set.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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 even-row-color"><code><a href="#DEFAULT_COLLATION" class="member-name-link">DEFAULT_COLLATION</a></code></div>
<div class="col-last even-row-color">
<div class="block">The name of the default collation.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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"><code><a href="#DEFAULT_COLLATION_STRENGTH" class="member-name-link">DEFAULT_COLLATION_STRENGTH</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The strength of the default collation.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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 even-row-color"><code><a href="#DEFAULT_NATIONAL_CHARSET" class="member-name-link">DEFAULT_NATIONAL_CHARSET</a></code></div>
<div class="col-last even-row-color">
<div class="block">The name of the default national character set.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#DUMP_GRAPHVIZ" class="member-name-link">DUMP_GRAPHVIZ</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to include a GraphViz representation when dumping the state of the Volcano planner.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#DUMP_SETS" class="member-name-link">DUMP_SETS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to include <code>RelSet</code> information when dumping the state of the Volcano
 planner.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#ENABLE_COLLATION_TRAIT" class="member-name-link">ENABLE_COLLATION_TRAIT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to enable the collation trait in the default planner configuration.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#ENABLE_ENUMERABLE" class="member-name-link">ENABLE_ENUMERABLE</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether the enumerable convention is enabled in the default planner configuration.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#ENABLE_REX_DIGEST_NORMALIZE" class="member-name-link">ENABLE_REX_DIGEST_NORMALIZE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether RexNode digest should be normalized (e.g.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#ENABLE_STREAM" class="member-name-link">ENABLE_STREAM</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether streaming is enabled in the default planner configuration.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#ENUMERABLE_ENABLE_TABLESCAN_ARRAY" class="member-name-link">ENUMERABLE_ENABLE_TABLESCAN_ARRAY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether the EnumerableTableScan should support ARRAY fields.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#ENUMERABLE_ENABLE_TABLESCAN_MAP" class="member-name-link">ENUMERABLE_ENABLE_TABLESCAN_MAP</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether the EnumerableTableScan should support MAP fields.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#ENUMERABLE_ENABLE_TABLESCAN_MULTISET" class="member-name-link">ENUMERABLE_ENABLE_TABLESCAN_MULTISET</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether the EnumerableTableScan should support MULTISET fields.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#INTEGRATION_TEST" class="member-name-link">INTEGRATION_TEST</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to run integration tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#METADATA_HANDLER_CACHE_MAXIMUM_SIZE" class="member-name-link">METADATA_HANDLER_CACHE_MAXIMUM_SIZE</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The maximum size of the cache of metadata handlers.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#STRICT" class="member-name-link">STRICT</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to follow the SQL standard strictly.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#TEST_CASSANDRA" class="member-name-link">TEST_CASSANDRA</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to run Cassandra tests.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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 even-row-color"><code><a href="#TEST_DATASET_PATH" class="member-name-link">TEST_DATASET_PATH</a></code></div>
<div class="col-last even-row-color">
<div class="block">Path to the dataset file that should used for integration tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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"><code><a href="#TEST_DB" class="member-name-link">TEST_DB</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Which database to use for tests that require a JDBC data source.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#TEST_DRUID" class="member-name-link">TEST_DRUID</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to run Druid tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;@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>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#TEST_FOODMART_QUERY_IDS" class="member-name-link">TEST_FOODMART_QUERY_IDS</a></code></div>
<div class="col-last odd-row-color">
<div class="block">A list of ids designating the queries
 (from query.json in new.hydromatic:foodmart-queries:0.4.1)
 that should be run as part of FoodmartTest.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#TEST_INNODB" class="member-name-link">TEST_INNODB</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to run InnoDB tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#TEST_MONGODB" class="member-name-link">TEST_MONGODB</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to run MongoDB tests.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#TEST_REDIS" class="member-name-link">TEST_REDIS</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to run Redis tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#TEST_SPLUNK" class="member-name-link">TEST_SPLUNK</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to run Splunk tests.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#TEST_WITH_DOCKER_CONTAINER" class="member-name-link">TEST_WITH_DOCKER_CONTAINER</a></code></div>
<div class="col-last even-row-color">
<div class="block">Whether to use Docker containers (https://www.testcontainers.org/) in tests.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#TOPDOWN_OPT" class="member-name-link">TOPDOWN_OPT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Whether to enable top-down optimization.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="CalciteSystemProperty.html" title="type parameter in CalciteSystemProperty">T</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#value()" class="member-name-link">value</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 value of this property.</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="DEBUG">
<h3>DEBUG</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">DEBUG</span></div>
<div class="block">Whether to run Calcite in debug mode.

 <p>When debug mode is activated significantly more information is gathered and printed to
 STDOUT. It is most commonly used to print and identify problems in generated java code. Debug
 mode is also used to perform more verifications at runtime, which are not performed during
 normal execution.</p></div>
</section>
</li>
<li>
<section class="detail" id="COMMUTE">
<h3>COMMUTE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">COMMUTE</span></div>
<div class="block">Whether to exploit join commutative property.</div>
</section>
</li>
<li>
<section class="detail" id="ENABLE_COLLATION_TRAIT">
<h3>ENABLE_COLLATION_TRAIT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENABLE_COLLATION_TRAIT</span></div>
<div class="block">Whether to enable the collation trait in the default planner configuration.

 <p>Some extra optimizations are possible if enabled, but queries should
 work either way. At some point this will become a preference, or we will
 run multiple phases: first disabled, then enabled.</div>
</section>
</li>
<li>
<section class="detail" id="ENABLE_ENUMERABLE">
<h3>ENABLE_ENUMERABLE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENABLE_ENUMERABLE</span></div>
<div class="block">Whether the enumerable convention is enabled in the default planner configuration.</div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_ENABLE_TABLESCAN_ARRAY">
<h3>ENUMERABLE_ENABLE_TABLESCAN_ARRAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENUMERABLE_ENABLE_TABLESCAN_ARRAY</span></div>
<div class="block">Whether the EnumerableTableScan should support ARRAY fields.</div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_ENABLE_TABLESCAN_MAP">
<h3>ENUMERABLE_ENABLE_TABLESCAN_MAP</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENUMERABLE_ENABLE_TABLESCAN_MAP</span></div>
<div class="block">Whether the EnumerableTableScan should support MAP fields.</div>
</section>
</li>
<li>
<section class="detail" id="ENUMERABLE_ENABLE_TABLESCAN_MULTISET">
<h3>ENUMERABLE_ENABLE_TABLESCAN_MULTISET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENUMERABLE_ENABLE_TABLESCAN_MULTISET</span></div>
<div class="block">Whether the EnumerableTableScan should support MULTISET fields.</div>
</section>
</li>
<li>
<section class="detail" id="ENABLE_STREAM">
<h3>ENABLE_STREAM</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENABLE_STREAM</span></div>
<div class="block">Whether streaming is enabled in the default planner configuration.</div>
</section>
</li>
<li>
<section class="detail" id="ENABLE_REX_DIGEST_NORMALIZE">
<h3>ENABLE_REX_DIGEST_NORMALIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ENABLE_REX_DIGEST_NORMALIZE</span></div>
<div class="block">Whether RexNode digest should be normalized (e.g. call operands ordered).
 <p>Normalization helps to treat $0=$1 and $1=$0 expressions equal, thus it saves efforts
 on planning.</p></div>
</section>
</li>
<li>
<section class="detail" id="STRICT">
<h3>STRICT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">STRICT</span></div>
<div class="block">Whether to follow the SQL standard strictly.</div>
</section>
</li>
<li>
<section class="detail" id="DUMP_GRAPHVIZ">
<h3>DUMP_GRAPHVIZ</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">DUMP_GRAPHVIZ</span></div>
<div class="block">Whether to include a GraphViz representation when dumping the state of the Volcano planner.</div>
</section>
</li>
<li>
<section class="detail" id="DUMP_SETS">
<h3>DUMP_SETS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">DUMP_SETS</span></div>
<div class="block">Whether to include <code>RelSet</code> information when dumping the state of the Volcano
 planner.</div>
</section>
</li>
<li>
<section class="detail" id="TOPDOWN_OPT">
<h3>TOPDOWN_OPT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TOPDOWN_OPT</span></div>
<div class="block">Whether to enable top-down optimization. This config can be overridden
 by <a href="CalciteConnectionProperty.html#TOPDOWN_OPT"><code>CalciteConnectionProperty.TOPDOWN_OPT</code></a>.

 <p>Note: Enabling top-down optimization will automatically disable
 the use of AbstractConverter and related rules.</p></div>
</section>
</li>
<li>
<section class="detail" id="INTEGRATION_TEST">
<h3>INTEGRATION_TEST</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">INTEGRATION_TEST</span></div>
<div class="block">Whether to run integration tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_DB">
<h3>TEST_DB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">TEST_DB</span></div>
<div class="block">Which database to use for tests that require a JDBC data source.

 <p>The property can take one of the following values:

 <ul>
   <li>HSQLDB (default)</li>
   <li>H2</li>
   <li>MYSQL</li>
   <li>ORACLE</li>
   <li>POSTGRESQL</li>
 </ul>

 <p>If the specified value is not included in the previous list, the default
 is used.

 <p>We recommend that casual users use hsqldb, and frequent Calcite
 developers use MySQL. The test suite runs faster against the MySQL database
 (mainly because of the 0.1 second versus 6 seconds startup time). You have
 to populate MySQL manually with the foodmart data set, otherwise there will
 be test failures.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_DATASET_PATH">
<h3>TEST_DATASET_PATH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">TEST_DATASET_PATH</span></div>
<div class="block">Path to the dataset file that should used for integration tests.

 <p>If a path is not set, then one of the following values will be used:

 <ul>
   <li>../calcite-test-dataset</li>
   <li>../../calcite-test-dataset</li>
   <li>.</li>
 </ul>
 The first valid path that exists in the filesystem will be chosen.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_MONGODB">
<h3>TEST_MONGODB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_MONGODB</span></div>
<div class="block">Whether to run MongoDB tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_SPLUNK">
<h3>TEST_SPLUNK</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_SPLUNK</span></div>
<div class="block">Whether to run Splunk tests.

 <p>Disabled by default, because we do not expect Splunk to be installed
 and populated with the data set necessary for testing.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_DRUID">
<h3>TEST_DRUID</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_DRUID</span></div>
<div class="block">Whether to run Druid tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_CASSANDRA">
<h3>TEST_CASSANDRA</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_CASSANDRA</span></div>
<div class="block">Whether to run Cassandra tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_INNODB">
<h3>TEST_INNODB</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_INNODB</span></div>
<div class="block">Whether to run InnoDB tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_REDIS">
<h3>TEST_REDIS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_REDIS</span></div>
<div class="block">Whether to run Redis tests.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_WITH_DOCKER_CONTAINER">
<h3>TEST_WITH_DOCKER_CONTAINER</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">TEST_WITH_DOCKER_CONTAINER</span></div>
<div class="block">Whether to use Docker containers (https://www.testcontainers.org/) in tests.

 If the property is set to <code>true</code>, affected tests will attempt to start Docker
 containers; when Docker is not available tests fallback to other execution modes and if it's
 not possible they are skipped entirely.

 If the property is set to <code>false</code>, Docker containers are not used at all and
 affected tests either fallback to other execution modes or skipped entirely.

 Users can override the default behavior to force non-Dockerized execution even when Docker
 is installed on the machine; this can be useful for replicating an issue that appears only in
 non-docker test mode or for running tests both with and without containers in CI.</div>
</section>
</li>
<li>
<section class="detail" id="TEST_FOODMART_QUERY_IDS">
<h3>TEST_FOODMART_QUERY_IDS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;@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>&gt;</span>&nbsp;<span class="element-name">TEST_FOODMART_QUERY_IDS</span></div>
<div class="block">A list of ids designating the queries
 (from query.json in new.hydromatic:foodmart-queries:0.4.1)
 that should be run as part of FoodmartTest.</div>
</section>
</li>
<li>
<section class="detail" id="ALLOW_INFINITE_COST_CONVERTERS">
<h3>ALLOW_INFINITE_COST_CONVERTERS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&gt;</span>&nbsp;<span class="element-name">ALLOW_INFINITE_COST_CONVERTERS</span></div>
<div class="block">Whether the optimizer will consider adding converters of infinite cost in
 order to convert a relational expression from one calling convention to
 another.</div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_CHARSET">
<h3>DEFAULT_CHARSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">DEFAULT_CHARSET</span></div>
<div class="block">The name of the default character set.

 <p>It is used by <a href="../sql/validate/SqlValidator.html" title="interface in org.apache.calcite.sql.validate"><code>SqlValidator</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_NATIONAL_CHARSET">
<h3>DEFAULT_NATIONAL_CHARSET</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">DEFAULT_NATIONAL_CHARSET</span></div>
<div class="block">The name of the default national character set.

 <p>It is used with the N'string' construct in
 <a href="../sql/SqlLiteral.html#%3Cinit%3E(java.lang.Object,org.apache.calcite.sql.type.SqlTypeName,org.apache.calcite.sql.parser.SqlParserPos)"><code>SqlLiteral(java.lang.Object, org.apache.calcite.sql.type.SqlTypeName, org.apache.calcite.sql.parser.SqlParserPos)</code></a>
 and may be different from the <a href="#DEFAULT_CHARSET"><code>DEFAULT_CHARSET</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_COLLATION">
<h3>DEFAULT_COLLATION</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">DEFAULT_COLLATION</span></div>
<div class="block">The name of the default collation.

 <p>It is used in <a href="../sql/SqlCollation.html" title="class in org.apache.calcite.sql"><code>SqlCollation</code></a> and
 <a href="../sql/SqlLiteral.html#%3Cinit%3E(java.lang.Object,org.apache.calcite.sql.type.SqlTypeName,org.apache.calcite.sql.parser.SqlParserPos)"><code>SqlLiteral(java.lang.Object, org.apache.calcite.sql.type.SqlTypeName, org.apache.calcite.sql.parser.SqlParserPos)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_COLLATION_STRENGTH">
<h3>DEFAULT_COLLATION_STRENGTH</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</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">DEFAULT_COLLATION_STRENGTH</span></div>
<div class="block">The strength of the default collation.
 Allowed values (as defined in <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/text/Collator.html" title="class or interface in java.text" class="external-link"><code>Collator</code></a>) are: primary, secondary,
 tertiary, identical.

 <p>It is used in <a href="../sql/SqlCollation.html" title="class in org.apache.calcite.sql"><code>SqlCollation</code></a> and
 <a href="../sql/SqlLiteral.html#%3Cinit%3E(java.lang.Object,org.apache.calcite.sql.type.SqlTypeName,org.apache.calcite.sql.parser.SqlParserPos)"><code>SqlLiteral(java.lang.Object, org.apache.calcite.sql.type.SqlTypeName, org.apache.calcite.sql.parser.SqlParserPos)</code></a>.</p></div>
</section>
</li>
<li>
<section class="detail" id="METADATA_HANDLER_CACHE_MAXIMUM_SIZE">
<h3>METADATA_HANDLER_CACHE_MAXIMUM_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">METADATA_HANDLER_CACHE_MAXIMUM_SIZE</span></div>
<div class="block">The maximum size of the cache of metadata handlers.

 <p>A typical value is the number of queries being concurrently prepared multiplied by the
 number of types of metadata.</p>

 <p>If the value is less than 0, there is no limit.</p></div>
</section>
</li>
<li>
<section class="detail" id="BINDABLE_CACHE_MAX_SIZE">
<h3>BINDABLE_CACHE_MAX_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">BINDABLE_CACHE_MAX_SIZE</span></div>
<div class="block">The maximum size of the cache used for storing Bindable objects, instantiated via
 dynamically generated Java classes.

 <p>The default value is 0.</p>

 <p>The property can take any value between [0, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html#MAX_VALUE" title="class or interface in java.lang" class="external-link"><code>Integer.MAX_VALUE</code></a>] inclusive. If the
 value is not valid (or not specified) then the default value is used.</p>

 <p>The cached objects may be quite big so it is suggested to use a rather small cache size
 (e.g., 1000). For the most common use cases a number close to 1000 should be enough to
 alleviate the performance penalty of compiling and loading classes.</p>

 <p>Setting this property to 0 disables the cache.</p></div>
</section>
</li>
<li>
<section class="detail" id="BINDABLE_CACHE_CONCURRENCY_LEVEL">
<h3>BINDABLE_CACHE_CONCURRENCY_LEVEL</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="class in org.apache.calcite.config">CalciteSystemProperty</a>&lt;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">BINDABLE_CACHE_CONCURRENCY_LEVEL</span></div>
<div class="block">The concurrency level of the cache used for storing Bindable objects, instantiated via
 dynamically generated Java classes.

 <p>The default value is 1.</p>

 <p>The property can take any value between [1, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Integer.html#MAX_VALUE" title="class or interface in java.lang" class="external-link"><code>Integer.MAX_VALUE</code></a>] inclusive. If the
 value is not valid (or not specified) then the default value is used.</p>

 <p>This property has no effect if the cache is disabled (i.e., <a href="#BINDABLE_CACHE_MAX_SIZE"><code>BINDABLE_CACHE_MAX_SIZE</code></a>
 set to 0.</p></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="value()">
<h3>value</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSystemProperty.html" title="type parameter in CalciteSystemProperty">T</a></span>&nbsp;<span class="element-name">value</span>()</div>
<div class="block">Returns the value of this property.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the value of this property or <code>null</code> if a default value has not been
 defined for this property.</dd>
</dl>
</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>
