Package org.apache.flink.table.api.internal

Class TableEnvironmentImpl

    • 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.

        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.

        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...)

      • getPlanner

        @VisibleForTesting
public Planner getPlanner()

      • 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.

      • createCatalog

        public void createCatalog​(String catalogName,
                          org.apache.flink.table.catalog.CatalogDescriptor catalogDescriptor)
        Description copied from interface: TableEnvironment
        Creates a Catalog using the provided CatalogDescriptor. All table registered in the Catalog can be accessed. The CatalogDescriptor will be persisted into the CatalogStore.
        Specified by:
        createCatalog in interface TableEnvironment
        Parameters:
        catalogName - The name under which the catalog will be created
        catalogDescriptor - The catalog descriptor for creating catalog

      • 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.

      • createTemporarySystemFunction

        public void createTemporarySystemFunction​(String name,
                                          String className,
                                          List<org.apache.flink.table.resource.ResourceUri> resourceUris)
        Description copied from interface: TableEnvironment
        Registers a UserDefinedFunction class as a temporary system function by the specific class name and user defined resource uri.

        Compared to TableEnvironment.createTemporaryFunction(String, Class), this method allows registering a user defined function by only providing a full path class name and a list of resources that contain the implementation of the function along with its dependencies. Users don't need to initialize the function instance in advance. The resource file can be a local or remote JAR file.

        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.
        className - The class name of UDF to be registered.
        resourceUris - The list of udf resource uris in local or remote.

      • 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.

      • createFunction

        public void createFunction​(String path,
                           String className,
                           List<org.apache.flink.table.resource.ResourceUri> resourceUris)
        Description copied from interface: TableEnvironment
        Registers a UserDefinedFunction class as a catalog function in the given path by the specific class name and user defined resource uri.

        Compared to TableEnvironment.createFunction(String, Class), this method allows registering a user defined function by only providing a full path class name and a list of resources that contain the implementation of the function along with its dependencies. Users don't need to initialize the function instance in advance. The resource file can be a local or remote JAR file.

        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.
        className - The class name of UDF to be registered.
        resourceUris - The list of udf resource uris in local or remote.

      • createFunction

        public void createFunction​(String path,
                           String className,
                           List<org.apache.flink.table.resource.ResourceUri> resourceUris,
                           boolean ignoreIfExists)
        Description copied from interface: TableEnvironment
        Registers a UserDefinedFunction class as a catalog function in the given path by the specific class name and user defined resource uri.

        Compared to TableEnvironment.createFunction(String, Class), this method allows registering a user defined function by only providing a full path class name and a list of resources that contain the implementation of the function along with its dependencies. Users don't need to initialize the function instance in advance. The resource file can be a local or remote JAR file.

        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.
        className - The class name of UDF to be registered.
        resourceUris - The list of udf resource uris in local or remote.
        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.

      • createTemporaryFunction

        public void createTemporaryFunction​(String path,
                                    String className,
                                    List<org.apache.flink.table.resource.ResourceUri> resourceUris)
        Description copied from interface: TableEnvironment
        Registers a UserDefinedFunction class as a temporary catalog function in the given path by the specific class name and user defined resource uri.

        Compared to TableEnvironment.createTemporaryFunction(String, Class), this method allows registering a user defined function by only providing a full path class name and a list of resources that contain the implementation of the function along with its dependencies. Users don't need to initialize the function instance in advance. The resource file can be a local or remote JAR file.

        Compared to TableEnvironment.createTemporarySystemFunction(String, String, List) 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.
        className - The class name of UDF to be registered.
        resourceUris - The list udf resource uri in local or remote.

      • 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.

      • createTemporaryTable

        public void createTemporaryTable​(String path,
                                 TableDescriptor descriptor,
                                 boolean ignoreIfExists)
        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(),
  true);
        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.
        ignoreIfExists - If a table exists under the given path and this flag is set, no operation is executed. An exception is thrown otherwise.

      • 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.

      • createTable

        public boolean createTable​(String path,
                           TableDescriptor descriptor,
                           boolean ignoreIfExists)
        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, boolean) 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(),
  true);
        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.
        ignoreIfExists - If a table exists under the given path and this flag is set, no operation is executed. An exception is thrown otherwise.
        Returns:
        true if table was created in the given path, false if a permanent object already exists in the given path.

      • 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.

      • createView

        public void createView​(String path,
                       Table view)
        Description copied from interface: TableEnvironment
        Registers a Table API object as a view similar to SQL views.

        Temporary objects can shadow permanent ones. If a temporary object in a given path exists, the permanent one will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

        Specified by:
        createView 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.

      • createView

        public boolean createView​(String path,
                          Table view,
                          boolean ignoreIfExists)
        Description copied from interface: TableEnvironment
        Registers a Table API object as a view similar to SQL views.

        Temporary objects can shadow permanent ones. If a temporary object in a given path exists, the permanent one will be inaccessible in the current session. To make the permanent object available again one can drop the corresponding temporary object.

        Specified by:
        createView 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.
        ignoreIfExists - If a view or a table exists and the given flag is set, no operation is executed. An exception is thrown otherwise.
        Returns:
        true if view was created in the given path, false if a permanent object already exists in the given path.

      • 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.

      • 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
        Parameters:
        path - The given path under which the temporary table will be dropped. See also the TableEnvironment class description for the format of the path.
        Returns:
        true if a table existed in the given path and was removed

      • dropTable

        public boolean dropTable​(String path)
        Description copied from interface: TableEnvironment
        Drops a table registered in the given path.

        This method can only drop permanent objects. Temporary objects can shadow permanent ones. If a temporary object exists in a given path, make sure to drop the temporary object first using TableEnvironment.dropTemporaryTable(java.lang.String).

        Compared to SQL, this method will not throw an error if the table does not exist. Use TableEnvironment.dropTable(java.lang.String, boolean) to change the default behavior.

        Specified by:
        dropTable in interface TableEnvironment
        Parameters:
        path - The given path under which the table will be dropped. See also the TableEnvironment class description for the format of the path.
        Returns:
        true if table existed in the given path and was dropped, false if table didn't exist in the given path.

      • dropTable

        public boolean dropTable​(String path,
                         boolean ignoreIfNotExists)
        Description copied from interface: TableEnvironment
        Drops a table registered in the given path.

        This method can only drop permanent objects. Temporary objects can shadow permanent ones. If a temporary object exists in a given path, make sure to drop the temporary object first using TableEnvironment.dropTemporaryTable(java.lang.String).

        Specified by:
        dropTable in interface TableEnvironment
        Parameters:
        path - The given path under which the given table will be dropped. See also the TableEnvironment class description for the format of the path.
        ignoreIfNotExists - If false exception will be thrown if the view to drop does not exist.
        Returns:
        true if table existed in the given path and was dropped, false if table didn't exist in the given path.

      • 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
        Parameters:
        path - The given path under which the temporary view will be dropped. See also the TableEnvironment class description for the format of the path.
        Returns:
        true if a view existed in the given path and was removed

      • dropView

        public boolean dropView​(String path)
        Description copied from interface: TableEnvironment
        Drops a view registered in the given path.

        This method can only drop permanent objects. Temporary objects can shadow permanent ones. If a temporary object exists in a given path, make sure to drop the temporary object first using TableEnvironment.dropTemporaryView(java.lang.String).

        Compared to SQL, this method will not throw an error if the view does not exist. Use TableEnvironment.dropView(java.lang.String, boolean) to change the default behavior.

        Specified by:
        dropView in interface TableEnvironment
        Parameters:
        path - The given path under which the view will be dropped. See also the TableEnvironment class description for the format of the path.
        Returns:
        true if view existed in the given path and was dropped, false if view didn't exist in the given path.

      • dropView

        public boolean dropView​(String path,
                        boolean ignoreIfNotExists)
        Description copied from interface: TableEnvironment
        Drops a view registered in the given path.

        This method can only drop permanent objects. Temporary objects can shadow permanent ones. If a temporary object exists in a given path, make sure to drop the temporary object first using TableEnvironment.dropTemporaryView(java.lang.String).

        Specified by:
        dropView in interface TableEnvironment
        Parameters:
        path - The given path under which the view will be dropped. See also the TableEnvironment class description for the format of the path.
        ignoreIfNotExists - If false exception will be thrown if the view to drop does not exist.
        Returns:
        true if view existed in the given path and was dropped, false if view didn't exist in the given path and ignoreIfNotExists was true.

      • explainSql

        public String explainSql​(String statement,
                         ExplainFormat format,
                         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.
        format - The output format of explained plan.
        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,
                              ExplainFormat format,
                              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.
        format - The output format.
        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.

      • 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

      • generatePipelineFromQueryOperation

        @VisibleForTesting
public org.apache.flink.api.dag.Pipeline generatePipelineFromQueryOperation​(QueryOperation operation,
                                                                            List<org.apache.flink.api.dag.Transformation<?>> transformations)
        generate execution Pipeline from QueryOperation.

      • 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:

        1. [current-catalog].[current-database].[requested-path]
        2. [current-catalog].[requested-path]
        3. [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

        You can unset the current catalog by passing a null value. If the current catalog is unset, you need to use fully qualified identifiers.

        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)

      • 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.

        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:

        1. [current-catalog].[current-database].[requested-path]
        2. [current-catalog].[requested-path]
        3. [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

        You can unset the current database by passing a null value. If the current database is unset, you need to qualify identifiers at least with the database name.

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

      • 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.

      • translate

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