TableEnvironmentImpl (Flink : Table : API Java 1.16.1 API)

java.lang.Object
- org.apache.flink.table.api.internal.TableEnvironmentImpl

All Implemented Interfaces:

TableEnvironmentInternal, TableEnvironment
```
@Internal
public class TableEnvironmentImpl
extends Object
implements TableEnvironmentInternal
```
Implementation of TableEnvironment that works exclusively with Table API interfaces. Only TableSource is supported as an input and TableSink as an output. It also does not bind to any particular StreamExecutionEnvironment.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Executor`	`execEnv`
`protected FunctionCatalog`	`functionCatalog`
`protected Planner`	`planner`
`protected ResourceManager`	`resourceManager`
`protected TableConfig`	`tableConfig`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`TableEnvironmentImpl(CatalogManager catalogManager, ModuleManager moduleManager, ResourceManager resourceManager, TableConfig tableConfig, Executor executor, FunctionCatalog functionCatalog, Planner planner, boolean isStreamingMode)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompiledPlan`	`compilePlan(List<ModifyOperation> operations)`
`CompiledPlan`	`compilePlanSql(String stmt)` Compiles a SQL DML statement into a `CompiledPlan`.
`static TableEnvironmentImpl`	`create(org.apache.flink.configuration.Configuration configuration)` Creates a table environment that is the entry point and central context for creating Table and SQL API programs.
`static TableEnvironmentImpl`	`create(EnvironmentSettings settings)` Creates a table environment that is the entry point and central context for creating Table and SQL API programs.
`void`	`createFunction(String path, Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)` Registers a `UserDefinedFunction` class as a catalog function in the given path.
`void`	`createFunction(String path, Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass, boolean ignoreIfExists)` Registers a `UserDefinedFunction` class as a catalog function in the given path.
`StatementSet`	`createStatementSet()` Returns a `StatementSet` that accepts pipelines defined by DML statements or `Table` objects.
`TableImpl`	`createTable(QueryOperation tableOperation)`
`void`	`createTable(String path, TableDescriptor descriptor)` Registers the given `TableDescriptor` as a catalog table.
`void`	`createTemporaryFunction(String path, Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)` Registers a `UserDefinedFunction` class as a temporary catalog function.
`void`	`createTemporaryFunction(String path, org.apache.flink.table.functions.UserDefinedFunction functionInstance)` Registers a `UserDefinedFunction` instance as a temporary catalog function.
`void`	`createTemporarySystemFunction(String name, Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)` Registers a `UserDefinedFunction` class as a temporary system function.
`void`	`createTemporarySystemFunction(String name, org.apache.flink.table.functions.UserDefinedFunction functionInstance)` Registers a `UserDefinedFunction` instance as a temporary system function.
`void`	`createTemporaryTable(String path, TableDescriptor descriptor)` Registers the given `TableDescriptor` as a temporary catalog table.
`void`	`createTemporaryView(String path, Table view)` Registers a `Table` API object as a temporary view similar to SQL temporary views.
`boolean`	`dropFunction(String path)` Drops a catalog function registered in the given path.
`boolean`	`dropTemporaryFunction(String path)` Drops a temporary catalog function registered in the given path.
`boolean`	`dropTemporarySystemFunction(String name)` Drops a temporary system function registered under the given name.
`boolean`	`dropTemporaryTable(String path)` Drops a temporary table registered in the given path.
`boolean`	`dropTemporaryView(String path)` Drops a temporary view registered in the given path.
`TableResultInternal`	`executeInternal(List<ModifyOperation> operations)` Execute the given modify operations and return the execution result.
`TableResultInternal`	`executeInternal(Operation operation)` Execute the given operation and return the execution result.
`TableResultInternal`	`executePlan(InternalPlan plan)`
`TableResult`	`executeSql(String statement)` Executes the given single statement and returns the execution result.
`String`	`explainInternal(List<Operation> operations, ExplainDetail... extraDetails)` Returns the AST of this table and the execution plan to compute the result of this table.
`String`	`explainPlan(InternalPlan compiledPlan, ExplainDetail... extraDetails)`
`String`	`explainSql(String statement, ExplainDetail... extraDetails)` Returns the AST of the specified statement and the execution plan to compute the result of the given statement.
`Table`	`from(String path)` Reads a registered table and returns the resulting `Table`.
`Table`	`from(TableDescriptor descriptor)` Returns a `Table` backed by the given `descriptor`.
`Table`	`fromTableSource(org.apache.flink.table.sources.TableSource<?> source)` Creates a table from a table source.
`Table`	`fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType, org.apache.flink.table.expressions.Expression... values)` Creates a Table from given collection of objects with a given row type.
`Table`	`fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType, Iterable<?> values)` Creates a Table from given collection of objects with a given row type.
`Table`	`fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType, Object... values)` Creates a Table from given collection of objects with a given row type.
`Table`	`fromValues(org.apache.flink.table.expressions.Expression... values)` Creates a Table from given values.
`Table`	`fromValues(Iterable<?> values)` Creates a Table from given collection of objects.
`Table`	`fromValues(Object... values)` Creates a Table from given values.
`Optional<org.apache.flink.table.catalog.Catalog>`	`getCatalog(String catalogName)` Gets a registered `Catalog` by name.
`CatalogManager`	`getCatalogManager()` Returns a `CatalogManager` that deals with all catalog objects.
`String[]`	`getCompletionHints(String statement, int position)` Returns completion hints for the given statement at the given cursor position.
`TableConfig`	`getConfig()` Returns the table config that defines the runtime behavior of the Table API.
`String`	`getCurrentCatalog()` Gets the current default catalog name of the current session.
`String`	`getCurrentDatabase()` Gets the current default database name of the running session.
`ExtendedOperationExecutor`	`getExtendedOperationExecutor()`
`OperationTreeBuilder`	`getOperationTreeBuilder()` Returns a `OperationTreeBuilder` that can create `QueryOperation`s.
`Parser`	`getParser()` Return a `Parser` that provides methods for parsing a SQL string.
`Planner`	`getPlanner()`
`String[]`	`listCatalogs()` Gets the names of all catalogs registered in this environment.
`String[]`	`listDatabases()` Gets the names of all databases registered in the current catalog.
`ModuleEntry[]`	`listFullModules()` Gets an array of all loaded modules with use status in this environment.
`String[]`	`listFunctions()` Gets the names of all functions in this environment.
`String[]`	`listModules()` Gets an array of names of all used modules in this environment in resolution order.
`String[]`	`listTables()` Gets the names of all tables available in the current namespace (the current database of the current catalog).
`String[]`	`listTables(String catalog, String databaseName)` Gets the names of all tables available in the given namespace (the given database of the given catalog).
`String[]`	`listTemporaryTables()` Gets the names of all temporary tables and views available in the current namespace (the current database of the current catalog).
`String[]`	`listTemporaryViews()` Gets the names of all temporary views available in the current namespace (the current database of the current catalog).
`String[]`	`listUserDefinedFunctions()` Gets the names of all user defined functions registered in this environment.
`String[]`	`listViews()` Gets the names of all views available in the current namespace (the current database of the current catalog).
`void`	`loadModule(String moduleName, org.apache.flink.table.module.Module module)` Loads a `Module` under a unique name.
`CompiledPlan`	`loadPlan(PlanReference planReference)` Loads a plan from a `PlanReference` into a `CompiledPlan`.
`protected QueryOperation`	`qualifyQueryOperation(org.apache.flink.table.catalog.ObjectIdentifier identifier, QueryOperation queryOperation)` Subclasses can override this method to transform the given QueryOperation to a new one with the qualified object identifier.
`void`	`registerCatalog(String catalogName, org.apache.flink.table.catalog.Catalog catalog)` Registers a `Catalog` under a unique name.
`void`	`registerFunction(String name, org.apache.flink.table.functions.ScalarFunction function)` Registers a `ScalarFunction` under a unique name.
`void`	`registerTable(String name, Table table)` Registers a `Table` under a unique name in the TableEnvironment's catalog.
`void`	`registerTableSinkInternal(String name, org.apache.flink.table.sinks.TableSink<?> tableSink)` Registers an external `TableSink` with already configured field names and field types in this `TableEnvironment`'s catalog.
`void`	`registerTableSourceInternal(String name, org.apache.flink.table.sources.TableSource<?> tableSource)` Registers an external `TableSource` in this `TableEnvironment`'s catalog.
`Table`	`scan(String... tablePath)` Scans a registered table and returns the resulting `Table`.
`Table`	`sqlQuery(String query)` Evaluates a SQL query on registered tables and returns a `Table` object describing the pipeline for further transformations.
`protected List<org.apache.flink.api.dag.Transformation<?>>`	`translate(List<ModifyOperation> modifyOperations)`
`void`	`unloadModule(String moduleName)` Unloads a `Module` with given name.
`void`	`useCatalog(String catalogName)` Sets the current catalog to the given value.
`void`	`useDatabase(String databaseName)` Sets the current default database.
`void`	`useModules(String... moduleNames)` Enable modules in use with declared name order.
`protected void`	`validateTableSource(org.apache.flink.table.sources.TableSource<?> tableSource)` Subclasses can override this method to add additional checks.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.flink.table.api.TableEnvironment
executePlan

Field Detail

resourceManager

protected final ResourceManager resourceManager

tableConfig

protected final TableConfig tableConfig

execEnv
```
protected final Executor execEnv
```

functionCatalog

protected final FunctionCatalog functionCatalog

planner
```
protected final Planner planner
```

Constructor Detail

TableEnvironmentImpl

protected TableEnvironmentImpl(CatalogManager catalogManager,
                               ModuleManager moduleManager,
                               ResourceManager resourceManager,
                               TableConfig tableConfig,
                               Executor executor,
                               FunctionCatalog functionCatalog,
                               Planner planner,
                               boolean isStreamingMode)

Method Detail

create
```
public static TableEnvironmentImpl create(org.apache.flink.configuration.Configuration configuration)
```
Description copied from interface: TableEnvironment
Creates a table environment that is the entry point and central context for creating Table and SQL API programs.
It is unified both on a language level for all JVM-based languages (i.e. there is no distinction between Scala and Java API) and for bounded and unbounded data processing.
A table environment is responsible for:
- Connecting to external systems.
- Registering and retrieving Tables and other meta objects from a catalog.
- Executing SQL statements.
- Offering further configuration options.
Note: This environment is meant for pure table programs. If you would like to convert from or to other Flink APIs, it might be necessary to use one of the available language-specific table environments in the corresponding bridging modules.
Specified by:

create in interface TableEnvironment

Parameters:

configuration - The specified options are used to instantiate the TableEnvironment.

create
```
public static TableEnvironmentImpl create(EnvironmentSettings settings)
```
Description copied from interface: TableEnvironment
Creates a table environment that is the entry point and central context for creating Table and SQL API programs.
It is unified both on a language level for all JVM-based languages (i.e. there is no distinction between Scala and Java API) and for bounded and unbounded data processing.
A table environment is responsible for:
- Connecting to external systems.
- Registering and retrieving Tables and other meta objects from a catalog.
- Executing SQL statements.
- Offering further configuration options.
Note: This environment is meant for pure table programs. If you would like to convert from or to other Flink APIs, it might be necessary to use one of the available language-specific table environments in the corresponding bridging modules.
Specified by:

create in interface TableEnvironment

Parameters:

settings - The environment settings used to instantiate the TableEnvironment.

fromValues
```
public Table fromValues(Object... values)
```
Description copied from interface: TableEnvironment
Creates a Table from given values.
Examples:
You can use a row(...) expression to create a composite rows:
```
 tEnv.fromValues(
     row(1, "ABC"),
     row(2L, "ABCDE")
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- f0: BIGINT NOT NULL     // original types INT and BIGINT are generalized to BIGINT
 |-- f1: VARCHAR(5) NOT NULL // original types CHAR(3) and CHAR(5) are generalized to VARCHAR(5)
                             // it uses VARCHAR instead of CHAR so that no padding is applied
 
```
The method will derive the types automatically from the input expressions. If types at a certain position differ, the method will try to find a common super type for all types. If a common super type does not exist, an exception will be thrown. If you want to specify the requested type explicitly see TableEnvironment.fromValues(AbstractDataType, Object...).
It is also possible to use Row object instead of row expressions.
ROWs that are a result of e.g. a function call are not flattened
```
 public class RowFunction extends ScalarFunction {
     {@literal @}DataTypeHint("ROW<f0 BIGINT, f1 VARCHAR(5)>")
     Row eval();
 }

 tEnv.fromValues(
     call(new RowFunction()),
     call(new RowFunction())
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- f0: ROW<`f0` BIGINT, `f1` VARCHAR(5)>
 
```
The row constructor can be dropped to create a table with a single column:
ROWs that are a result of e.g. a function call are not flattened
```
 tEnv.fromValues(
     1,
     2L,
     3
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- f0: BIGINT NOT NULL
 
```
Specified by:

fromValues in interface TableEnvironment

Parameters:

values - Expressions for constructing rows of the VALUES table.

fromValues
```
public Table fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType,
                        Object... values)
```
Description copied from interface: TableEnvironment
Creates a Table from given collection of objects with a given row type.
The difference between this method and TableEnvironment.fromValues(Object...) is that the schema can be manually adjusted. It might be helpful for assigning more generic types like e.g. DECIMAL or naming the columns.
Examples:
```
 tEnv.fromValues(
     DataTypes.ROW(
         DataTypes.FIELD("id", DataTypes.DECIMAL(10, 2)),
         DataTypes.FIELD("name", DataTypes.STRING())
     ),
     row(1, "ABC"),
     row(2L, "ABCDE")
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- id: DECIMAL(10, 2)
 |-- name: STRING
 
```
For more examples see TableEnvironment.fromValues(Object...).
Specified by:

fromValues in interface TableEnvironment

Parameters:

rowType - Expected row type for the values.

values - Expressions for constructing rows of the VALUES table.

See Also:

TableEnvironment.fromValues(Object...)

fromValues
```
public Table fromValues(org.apache.flink.table.expressions.Expression... values)
```
Description copied from interface: TableEnvironment
Creates a Table from given values.
Examples:
You can use a row(...) expression to create a composite rows:
```
 tEnv.fromValues(
     row(1, "ABC"),
     row(2L, "ABCDE")
 )
 
```
will produce a Table with a schema as follows:
```
  root
  |-- f0: BIGINT NOT NULL     // original types INT and BIGINT are generalized to BIGINT
  |-- f1: VARCHAR(5) NOT NULL // original types CHAR(3) and CHAR(5) are generalized to VARCHAR(5)
 	 *                          // it uses VARCHAR instead of CHAR so that no padding is applied
 
```
The method will derive the types automatically from the input expressions. If types at a certain position differ, the method will try to find a common super type for all types. If a common super type does not exist, an exception will be thrown. If you want to specify the requested type explicitly see TableEnvironment.fromValues(AbstractDataType, Expression...).
It is also possible to use Row object instead of row expressions.
ROWs that are a result of e.g. a function call are not flattened
```
 public class RowFunction extends ScalarFunction {
     {@literal @}DataTypeHint("ROW<f0 BIGINT, f1 VARCHAR(5)>")
     Row eval();
 }

 tEnv.fromValues(
     call(new RowFunction()),
     call(new RowFunction())
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- f0: ROW<`f0` BIGINT, `f1` VARCHAR(5)>
 
```
The row constructor can be dropped to create a table with a single column:
ROWs that are a result of e.g. a function call are not flattened
```
 tEnv.fromValues(
     lit(1).plus(2),
     lit(2L),
     lit(3)
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- f0: BIGINT NOT NULL
 
```
Specified by:

fromValues in interface TableEnvironment

Parameters:

values - Expressions for constructing rows of the VALUES table.

fromValues
```
public Table fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType,
                        org.apache.flink.table.expressions.Expression... values)
```
Description copied from interface: TableEnvironment
Creates a Table from given collection of objects with a given row type.
The difference between this method and TableEnvironment.fromValues(Expression...) is that the schema can be manually adjusted. It might be helpful for assigning more generic types like e.g. DECIMAL or naming the columns.
Examples:
```
 tEnv.fromValues(
     DataTypes.ROW(
         DataTypes.FIELD("id", DataTypes.DECIMAL(10, 2)),
         DataTypes.FIELD("name", DataTypes.STRING())
     ),
     row(1, "ABC"),
     row(2L, "ABCDE")
 )
 
```
will produce a Table with a schema as follows:
```
 root
 |-- id: DECIMAL(10, 2)
 |-- name: STRING
 
```
For more examples see TableEnvironment.fromValues(Expression...).
Specified by:

fromValues in interface TableEnvironment

Parameters:

rowType - Expected row type for the values.

values - Expressions for constructing rows of the VALUES table.

See Also:

TableEnvironment.fromValues(Expression...)

fromValues
```
public Table fromValues(Iterable<?> values)
```
Description copied from interface: TableEnvironment

Creates a Table from given collection of objects.
See TableEnvironment.fromValues(Object...) for more explanation.

Specified by:

fromValues in interface TableEnvironment

Parameters:

values - Expressions for constructing rows of the VALUES table.

See Also:

TableEnvironment.fromValues(Object...)

fromValues
```
public Table fromValues(org.apache.flink.table.types.AbstractDataType<?> rowType,
                        Iterable<?> values)
```
Description copied from interface: TableEnvironment

Creates a Table from given collection of objects with a given row type.
See TableEnvironment.fromValues(AbstractDataType, Object...) for more explanation.

Specified by:

fromValues in interface TableEnvironment

Parameters:

rowType - Expected row type for the values.

values - Expressions for constructing rows of the VALUES table.

See Also:

TableEnvironment.fromValues(AbstractDataType, Object...)

getPlanner

@VisibleForTesting
public Planner getPlanner()

fromTableSource
```
public Table fromTableSource(org.apache.flink.table.sources.TableSource<?> source)
```
Description copied from interface: TableEnvironmentInternal

Creates a table from a table source.

Specified by:

fromTableSource in interface TableEnvironmentInternal

Parameters:

source - table source used as table

registerCatalog
```
public void registerCatalog(String catalogName,
                            org.apache.flink.table.catalog.Catalog catalog)
```
Description copied from interface: TableEnvironment

Registers a Catalog under a unique name. All tables registered in the Catalog can be accessed.

Specified by:

registerCatalog in interface TableEnvironment

Parameters:

catalogName - The name under which the catalog will be registered.

catalog - The catalog to register.

getCatalog
```
public Optional<org.apache.flink.table.catalog.Catalog> getCatalog(String catalogName)
```
Description copied from interface: TableEnvironment

Gets a registered Catalog by name.

Specified by:

getCatalog in interface TableEnvironment

Parameters:

catalogName - The name to look up the Catalog.

Returns:

The requested catalog, empty if there is no registered catalog with given name.

loadModule
```
public void loadModule(String moduleName,
                       org.apache.flink.table.module.Module module)
```
Description copied from interface: TableEnvironment

Loads a Module under a unique name. Modules will be kept in the loaded order. ValidationException is thrown when there is already a module with the same name.

Specified by:

loadModule in interface TableEnvironment

Parameters:

moduleName - name of the Module

module - the module instance

useModules
```
public void useModules(String... moduleNames)
```
Description copied from interface: TableEnvironment

Enable modules in use with declared name order. Modules that have been loaded but not exist in names varargs will become unused.

Specified by:

useModules in interface TableEnvironment

Parameters:

moduleNames - module names to be used

unloadModule
```
public void unloadModule(String moduleName)
```
Description copied from interface: TableEnvironment

Unloads a Module with given name. ValidationException is thrown when there is no module with the given name.

Specified by:

unloadModule in interface TableEnvironment

Parameters:

moduleName - name of the Module

registerFunction
```
public void registerFunction(String name,
                             org.apache.flink.table.functions.ScalarFunction function)
```
Description copied from interface: TableEnvironment

Registers a ScalarFunction under a unique name. Replaces already existing user-defined functions under this name.

Specified by:

registerFunction in interface TableEnvironment

createTemporarySystemFunction
```
public void createTemporarySystemFunction(String name,
                                          Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction class as a temporary system function.
Compared to TableEnvironment.createTemporaryFunction(String, Class), system functions are identified by a global name that is independent of the current catalog and current database. Thus, this method allows to extend the set of built-in system functions like TRIM, ABS, etc.
Temporary functions can shadow permanent ones. If a permanent function under a given name exists, it will be inaccessible in the current session. To make the permanent function available again one can drop the corresponding temporary system function.

Specified by:

createTemporarySystemFunction in interface TableEnvironment

Parameters:

name - The name under which the function will be registered globally.

functionClass - The function class containing the implementation.

createTemporarySystemFunction
```
public void createTemporarySystemFunction(String name,
                                          org.apache.flink.table.functions.UserDefinedFunction functionInstance)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction instance as a temporary system function.
Compared to TableEnvironment.createTemporarySystemFunction(String, Class), this method takes a function instance that might have been parameterized before (e.g. through its constructor). This might be useful for more interactive sessions. Make sure that the instance is Serializable.
Compared to TableEnvironment.createTemporaryFunction(String, UserDefinedFunction), system functions are identified by a global name that is independent of the current catalog and current database. Thus, this method allows to extend the set of built-in system functions like TRIM, ABS, etc.
Temporary functions can shadow permanent ones. If a permanent function under a given name exists, it will be inaccessible in the current session. To make the permanent function available again one can drop the corresponding temporary system function.

Specified by:

createTemporarySystemFunction in interface TableEnvironment

Parameters:

name - The name under which the function will be registered globally.

functionInstance - The (possibly pre-configured) function instance containing the implementation.

dropTemporarySystemFunction
```
public boolean dropTemporarySystemFunction(String name)
```
Description copied from interface: TableEnvironment

Drops a temporary system function registered under the given name.
If a permanent function with the given name exists, it will be used from now on for any queries that reference this name.

Specified by:

dropTemporarySystemFunction in interface TableEnvironment

Parameters:

name - The name under which the function has been registered globally.

Returns:

true if a function existed under the given name and was removed

createFunction
```
public void createFunction(String path,
                           Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction class as a catalog function in the given path.
Compared to system functions with a globally defined name, catalog functions are always (implicitly or explicitly) identified by a catalog and database.
There must not be another function (temporary or permanent) registered under the same path.

Specified by:

createFunction in interface TableEnvironment

Parameters:

path - The path under which the function will be registered. See also the TableEnvironment class description for the format of the path.

functionClass - The function class containing the implementation.

createFunction
```
public void createFunction(String path,
                           Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass,
                           boolean ignoreIfExists)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction class as a catalog function in the given path.
Compared to system functions with a globally defined name, catalog functions are always (implicitly or explicitly) identified by a catalog and database.

Specified by:

createFunction in interface TableEnvironment

Parameters:

path - The path under which the function will be registered. See also the TableEnvironment class description for the format of the path.

functionClass - The function class containing the implementation.

ignoreIfExists - If a function exists under the given path and this flag is set, no operation is executed. An exception is thrown otherwise.

dropFunction
```
public boolean dropFunction(String path)
```
Description copied from interface: TableEnvironment

Drops a catalog function registered in the given path.

Specified by:

dropFunction in interface TableEnvironment

Parameters:

path - The path under which the function has been registered. See also the TableEnvironment class description for the format of the path.

Returns:

true if a function existed in the given path and was removed

createTemporaryFunction
```
public void createTemporaryFunction(String path,
                                    Class<? extends org.apache.flink.table.functions.UserDefinedFunction> functionClass)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction class as a temporary catalog function.
Compared to TableEnvironment.createTemporarySystemFunction(String, Class) with a globally defined name, catalog functions are always (implicitly or explicitly) identified by a catalog and database.
Temporary functions can shadow permanent ones. If a permanent function under a given name exists, it will be inaccessible in the current session. To make the permanent function available again one can drop the corresponding temporary function.

Specified by:

createTemporaryFunction in interface TableEnvironment

Parameters:

path - The path under which the function will be registered. See also the TableEnvironment class description for the format of the path.

functionClass - The function class containing the implementation.

createTemporaryFunction
```
public void createTemporaryFunction(String path,
                                    org.apache.flink.table.functions.UserDefinedFunction functionInstance)
```
Description copied from interface: TableEnvironment

Registers a UserDefinedFunction instance as a temporary catalog function.
Compared to TableEnvironment.createTemporaryFunction(String, Class), this method takes a function instance that might have been parameterized before (e.g. through its constructor). This might be useful for more interactive sessions. Make sure that the instance is Serializable.
Compared to TableEnvironment.createTemporarySystemFunction(String, UserDefinedFunction) with a globally defined name, catalog functions are always (implicitly or explicitly) identified by a catalog and database.
Temporary functions can shadow permanent ones. If a permanent function under a given name exists, it will be inaccessible in the current session. To make the permanent function available again one can drop the corresponding temporary function.

Specified by:

createTemporaryFunction in interface TableEnvironment

Parameters:

path - The path under which the function will be registered. See also the TableEnvironment class description for the format of the path.

functionInstance - The (possibly pre-configured) function instance containing the implementation.

dropTemporaryFunction
```
public boolean dropTemporaryFunction(String path)
```
Description copied from interface: TableEnvironment

Drops a temporary catalog function registered in the given path.
If a permanent function with the given path exists, it will be used from now on for any queries that reference this path.

Specified by:

dropTemporaryFunction in interface TableEnvironment

Parameters:

path - The path under which the function will be registered. See also the TableEnvironment class description for the format of the path.

Returns:

true if a function existed in the given path and was removed

createTemporaryTable
```
public void createTemporaryTable(String path,
                                 TableDescriptor descriptor)
```
Description copied from interface: TableEnvironment
Registers the given TableDescriptor as a temporary catalog table.
The descriptor is converted into a CatalogTable and stored in the catalog.
Temporary objects can shadow permanent ones. If a permanent object in a given path exists, it will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.
Examples:
```
 tEnv.createTemporaryTable("MyTable", TableDescriptor.forConnector("datagen")
   .schema(Schema.newBuilder()
     .column("f0", DataTypes.STRING())
     .build())
   .option(DataGenOptions.ROWS_PER_SECOND, 10)
   .option("fields.f0.kind", "random")
   .build());
 
```
Specified by:

createTemporaryTable in interface TableEnvironment

Parameters:

path - The path under which the table will be registered. See also the TableEnvironment class description for the format of the path.

descriptor - Template for creating a CatalogTable instance.

createTable
```
public void createTable(String path,
                        TableDescriptor descriptor)
```
Description copied from interface: TableEnvironment
Registers the given TableDescriptor as a catalog table.
The descriptor is converted into a CatalogTable and stored in the catalog.
If the table should not be permanently stored in a catalog, use TableEnvironment.createTemporaryTable(String, TableDescriptor) instead.
Examples:
```
 tEnv.createTable("MyTable", TableDescriptor.forConnector("datagen")
   .schema(Schema.newBuilder()
     .column("f0", DataTypes.STRING())
     .build())
   .option(DataGenOptions.ROWS_PER_SECOND, 10)
   .option("fields.f0.kind", "random")
   .build());
 
```
Specified by:

createTable in interface TableEnvironment

Parameters:

path - The path under which the table will be registered. See also the TableEnvironment class description for the format of the path.

descriptor - Template for creating a CatalogTable instance.

registerTable
```
public void registerTable(String name,
                          Table table)
```
Description copied from interface: TableEnvironment

Registers a Table under a unique name in the TableEnvironment's catalog. Registered tables can be referenced in SQL queries.
Temporary objects can shadow permanent ones. If a permanent object in a given path exists, it will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

Specified by:

registerTable in interface TableEnvironment

Parameters:

name - The name under which the table will be registered.

table - The table to register.

createTemporaryView
```
public void createTemporaryView(String path,
                                Table view)
```
Description copied from interface: TableEnvironment

Registers a Table API object as a temporary view similar to SQL temporary views.
Temporary objects can shadow permanent ones. If a permanent object in a given path exists, it will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

Specified by:

createTemporaryView in interface TableEnvironment

Parameters:

path - The path under which the view will be registered. See also the TableEnvironment class description for the format of the path.

view - The view to register.

scan
```
public Table scan(String... tablePath)
```
Description copied from interface: TableEnvironment
Scans a registered table and returns the resulting Table.
A table to scan must be registered in the TableEnvironment. It can be either directly registered or be an external member of a Catalog.
See the documentation of TableEnvironment.useDatabase(String) or TableEnvironment.useCatalog(String) for the rules on the path resolution.
Examples:
Scanning a directly registered table.
```
 Table tab = tableEnv.scan("tableName");
 
```
Scanning a table from a registered catalog.
```
 Table tab = tableEnv.scan("catalogName", "dbName", "tableName");
 
```
Specified by:

scan in interface TableEnvironment

Parameters:

tablePath - The path of the table to scan.

Returns:

The resulting Table.

See Also:

TableEnvironment.useCatalog(String), TableEnvironment.useDatabase(String)

from
```
public Table from(String path)
```
Description copied from interface: TableEnvironment
Reads a registered table and returns the resulting Table.
A table to scan must be registered in the TableEnvironment.
See the documentation of TableEnvironment.useDatabase(String) or TableEnvironment.useCatalog(String) for the rules on the path resolution.
Examples:
Reading a table from default catalog and database.
```
 Table tab = tableEnv.from("tableName");
 
```
Reading a table from a registered catalog.
```
 Table tab = tableEnv.from("catalogName.dbName.tableName");
 
```
Reading a table from a registered catalog with escaping. Dots in e.g. a database name must be escaped.
```
 Table tab = tableEnv.from("catalogName.`db.Name`.Table");
 
```
Note that the returned Table is an API object and only contains a pipeline description. It actually corresponds to a view in SQL terms. Call Executable.execute() to trigger an execution.
Specified by:

from in interface TableEnvironment

Parameters:

path - The path of a table API object to scan.

Returns:

The Table object describing the pipeline for further transformations.

See Also:

TableEnvironment.useCatalog(String), TableEnvironment.useDatabase(String)

from
```
public Table from(TableDescriptor descriptor)
```
Description copied from interface: TableEnvironment
Returns a Table backed by the given descriptor.
The descriptor won't be registered in the catalog, but it will be propagated directly in the operation tree. Note that calling this method multiple times, even with the same descriptor, results in multiple temporary tables. In such cases, it is recommended to register it under a name using TableEnvironment.createTemporaryTable(String, TableDescriptor) and reference it via TableEnvironment.from(String).
Examples:
```
 Table table = tEnv.from(TableDescriptor.forConnector("datagen")
   .schema(Schema.newBuilder()
     .column("f0", DataTypes.STRING())
     .build())
   .build());
 
```
Note that the returned Table is an API object and only contains a pipeline description. It actually corresponds to a view in SQL terms. Call Executable.execute() to trigger an execution.
Specified by:

from in interface TableEnvironment

Returns:

The Table object describing the pipeline for further transformations.

listCatalogs
```
public String[] listCatalogs()
```
Description copied from interface: TableEnvironment

Gets the names of all catalogs registered in this environment.

Specified by:

listCatalogs in interface TableEnvironment

Returns:

A list of the names of all registered catalogs.

listModules
```
public String[] listModules()
```
Description copied from interface: TableEnvironment

Gets an array of names of all used modules in this environment in resolution order.

Specified by:

listModules in interface TableEnvironment

Returns:

A list of the names of used modules in resolution order.

listFullModules
```
public ModuleEntry[] listFullModules()
```
Description copied from interface: TableEnvironment

Gets an array of all loaded modules with use status in this environment. Used modules are kept in resolution order.

Specified by:

listFullModules in interface TableEnvironment

Returns:

A list of name and use status entries of all loaded modules.

listDatabases
```
public String[] listDatabases()
```
Description copied from interface: TableEnvironment

Gets the names of all databases registered in the current catalog.

Specified by:

listDatabases in interface TableEnvironment

Returns:

A list of the names of all registered databases in the current catalog.

listTables
```
public String[] listTables()
```
Description copied from interface: TableEnvironment

Gets the names of all tables available in the current namespace (the current database of the current catalog). It returns both temporary and permanent tables and views.

Specified by:

listTables in interface TableEnvironment

Returns:

A list of the names of all registered tables in the current database of the current catalog.

See Also:

TableEnvironment.listTemporaryTables(), TableEnvironment.listTemporaryViews()

listTables
```
public String[] listTables(String catalog,
                           String databaseName)
```
Description copied from interface: TableEnvironment

Gets the names of all tables available in the given namespace (the given database of the given catalog). It returns both temporary and permanent tables and views.

Specified by:

listTables in interface TableEnvironment

Returns:

A list of the names of all registered tables in the given database of the given catalog.

See Also:

TableEnvironment.listTemporaryTables(), TableEnvironment.listTemporaryViews()

listViews
```
public String[] listViews()
```
Description copied from interface: TableEnvironment

Gets the names of all views available in the current namespace (the current database of the current catalog). It returns both temporary and permanent views.

Specified by:

listViews in interface TableEnvironment

Returns:

A list of the names of all registered views in the current database of the current catalog.

See Also:

TableEnvironment.listTemporaryViews()

listTemporaryTables
```
public String[] listTemporaryTables()
```
Description copied from interface: TableEnvironment

Gets the names of all temporary tables and views available in the current namespace (the current database of the current catalog).

Specified by:

listTemporaryTables in interface TableEnvironment

Returns:

A list of the names of all registered temporary tables and views in the current database of the current catalog.

See Also:

TableEnvironment.listTables()

listTemporaryViews
```
public String[] listTemporaryViews()
```
Description copied from interface: TableEnvironment

Gets the names of all temporary views available in the current namespace (the current database of the current catalog).

Specified by:

listTemporaryViews in interface TableEnvironment

Returns:

A list of the names of all registered temporary views in the current database of the current catalog.

See Also:

TableEnvironment.listTables()

dropTemporaryTable
```
public boolean dropTemporaryTable(String path)
```
Description copied from interface: TableEnvironment

Drops a temporary table registered in the given path.
If a permanent table with a given path exists, it will be used from now on for any queries that reference this path.

Specified by:

dropTemporaryTable in interface TableEnvironment

Returns:

true if a table existed in the given path and was removed

dropTemporaryView
```
public boolean dropTemporaryView(String path)
```
Description copied from interface: TableEnvironment

Drops a temporary view registered in the given path.
If a permanent table or view with a given path exists, it will be used from now on for any queries that reference this path.

Specified by:

dropTemporaryView in interface TableEnvironment

Returns:

true if a view existed in the given path and was removed

listUserDefinedFunctions
```
public String[] listUserDefinedFunctions()
```
Description copied from interface: TableEnvironment

Gets the names of all user defined functions registered in this environment.

Specified by:

listUserDefinedFunctions in interface TableEnvironment

listFunctions
```
public String[] listFunctions()
```
Description copied from interface: TableEnvironment

Gets the names of all functions in this environment.

Specified by:

listFunctions in interface TableEnvironment

explainSql
```
public String explainSql(String statement,
                         ExplainDetail... extraDetails)
```
Description copied from interface: TableEnvironment

Returns the AST of the specified statement and the execution plan to compute the result of the given statement.

Specified by:

explainSql in interface TableEnvironment

Parameters:

statement - The statement for which the AST and execution plan will be returned.

extraDetails - The extra explain details which the explain result should include, e.g. estimated cost, changelog mode for streaming, displaying execution plan in json format

Returns:

AST and the execution plan.

explainInternal
```
public String explainInternal(List<Operation> operations,
                              ExplainDetail... extraDetails)
```
Description copied from interface: TableEnvironmentInternal

Returns the AST of this table and the execution plan to compute the result of this table.

Specified by:

explainInternal in interface TableEnvironmentInternal

Parameters:

operations - The operations to be explained.

extraDetails - The extra explain details which the explain result should include, e.g. estimated cost, changelog mode for streaming

Returns:

AST and the execution plan.

getCompletionHints
```
public String[] getCompletionHints(String statement,
                                   int position)
```
Description copied from interface: TableEnvironment

Returns completion hints for the given statement at the given cursor position. The completion happens case insensitively.

Specified by:

getCompletionHints in interface TableEnvironment

Parameters:

statement - Partial or slightly incorrect SQL statement

position - cursor position

Returns:

completion hints that fit at the current cursor position

sqlQuery
```
public Table sqlQuery(String query)
```
Description copied from interface: TableEnvironment
Evaluates a SQL query on registered tables and returns a Table object describing the pipeline for further transformations.
All tables and other objects referenced by the query must be registered in the TableEnvironment. For example, use TableEnvironment.createTemporaryView(String, Table)) for referencing a Table object or TableEnvironment.createTemporarySystemFunction(String, Class) for functions.
Alternatively, a Table object is automatically registered when its Table#toString() method is called, for example when it is embedded into a string. Hence, SQL queries can directly reference a Table object inline (i.e. anonymous) as follows:
```
 Table table = ...;
 String tableName = table.toString();
 // the table is not registered to the table environment
 tEnv.sqlQuery("SELECT * FROM " + tableName + " WHERE a > 12");
 
```
Note that the returned Table is an API object and only contains a pipeline description. It actually corresponds to a view in SQL terms. Call Executable.execute() to trigger an execution or use TableEnvironment.executeSql(String) directly.
Specified by:

sqlQuery in interface TableEnvironment

Parameters:

query - The SQL query to evaluate.

Returns:

The Table object describing the pipeline for further transformations.

executeSql
```
public TableResult executeSql(String statement)
```
Description copied from interface: TableEnvironment

Executes the given single statement and returns the execution result.
The statement can be DDL/DML/DQL/SHOW/DESCRIBE/EXPLAIN/USE. For DML and DQL, this method returns TableResult once the job has been submitted. For DDL and DCL statements, TableResult is returned once the operation has finished.
If multiple pipelines should insert data into one or more sink tables as part of a single execution, use a StatementSet (see TableEnvironment.createStatementSet()).
By default, all DML operations are executed asynchronously. Use TableResult.await() or TableResult.getJobClient() to monitor the execution. Set TableConfigOptions.TABLE_DML_SYNC for always synchronous execution.

Specified by:

executeSql in interface TableEnvironment

Returns:

content for DQL/SHOW/DESCRIBE/EXPLAIN, the affected row count for `DML` (-1 means unknown), or a string message ("OK") for other statements.

createStatementSet
```
public StatementSet createStatementSet()
```
Description copied from interface: TableEnvironment

Returns a StatementSet that accepts pipelines defined by DML statements or Table objects. The planner can optimize all added statements together and then submit them as one job.

Specified by:

createStatementSet in interface TableEnvironment

loadPlan
```
public CompiledPlan loadPlan(PlanReference planReference)
```
Description copied from interface: TableEnvironment

Loads a plan from a PlanReference into a CompiledPlan.
Compiled plans can be persisted and reloaded across Flink versions. They describe static pipelines to ensure backwards compatibility and enable stateful streaming job upgrades. See CompiledPlan and the website documentation for more information.
This method will parse the input reference and will validate the plan. The returned instance can be executed via Executable.execute().
Note: The compiled plan feature is not supported in batch mode.

Specified by:

loadPlan in interface TableEnvironment

compilePlanSql
```
public CompiledPlan compilePlanSql(String stmt)
```
Description copied from interface: TableEnvironment

Compiles a SQL DML statement into a CompiledPlan.
Compiled plans can be persisted and reloaded across Flink versions. They describe static pipelines to ensure backwards compatibility and enable stateful streaming job upgrades. See CompiledPlan and the website documentation for more information.
Note: Only INSERT INTO is supported at the moment.
Note: The compiled plan feature is not supported in batch mode.

Specified by:

compilePlanSql in interface TableEnvironment

See Also:

Executable.execute(), TableEnvironment.loadPlan(PlanReference)

executePlan
```
public TableResultInternal executePlan(InternalPlan plan)
```
Specified by:

executePlan in interface TableEnvironmentInternal

compilePlan

public CompiledPlan compilePlan(List<ModifyOperation> operations)

Specified by:: compilePlan in interface TableEnvironmentInternal

executeInternal
```
public TableResultInternal executeInternal(List<ModifyOperation> operations)
```
Description copied from interface: TableEnvironmentInternal

Execute the given modify operations and return the execution result.

Specified by:

executeInternal in interface TableEnvironmentInternal

Parameters:

operations - The operations to be executed.

Returns:

the affected row counts (-1 means unknown).

executeInternal
```
public TableResultInternal executeInternal(Operation operation)
```
Description copied from interface: TableEnvironmentInternal

Execute the given operation and return the execution result.

Specified by:

executeInternal in interface TableEnvironmentInternal

Parameters:

operation - The operation to be executed.

Returns:

the content of the execution result.

getCurrentCatalog
```
public String getCurrentCatalog()
```
Description copied from interface: TableEnvironment

Gets the current default catalog name of the current session.

Specified by:

getCurrentCatalog in interface TableEnvironment

Returns:

The current default catalog name that is used for the path resolution.

See Also:

TableEnvironment.useCatalog(String)

useCatalog

public void useCatalog(String catalogName)

Description copied from interface: TableEnvironment

Sets the current catalog to the given value. It also sets the default database to the catalog's default one. See also TableEnvironment.useDatabase(String).

This is used during the resolution of object paths. Both the catalog and database are optional when referencing catalog objects such as tables, views etc. The algorithm looks for requested objects in following paths in that order:

[current-catalog].[current-database].[requested-path]
[current-catalog].[requested-path]
[requested-path]

Example:

Given structure with default catalog set to default_catalog and default database set to default_database.

 root:
   |- default_catalog
       |- default_database
           |- tab1
       |- db1
           |- tab1
   |- cat1
       |- db1
           |- tab1

The following table describes resolved paths:

Requested path	Resolved path
tab1	default_catalog.default_database.tab1
db1.tab1	default_catalog.db1.tab1
cat1.db1.tab1	cat1.db1.tab1

Specified by:: useCatalog in interface TableEnvironment
Parameters:: catalogName - The name of the catalog to set as the current default catalog.
See Also:: TableEnvironment.useDatabase(String)

getCurrentDatabase
```
public String getCurrentDatabase()
```
Description copied from interface: TableEnvironment

Gets the current default database name of the running session.

Specified by:

getCurrentDatabase in interface TableEnvironment

Returns:

The name of the current database of the current catalog.

See Also:

TableEnvironment.useDatabase(String)

useDatabase

public void useDatabase(String databaseName)

Description copied from interface: TableEnvironment

Sets the current default database. It has to exist in the current catalog. That path will be used as the default one when looking for unqualified object names.

[current-catalog].[current-database].[requested-path]
[current-catalog].[requested-path]
[requested-path]

Example:

Given structure with default catalog set to default_catalog and default database set to default_database.

 root:
   |- default_catalog
       |- default_database
           |- tab1
       |- db1
           |- tab1
   |- cat1
       |- db1
           |- tab1

The following table describes resolved paths:

Requested path	Resolved path
tab1	default_catalog.default_database.tab1
db1.tab1	default_catalog.db1.tab1
cat1.db1.tab1	cat1.db1.tab1

Specified by:: useDatabase in interface TableEnvironment
Parameters:: databaseName - The name of the database to set as the current database.
See Also:: TableEnvironment.useCatalog(String)

getConfig
```
public TableConfig getConfig()
```
Description copied from interface: TableEnvironment

Returns the table config that defines the runtime behavior of the Table API.

Specified by:

getConfig in interface TableEnvironment

getParser
```
public Parser getParser()
```
Description copied from interface: TableEnvironmentInternal

Return a Parser that provides methods for parsing a SQL string.

Specified by:

getParser in interface TableEnvironmentInternal

Returns:

initialized Parser.

getExtendedOperationExecutor

public ExtendedOperationExecutor getExtendedOperationExecutor()

getCatalogManager
```
public CatalogManager getCatalogManager()
```
Description copied from interface: TableEnvironmentInternal

Returns a CatalogManager that deals with all catalog objects.

Specified by:

getCatalogManager in interface TableEnvironmentInternal

getOperationTreeBuilder
```
public OperationTreeBuilder getOperationTreeBuilder()
```
Description copied from interface: TableEnvironmentInternal

Returns a OperationTreeBuilder that can create QueryOperations.

Specified by:

getOperationTreeBuilder in interface TableEnvironmentInternal

qualifyQueryOperation
```
protected QueryOperation qualifyQueryOperation(org.apache.flink.table.catalog.ObjectIdentifier identifier,
                                               QueryOperation queryOperation)
```
Subclasses can override this method to transform the given QueryOperation to a new one with the qualified object identifier. This is needed for some QueryOperations, e.g. JavaDataStreamQueryOperation, which doesn't know the registered identifier when created (fromDataStream(DataStream). But the identifier is required when converting this QueryOperation to RelNode.

validateTableSource
```
protected void validateTableSource(org.apache.flink.table.sources.TableSource<?> tableSource)
```
Subclasses can override this method to add additional checks.

Parameters:

tableSource - tableSource to validate

translate

protected List<org.apache.flink.api.dag.Transformation<?>> translate(List<ModifyOperation> modifyOperations)

registerTableSourceInternal
```
public void registerTableSourceInternal(String name,
                                        org.apache.flink.table.sources.TableSource<?> tableSource)
```
Description copied from interface: TableEnvironmentInternal

Registers an external TableSource in this TableEnvironment's catalog. Registered tables can be referenced in SQL queries.
Temporary objects can shadow permanent ones. If a permanent object in a given path exists, it will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

Specified by:

registerTableSourceInternal in interface TableEnvironmentInternal

Parameters:

name - The name under which the TableSource is registered.

tableSource - The TableSource to register.

registerTableSinkInternal
```
public void registerTableSinkInternal(String name,
                                      org.apache.flink.table.sinks.TableSink<?> tableSink)
```
Description copied from interface: TableEnvironmentInternal

Registers an external TableSink with already configured field names and field types in this TableEnvironment's catalog. Registered sink tables can be referenced in SQL DML statements.
Temporary objects can shadow permanent ones. If a permanent object in a given path exists, it will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

Specified by:

registerTableSinkInternal in interface TableEnvironmentInternal

Parameters:

name - The name under which the TableSink is registered.

tableSink - The configured TableSink to register.

createTable

@VisibleForTesting
public TableImpl createTable(QueryOperation tableOperation)

explainPlan

public String explainPlan(InternalPlan compiledPlan,
                          ExplainDetail... extraDetails)

Specified by:: explainPlan in interface TableEnvironmentInternal

Class TableEnvironmentImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.flink.table.api.TableEnvironment

Field Detail

resourceManager

tableConfig

execEnv

functionCatalog

planner

Constructor Detail

TableEnvironmentImpl

Method Detail

create

create

fromValues

fromValues

fromValues

fromValues

fromValues

fromValues

getPlanner

fromTableSource

registerCatalog

getCatalog

loadModule

useModules

unloadModule

registerFunction

createTemporarySystemFunction

createTemporarySystemFunction

dropTemporarySystemFunction

createFunction

createFunction

dropFunction

createTemporaryFunction

createTemporaryFunction

dropTemporaryFunction

createTemporaryTable

createTable

registerTable

createTemporaryView

scan

from

from

listCatalogs

listModules

listFullModules

listDatabases

listTables

listTables

listViews

listTemporaryTables

listTemporaryViews

dropTemporaryTable

dropTemporaryView

listUserDefinedFunctions

listFunctions

explainSql

explainInternal

getCompletionHints

sqlQuery

executeSql

createStatementSet

loadPlan

compilePlanSql

executePlan

compilePlan

executeInternal

executeInternal

getCurrentCatalog

useCatalog

getCurrentDatabase

useDatabase

getConfig

getParser

getExtendedOperationExecutor

getCatalogManager