<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>CalciteSchema (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.jdbc, class: CalciteSchema">
<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.jdbc</a></div>
<h1 title="Class CalciteSchema" class="title">Class CalciteSchema</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.jdbc.CalciteSchema</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="CalciteRootSchema.html" title="class in org.apache.calcite.jdbc">CalciteRootSchema</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">CalciteSchema</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">Schema.

 <p>Wrapper around user-defined schema used internally.</p></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 class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="CalciteSchema.Entry.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.Entry</a></code></div>
<div class="col-last even-row-color">
<div class="block">Entry in a schema, such as a table or sub-schema.</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="CalciteSchema.FunctionEntry.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Membership of a function in a schema.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="CalciteSchema.FunctionEntryImpl.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntryImpl</a></code></div>
<div class="col-last even-row-color">
<div class="block">Implementation of <a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.FunctionEntry</code></a>
 where all properties are held in fields.</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="CalciteSchema.LatticeEntry.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Membership of a lattice in a schema.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="CalciteSchema.LatticeEntryImpl.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntryImpl</a></code></div>
<div class="col-last even-row-color">
<div class="block">Implementation of <a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.LatticeEntry</code></a>
 where all properties are held in fields.</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="CalciteSchema.TableEntry.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Membership of a table in a schema.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="CalciteSchema.TableEntryImpl.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntryImpl</a></code></div>
<div class="col-last even-row-color">
<div class="block">Implementation of <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TableEntry</code></a>
 where all properties are held in fields.</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="CalciteSchema.TypeEntry.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Membership of a type in a schema.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="CalciteSchema.TypeEntryImpl.html" class="type-name-link" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntryImpl</a></code></div>
<div class="col-last even-row-color">
<div class="block">Implementation of <a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc"><code>CalciteSchema.TypeEntry</code></a>
 where all properties are held in fields.</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 final <a href="../util/NameMultimap.html" title="class in org.apache.calcite.util">NameMultimap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#functionMap" class="member-name-link">functionMap</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../util/NameSet.html" title="class in org.apache.calcite.util">NameSet</a></code></div>
<div class="col-second odd-row-color"><code><a href="#functionNames" class="member-name-link">functionNames</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#latticeMap" class="member-name-link">latticeMap</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><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 odd-row-color"><code><a href="#name" class="member-name-link">name</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#nullaryFunctionMap" class="member-name-link">nullaryFunctionMap</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>final <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a></code></div>
<div class="col-second odd-row-color"><code><a href="#schema" class="member-name-link">schema</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#subSchemaMap" class="member-name-link">subSchemaMap</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#tableMap" class="member-name-link">tableMap</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Tables explicitly defined in this schema.</div>
</div>
<div class="col-first even-row-color"><code>protected final <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#typeMap" class="member-name-link">typeMap</a></code></div>
<div class="col-last even-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 three-column-summary">
<div class="table-header col-first">Modifier</div>
<div class="table-header col-second">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected </code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.calcite.jdbc.CalciteSchema,org.apache.calcite.schema.Schema,java.lang.String,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMultimap,org.apache.calcite.util.NameSet,org.apache.calcite.util.NameMap,java.util.List)" class="member-name-link">CalciteSchema</a><wbr>(@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;parent,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;&nbsp;subSchemaMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a>&gt;&nbsp;tableMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;&nbsp;latticeMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a>&gt;&nbsp;typeMap,
 @Nullable <a href="../util/NameMultimap.html" title="class in org.apache.calcite.util">NameMultimap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;&nbsp;functionMap,
 @Nullable <a href="../util/NameSet.html" title="class in org.apache.calcite.util">NameSet</a>&nbsp;functionNames,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;&nbsp;nullaryFunctionMap,
 @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;? extends <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;&gt;&nbsp;path)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-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-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button><button id="method-summary-table-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><a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</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">Defines a type within this schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>abstract <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#add(java.lang.String,org.apache.calcite.schema.Schema)" class="member-name-link">add</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds a child schema of this schema.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.String,org.apache.calcite.schema.Table)" class="member-name-link">add</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;tableName,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Defines a table within this schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#add(java.lang.String,org.apache.calcite.schema.Table,com.google.common.collect.ImmutableList)" class="member-name-link">add</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;tableName,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table,
 com.google.common.collect.ImmutableList&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;sqls)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Defines a table within this schema.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitFuncNamesToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)" class="member-name-link">addImplicitFuncNamesToBuilder</a><wbr>(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit function names to a builder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitFunctionsToBuilder(com.google.common.collect.ImmutableList.Builder,java.lang.String,boolean)" class="member-name-link">addImplicitFunctionsToBuilder</a><wbr>(com.google.common.collect.ImmutableList.Builder&lt;<a href="../schema/Function.html" title="interface in org.apache.calcite.schema">Function</a>&gt;&nbsp;builder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit functions to a builder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitSubSchemaToBuilder(com.google.common.collect.ImmutableSortedMap.Builder)" class="member-name-link">addImplicitSubSchemaToBuilder</a><wbr>(com.google.common.collect.ImmutableSortedMap.Builder&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>,<wbr><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;&nbsp;builder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit sub-schemas to a builder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitTablesBasedOnNullaryFunctionsToBuilder(com.google.common.collect.ImmutableSortedMap.Builder)" class="member-name-link">addImplicitTablesBasedOnNullaryFunctionsToBuilder</a><wbr>(com.google.common.collect.ImmutableSortedMap.Builder&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>,<wbr><a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&gt;&nbsp;builder)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit table functions to a builder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitTableToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)" class="member-name-link">addImplicitTableToBuilder</a><wbr>(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit tables to a builder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addImplicitTypeNamesToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)" class="member-name-link">addImplicitTypeNamesToBuilder</a><wbr>(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Adds implicit type names to a builder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createRootSchema(boolean)" class="member-name-link">createRootSchema</a><wbr>(boolean&nbsp;addMetadataSchema)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a root schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createRootSchema(boolean,boolean)" class="member-name-link">createRootSchema</a><wbr>(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a root schema.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createRootSchema(boolean,boolean,java.lang.String)" class="member-name-link">createRootSchema</a><wbr>(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a root schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createRootSchema(boolean,boolean,java.lang.String,org.apache.calcite.schema.Schema)" class="member-name-link">createRootSchema</a><wbr>(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema)</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-tab2 method-summary-table-tab4"><code><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createSnapshot(org.apache.calcite.schema.SchemaVersion)" class="member-name-link">createSnapshot</a><wbr>(<a href="../schema/SchemaVersion.html" title="interface in org.apache.calcite.schema">SchemaVersion</a>&nbsp;version)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a snapshot of this CalciteSchema as of the specified time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>protected static &lt;V&gt;&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr>V&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#find(java.util.NavigableMap,java.lang.String)" class="member-name-link">find</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr>V&gt;&nbsp;map,
 <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 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use NameMap</div>
</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>protected static <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<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 method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#find(java.util.NavigableSet,java.lang.String)" class="member-name-link">find</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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;set,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use NameSet</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#from(org.apache.calcite.schema.SchemaPlus)" class="member-name-link">from</a><wbr>(<a href="../schema/SchemaPlus.html" title="interface in org.apache.calcite.schema">SchemaPlus</a>&nbsp;plus)</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-tab2 method-summary-table-tab4"><code>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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 method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getFunctionNames()" class="member-name-link">getFunctionNames</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 list of function names in this schema, both implicit and
 explicit, never null.</div>
</div>
<div class="col-first odd-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/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../schema/Function.html" title="interface in org.apache.calcite.schema">Function</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="#getFunctions(java.lang.String,boolean)" class="member-name-link">getFunctions</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a collection of all functions, explicit and implicit, with a given
 name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract @Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getImplicitSubSchema(java.lang.String,boolean)" class="member-name-link">getImplicitSubSchema</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;schemaName,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns a sub-schema with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.schema.Schema)"><code>add(String, Schema)</code></a>), or null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract @Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getImplicitTable(java.lang.String,boolean)" class="member-name-link">getImplicitTable</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;tableName,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns a table with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.schema.Table)"><code>add(String, Table)</code></a>), or null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract @Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getImplicitTableBasedOnNullaryFunction(java.lang.String,boolean)" class="member-name-link">getImplicitTableBasedOnNullaryFunction</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;tableName,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns table function with a given name and zero arguments that is
 defined implicitly (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object,
 not explicitly by a call to <code>add(String, Function)</code>), or null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract @Nullable <a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getImplicitType(java.lang.String,boolean)" class="member-name-link">getImplicitType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns a type with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)"><code>add(String, RelProtoDataType)</code></a>), or null.</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/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLatticeMap()" class="member-name-link">getLatticeMap</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 a collection of lattices.</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="#getName()" class="member-name-link">getName</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><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <a href="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;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getPath()" class="member-name-link">getPath</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 default path resolving functions from this schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final @Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSubSchema(java.lang.String,boolean)" class="member-name-link">getSubSchema</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;schemaName,
 boolean&nbsp;caseSensitive)</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>final <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSubSchemaMap()" class="member-name-link">getSubSchemaMap</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 a collection of sub-schemas, both explicit (defined using
 <a href="#add(java.lang.String,org.apache.calcite.schema.Schema)"><code>add(String, org.apache.calcite.schema.Schema)</code></a>) and implicit
 (defined using <a href="../schema/Schema.html#getSubSchemaNames()"><code>Schema.getSubSchemaNames()</code></a>
 and <a href="../schema/Schema.html#getSubSchema(java.lang.String)"><code>Schema.getSubSchema(String)</code></a>).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final @Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTable(java.lang.String,boolean)" class="member-name-link">getTable</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;tableName,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a table with the given name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final @Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTableBasedOnNullaryFunction(java.lang.String,boolean)" class="member-name-link">getTableBasedOnNullaryFunction</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;tableName,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a tables derived from explicit and implicit functions
 that take zero parameters.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final @Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTableBySql(java.lang.String)" class="member-name-link">getTableBySql</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;sql)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a table that materializes the given SQL statement.</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/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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 method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTableNames()" class="member-name-link">getTableNames</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 set of all table names.</div>
</div>
<div class="col-first odd-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/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</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="#getTablesBasedOnNullaryFunctions()" class="member-name-link">getTablesBasedOnNullaryFunctions</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 tables derived from explicit and implicit functions
 that take zero parameters.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>final @Nullable <a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getType(java.lang.String,boolean)" class="member-name-link">getType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a type, explicit and implicit, with a given
 name.</div>
</div>
<div class="col-first odd-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/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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="#getTypeNames()" class="member-name-link">getTypeNames</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 set of all types names.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isCacheEnabled()" class="member-name-link">isCacheEnabled</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-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="#isRoot()" class="member-name-link">isRoot</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 is a root schema.</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/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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#path(java.lang.String)" class="member-name-link">path</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;name)</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 path of an object in this schema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../schema/SchemaPlus.html" title="interface in org.apache.calcite.schema">SchemaPlus</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#plus()" class="member-name-link">plus</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>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeFunction(java.lang.String)" class="member-name-link">removeFunction</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-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="#removeSubSchema(java.lang.String)" class="member-name-link">removeSubSchema</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last 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>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeTable(java.lang.String)" class="member-name-link">removeTable</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-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="#removeType(java.lang.String)" class="member-name-link">removeType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last 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><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#root()" class="member-name-link">root</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-tab3"><code>abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setCache(boolean)" class="member-name-link">setCache</a><wbr>(boolean&nbsp;cache)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#snapshot(org.apache.calcite.jdbc.CalciteSchema,org.apache.calcite.schema.SchemaVersion)" class="member-name-link">snapshot</a><wbr>(@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;parent,
 <a href="../schema/SchemaVersion.html" title="interface in org.apache.calcite.schema">SchemaVersion</a>&nbsp;version)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns a snapshot representation of this CalciteSchema.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="CalciteSchema.TableEntryImpl.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntryImpl</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#tableEntry(java.lang.String,org.apache.calcite.schema.Table)" class="member-name-link">tableEntry</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a TableEntryImpl with no SQLs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="CalciteSchema.TypeEntryImpl.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntryImpl</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#typeEntry(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)" class="member-name-link">typeEntry</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</a>&nbsp;relProtoDataType)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a TableEntryImpl with no SQLs.</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="schema">
<h3>schema</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a></span>&nbsp;<span class="element-name">schema</span></div>
</section>
</li>
<li>
<section class="detail" id="name">
<h3>name</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">name</span></div>
</section>
</li>
<li>
<section class="detail" id="tableMap">
<h3>tableMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a>&gt;</span>&nbsp;<span class="element-name">tableMap</span></div>
<div class="block">Tables explicitly defined in this schema. Does not include tables in
  <a href="#schema"><code>schema</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="functionMap">
<h3>functionMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMultimap.html" title="class in org.apache.calcite.util">NameMultimap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;</span>&nbsp;<span class="element-name">functionMap</span></div>
</section>
</li>
<li>
<section class="detail" id="typeMap">
<h3>typeMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a>&gt;</span>&nbsp;<span class="element-name">typeMap</span></div>
</section>
</li>
<li>
<section class="detail" id="latticeMap">
<h3>latticeMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;</span>&nbsp;<span class="element-name">latticeMap</span></div>
</section>
</li>
<li>
<section class="detail" id="functionNames">
<h3>functionNames</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameSet.html" title="class in org.apache.calcite.util">NameSet</a></span>&nbsp;<span class="element-name">functionNames</span></div>
</section>
</li>
<li>
<section class="detail" id="nullaryFunctionMap">
<h3>nullaryFunctionMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;</span>&nbsp;<span class="element-name">nullaryFunctionMap</span></div>
</section>
</li>
<li>
<section class="detail" id="subSchemaMap">
<h3>subSchemaMap</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;</span>&nbsp;<span class="element-name">subSchemaMap</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.jdbc.CalciteSchema,org.apache.calcite.schema.Schema,java.lang.String,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMap,org.apache.calcite.util.NameMultimap,org.apache.calcite.util.NameSet,org.apache.calcite.util.NameMap,java.util.List)">
<h3>CalciteSchema</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">CalciteSchema</span><wbr><span class="parameters">(@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;parent,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;&nbsp;subSchemaMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a>&gt;&nbsp;tableMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;&nbsp;latticeMap,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a>&gt;&nbsp;typeMap,
 @Nullable <a href="../util/NameMultimap.html" title="class in org.apache.calcite.util">NameMultimap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;&nbsp;functionMap,
 @Nullable <a href="../util/NameSet.html" title="class in org.apache.calcite.util">NameSet</a>&nbsp;functionNames,
 @Nullable <a href="../util/NameMap.html" title="class in org.apache.calcite.util">NameMap</a>&lt;<a href="CalciteSchema.FunctionEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.FunctionEntry</a>&gt;&nbsp;nullaryFunctionMap,
 @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;? extends <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;&gt;&nbsp;path)</span></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="getImplicitSubSchema(java.lang.String,boolean)">
<h3>getImplicitSubSchema</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">getImplicitSubSchema</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;schemaName,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a sub-schema with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.schema.Schema)"><code>add(String, Schema)</code></a>), or null.</div>
</section>
</li>
<li>
<section class="detail" id="getImplicitTable(java.lang.String,boolean)">
<h3>getImplicitTable</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getImplicitTable</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;tableName,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a table with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.schema.Table)"><code>add(String, Table)</code></a>), or null.</div>
</section>
</li>
<li>
<section class="detail" id="getImplicitType(java.lang.String,boolean)">
<h3>getImplicitType</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></span>&nbsp;<span class="element-name">getImplicitType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a type with a given name that is defined implicitly
 (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object, not explicitly
 by a call to <a href="#add(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)"><code>add(String, RelProtoDataType)</code></a>), or null.</div>
</section>
</li>
<li>
<section class="detail" id="getImplicitTableBasedOnNullaryFunction(java.lang.String,boolean)">
<h3>getImplicitTableBasedOnNullaryFunction</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getImplicitTableBasedOnNullaryFunction</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;tableName,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns table function with a given name and zero arguments that is
 defined implicitly (that is, by the underlying <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema"><code>Schema</code></a> object,
 not explicitly by a call to <code>add(String, Function)</code>), or null.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitSubSchemaToBuilder(com.google.common.collect.ImmutableSortedMap.Builder)">
<h3>addImplicitSubSchemaToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitSubSchemaToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableSortedMap.Builder&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>,<wbr><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;&nbsp;builder)</span></div>
<div class="block">Adds implicit sub-schemas to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitTableToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)">
<h3>addImplicitTableToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitTableToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</span></div>
<div class="block">Adds implicit tables to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitFunctionsToBuilder(com.google.common.collect.ImmutableList.Builder,java.lang.String,boolean)">
<h3>addImplicitFunctionsToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitFunctionsToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableList.Builder&lt;<a href="../schema/Function.html" title="interface in org.apache.calcite.schema">Function</a>&gt;&nbsp;builder,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Adds implicit functions to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitFuncNamesToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)">
<h3>addImplicitFuncNamesToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitFuncNamesToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</span></div>
<div class="block">Adds implicit function names to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitTypeNamesToBuilder(com.google.common.collect.ImmutableSortedSet.Builder)">
<h3>addImplicitTypeNamesToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitTypeNamesToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableSortedSet.Builder&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;builder)</span></div>
<div class="block">Adds implicit type names to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="addImplicitTablesBasedOnNullaryFunctionsToBuilder(com.google.common.collect.ImmutableSortedMap.Builder)">
<h3>addImplicitTablesBasedOnNullaryFunctionsToBuilder</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addImplicitTablesBasedOnNullaryFunctionsToBuilder</span><wbr><span class="parameters">(com.google.common.collect.ImmutableSortedMap.Builder&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>,<wbr><a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&gt;&nbsp;builder)</span></div>
<div class="block">Adds implicit table functions to a builder.</div>
</section>
</li>
<li>
<section class="detail" id="snapshot(org.apache.calcite.jdbc.CalciteSchema,org.apache.calcite.schema.SchemaVersion)">
<h3>snapshot</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">snapshot</span><wbr><span class="parameters">(@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&nbsp;parent,
 <a href="../schema/SchemaVersion.html" title="interface in org.apache.calcite.schema">SchemaVersion</a>&nbsp;version)</span></div>
<div class="block">Returns a snapshot representation of this CalciteSchema.</div>
</section>
</li>
<li>
<section class="detail" id="isCacheEnabled()">
<h3>isCacheEnabled</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isCacheEnabled</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setCache(boolean)">
<h3>setCache</h3>
<div class="member-signature"><span class="modifiers">public abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setCache</span><wbr><span class="parameters">(boolean&nbsp;cache)</span></div>
</section>
</li>
<li>
<section class="detail" id="tableEntry(java.lang.String,org.apache.calcite.schema.Table)">
<h3>tableEntry</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="CalciteSchema.TableEntryImpl.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntryImpl</a></span>&nbsp;<span class="element-name">tableEntry</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table)</span></div>
<div class="block">Creates a TableEntryImpl with no SQLs.</div>
</section>
</li>
<li>
<section class="detail" id="typeEntry(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)">
<h3>typeEntry</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="CalciteSchema.TypeEntryImpl.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntryImpl</a></span>&nbsp;<span class="element-name">typeEntry</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</a>&nbsp;relProtoDataType)</span></div>
<div class="block">Creates a TableEntryImpl with no SQLs.</div>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.String,org.apache.calcite.schema.Table)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">add</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;tableName,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table)</span></div>
<div class="block">Defines a table within this schema.</div>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.String,org.apache.calcite.schema.Table,com.google.common.collect.ImmutableList)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">add</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;tableName,
 <a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&nbsp;table,
 com.google.common.collect.ImmutableList&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;sqls)</span></div>
<div class="block">Defines a table within this schema.</div>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.String,org.apache.calcite.rel.type.RelProtoDataType)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../rel/type/RelProtoDataType.html" title="interface in org.apache.calcite.rel.type">RelProtoDataType</a>&nbsp;type)</span></div>
<div class="block">Defines a type within this schema.</div>
</section>
</li>
<li>
<section class="detail" id="root()">
<h3>root</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">root</span>()</div>
</section>
</li>
<li>
<section class="detail" id="isRoot()">
<h3>isRoot</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isRoot</span>()</div>
<div class="block">Returns whether this is a root schema.</div>
</section>
</li>
<li>
<section class="detail" id="path(java.lang.String)">
<h3>path</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/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">path</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;name)</span></div>
<div class="block">Returns the path of an object in this schema.</div>
</section>
</li>
<li>
<section class="detail" id="getSubSchema(java.lang.String,boolean)">
<h3>getSubSchema</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">getSubSchema</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;schemaName,
 boolean&nbsp;caseSensitive)</span></div>
</section>
</li>
<li>
<section class="detail" id="add(java.lang.String,org.apache.calcite.schema.Schema)">
<h3>add</h3>
<div class="member-signature"><span class="modifiers">public abstract</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">add</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema)</span></div>
<div class="block">Adds a child schema of this schema.</div>
</section>
</li>
<li>
<section class="detail" id="getTableBySql(java.lang.String)">
<h3>getTableBySql</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getTableBySql</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;sql)</span></div>
<div class="block">Returns a table that materializes the given SQL statement.</div>
</section>
</li>
<li>
<section class="detail" id="getTable(java.lang.String,boolean)">
<h3>getTable</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getTable</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;tableName,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a table with the given name. Does not look for views.</div>
</section>
</li>
<li>
<section class="detail" id="getName()">
<h3>getName</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">getName</span>()</div>
</section>
</li>
<li>
<section class="detail" id="plus()">
<h3>plus</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../schema/SchemaPlus.html" title="interface in org.apache.calcite.schema">SchemaPlus</a></span>&nbsp;<span class="element-name">plus</span>()</div>
</section>
</li>
<li>
<section class="detail" id="from(org.apache.calcite.schema.SchemaPlus)">
<h3>from</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">from</span><wbr><span class="parameters">(<a href="../schema/SchemaPlus.html" title="interface in org.apache.calcite.schema">SchemaPlus</a>&nbsp;plus)</span></div>
</section>
</li>
<li>
<section class="detail" id="getPath()">
<h3>getPath</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/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends <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;&gt;</span>&nbsp;<span class="element-name">getPath</span>()</div>
<div class="block">Returns the default path resolving functions from this schema.

 <p>The path consists is a list of lists of strings.
 Each list of strings represents the path of a schema from the root schema.
 For example, [[], [foo], [foo, bar, baz]] represents three schemas: the
 root schema "/" (level 0), "/foo" (level 1) and "/foo/bar/baz" (level 3).</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>Path of this schema; never null, may be empty</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSubSchemaMap()">
<h3>getSubSchemaMap</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/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a>&gt;</span>&nbsp;<span class="element-name">getSubSchemaMap</span>()</div>
<div class="block">Returns a collection of sub-schemas, both explicit (defined using
 <a href="#add(java.lang.String,org.apache.calcite.schema.Schema)"><code>add(String, org.apache.calcite.schema.Schema)</code></a>) and implicit
 (defined using <a href="../schema/Schema.html#getSubSchemaNames()"><code>Schema.getSubSchemaNames()</code></a>
 and <a href="../schema/Schema.html#getSubSchema(java.lang.String)"><code>Schema.getSubSchema(String)</code></a>).</div>
</section>
</li>
<li>
<section class="detail" id="getLatticeMap()">
<h3>getLatticeMap</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/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="CalciteSchema.LatticeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.LatticeEntry</a>&gt;</span>&nbsp;<span class="element-name">getLatticeMap</span>()</div>
<div class="block">Returns a collection of lattices.

 <p>All are explicit (defined using <code>add(String, Lattice)</code>).</div>
</section>
</li>
<li>
<section class="detail" id="getTableNames()">
<h3>getTableNames</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/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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">getTableNames</span>()</div>
<div class="block">Returns the set of all table names. Includes implicit and explicit tables
 and functions with zero parameters.</div>
</section>
</li>
<li>
<section class="detail" id="getTypeNames()">
<h3>getTypeNames</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/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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">getTypeNames</span>()</div>
<div class="block">Returns the set of all types names.</div>
</section>
</li>
<li>
<section class="detail" id="getType(java.lang.String,boolean)">
<h3>getType</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TypeEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TypeEntry</a></span>&nbsp;<span class="element-name">getType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a type, explicit and implicit, with a given
 name. Never null.</div>
</section>
</li>
<li>
<section class="detail" id="getFunctions(java.lang.String,boolean)">
<h3>getFunctions</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/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../schema/Function.html" title="interface in org.apache.calcite.schema">Function</a>&gt;</span>&nbsp;<span class="element-name">getFunctions</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a collection of all functions, explicit and implicit, with a given
 name. Never null.</div>
</section>
</li>
<li>
<section class="detail" id="getFunctionNames()">
<h3>getFunctionNames</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/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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">getFunctionNames</span>()</div>
<div class="block">Returns the list of function names in this schema, both implicit and
 explicit, never null.</div>
</section>
</li>
<li>
<section class="detail" id="getTablesBasedOnNullaryFunctions()">
<h3>getTablesBasedOnNullaryFunctions</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/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr><a href="../schema/Table.html" title="interface in org.apache.calcite.schema">Table</a>&gt;</span>&nbsp;<span class="element-name">getTablesBasedOnNullaryFunctions</span>()</div>
<div class="block">Returns tables derived from explicit and implicit functions
 that take zero parameters.</div>
</section>
</li>
<li>
<section class="detail" id="getTableBasedOnNullaryFunction(java.lang.String,boolean)">
<h3>getTableBasedOnNullaryFunction</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">@Nullable <a href="CalciteSchema.TableEntry.html" title="class in org.apache.calcite.jdbc">CalciteSchema.TableEntry</a></span>&nbsp;<span class="element-name">getTableBasedOnNullaryFunction</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;tableName,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Returns a tables derived from explicit and implicit functions
 that take zero parameters.</div>
</section>
</li>
<li>
<section class="detail" id="createSnapshot(org.apache.calcite.schema.SchemaVersion)">
<h3>createSnapshot</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">createSnapshot</span><wbr><span class="parameters">(<a href="../schema/SchemaVersion.html" title="interface in org.apache.calcite.schema">SchemaVersion</a>&nbsp;version)</span></div>
<div class="block">Creates a snapshot of this CalciteSchema as of the specified time. All
 explicit objects in this CalciteSchema will be copied into the snapshot
 CalciteSchema, while the contents of the snapshot of the underlying schema
 should not change as specified in <a href="../schema/Schema.html#snapshot(org.apache.calcite.schema.SchemaVersion)"><code>Schema.snapshot(SchemaVersion)</code></a>.
 Snapshots of explicit sub schemas will be created and copied recursively.

 <p>Currently, to accommodate the requirement of creating tables on the fly
 for materializations, the snapshot will still use the same table map and
 lattice map as in the original CalciteSchema instead of making copies.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>version</code> - The current schema version</dd>
<dt>Returns:</dt>
<dd>the schema snapshot.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="find(java.util.NavigableMap,java.lang.String)">
<h3>find</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">protected static</span>&nbsp;<span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr>V&gt;</span>&nbsp;<span class="element-name">find</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableMap.html" title="class or interface in java.util" class="external-link">NavigableMap</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>,<wbr>V&gt;&nbsp;map,
 <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="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use NameMap</div>
</div>
<div class="block">Returns a subset of a map whose keys match the given string
 case-insensitively.</div>
</section>
</li>
<li>
<section class="detail" id="find(java.util.NavigableSet,java.lang.String)">
<h3>find</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">protected static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<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">find</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/NavigableSet.html" title="class or interface in java.util" class="external-link">NavigableSet</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;set,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">use NameSet</div>
</div>
<div class="block">Returns a subset of a set whose values match the given string
 case-insensitively.</div>
</section>
</li>
<li>
<section class="detail" id="createRootSchema(boolean)">
<h3>createRootSchema</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">createRootSchema</span><wbr><span class="parameters">(boolean&nbsp;addMetadataSchema)</span></div>
<div class="block">Creates a root schema.

 <p>When <code>addMetadataSchema</code> argument is true adds a "metadata"
 schema containing definitions of tables, columns etc. to root schema.
 By default, creates a <code>CachingCalciteSchema</code>.</div>
</section>
</li>
<li>
<section class="detail" id="createRootSchema(boolean,boolean)">
<h3>createRootSchema</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">createRootSchema</span><wbr><span class="parameters">(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache)</span></div>
<div class="block">Creates a root schema.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>addMetadataSchema</code> - Whether to add a "metadata" schema containing
              definitions of tables, columns etc.</dd>
<dd><code>cache</code> - If true create <code>CachingCalciteSchema</code>;
                if false create <code>SimpleCalciteSchema</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createRootSchema(boolean,boolean,java.lang.String)">
<h3>createRootSchema</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">createRootSchema</span><wbr><span class="parameters">(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Creates a root schema.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>addMetadataSchema</code> - Whether to add a "metadata" schema containing
              definitions of tables, columns etc.</dd>
<dd><code>cache</code> - If true create <code>CachingCalciteSchema</code>;
                if false create <code>SimpleCalciteSchema</code></dd>
<dd><code>name</code> - Schema name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createRootSchema(boolean,boolean,java.lang.String,org.apache.calcite.schema.Schema)">
<h3>createRootSchema</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="CalciteSchema.html" title="class in org.apache.calcite.jdbc">CalciteSchema</a></span>&nbsp;<span class="element-name">createRootSchema</span><wbr><span class="parameters">(boolean&nbsp;addMetadataSchema,
 boolean&nbsp;cache,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name,
 <a href="../schema/Schema.html" title="interface in org.apache.calcite.schema">Schema</a>&nbsp;schema)</span></div>
</section>
</li>
<li>
<section class="detail" id="removeSubSchema(java.lang.String)">
<h3>removeSubSchema</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">removeSubSchema</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
</section>
</li>
<li>
<section class="detail" id="removeTable(java.lang.String)">
<h3>removeTable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">removeTable</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
</section>
</li>
<li>
<section class="detail" id="removeFunction(java.lang.String)">
<h3>removeFunction</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">removeFunction</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
</section>
</li>
<li>
<section class="detail" id="removeType(java.lang.String)">
<h3>removeType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">removeType</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
</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>
