TableImpl (flink-table-api-java 1.10.0 API)

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

All Implemented Interfaces:: Table

@Internal
public class TableImpl
extends Object
implements Table

Implementation for Table.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Table`	`addColumns(org.apache.flink.table.expressions.Expression... fields)` Adds additional columns.
`Table`	`addColumns(String fields)` Adds additional columns.
`Table`	`addOrReplaceColumns(org.apache.flink.table.expressions.Expression... fields)` Adds additional columns.
`Table`	`addOrReplaceColumns(String fields)` Adds additional columns.
`AggregatedTable`	`aggregate(org.apache.flink.table.expressions.Expression aggregateFunction)` Performs a global aggregate operation with an aggregate function.
`AggregatedTable`	`aggregate(String aggregateFunction)` Performs a global aggregate operation with an aggregate function.
`Table`	`as(org.apache.flink.table.expressions.Expression... fields)` Renames the fields of the expression result.
`Table`	`as(String fields)` Renames the fields of the expression result.
`static TableImpl`	`createTable(TableEnvironment tableEnvironment, QueryOperation operationTree, OperationTreeBuilder operationTreeBuilder, FunctionLookup functionLookup)`
`org.apache.flink.table.functions.TemporalTableFunction`	`createTemporalTableFunction(org.apache.flink.table.expressions.Expression timeAttribute, org.apache.flink.table.expressions.Expression primaryKey)` Creates `TemporalTableFunction` backed up by this table as a history table.
`org.apache.flink.table.functions.TemporalTableFunction`	`createTemporalTableFunction(String timeAttribute, String primaryKey)` Creates `TemporalTableFunction` backed up by this table as a history table.
`Table`	`distinct()` Removes duplicate values and returns only distinct (different) values.
`Table`	`dropColumns(org.apache.flink.table.expressions.Expression... fields)` Drops existing columns.
`Table`	`dropColumns(String fields)` Drops existing columns.
`Table`	`fetch(int fetch)` Limits a sorted result to the first n rows.
`Table`	`filter(org.apache.flink.table.expressions.Expression predicate)` Filters out elements that don't pass the filter predicate.
`Table`	`filter(String predicate)` Filters out elements that don't pass the filter predicate.
`FlatAggregateTable`	`flatAggregate(org.apache.flink.table.expressions.Expression tableAggregateFunction)` Perform a global flatAggregate without groupBy.
`FlatAggregateTable`	`flatAggregate(String tableAggregateFunction)` Perform a global flatAggregate without groupBy.
`Table`	`flatMap(org.apache.flink.table.expressions.Expression tableFunction)` Performs a flatMap operation with an user-defined table function or built-in table function.
`Table`	`flatMap(String tableFunction)` Performs a flatMap operation with an user-defined table function or built-in table function.
`Table`	`fullOuterJoin(Table right, org.apache.flink.table.expressions.Expression joinPredicate)` Joins two `Table`s.
`Table`	`fullOuterJoin(Table right, String joinPredicate)` Joins two `Table`s.
`QueryOperation`	`getQueryOperation()` Returns underlying logical representation of this table.
`org.apache.flink.table.api.TableSchema`	`getSchema()` Returns the schema of this table.
`TableEnvironment`	`getTableEnvironment()`
`GroupedTable`	`groupBy(org.apache.flink.table.expressions.Expression... fields)` Groups the elements on some grouping keys.
`GroupedTable`	`groupBy(String fields)` Groups the elements on some grouping keys.
`void`	`insertInto(QueryConfig conf, String tablePath, String... tablePathContinued)` Writes the `Table` to a `TableSink` that was registered under the specified path.
`void`	`insertInto(String tablePath)` Writes the `Table` to a `TableSink` that was registered under the specified path.
`void`	`insertInto(String tableName, QueryConfig conf)` Writes the `Table` to a `TableSink` that was registered under the specified name in the built-in catalog.
`Table`	`intersect(Table right)` Intersects two `Table`s with duplicate records removed.
`Table`	`intersectAll(Table right)` Intersects two `Table`s.
`Table`	`join(Table right)` Joins two `Table`s.
`Table`	`join(Table right, org.apache.flink.table.expressions.Expression joinPredicate)` Joins two `Table`s.
`Table`	`join(Table right, String joinPredicate)` Joins two `Table`s.
`Table`	`joinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`joinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall, org.apache.flink.table.expressions.Expression joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`joinLateral(String tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`joinLateral(String tableFunctionCall, String joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoin(Table right)` Joins two `Table`s.
`Table`	`leftOuterJoin(Table right, org.apache.flink.table.expressions.Expression joinPredicate)` Joins two `Table`s.
`Table`	`leftOuterJoin(Table right, String joinPredicate)` Joins two `Table`s.
`Table`	`leftOuterJoinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall, org.apache.flink.table.expressions.Expression joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoinLateral(String tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoinLateral(String tableFunctionCall, String joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`map(org.apache.flink.table.expressions.Expression mapFunction)` Performs a map operation with an user-defined scalar function or built-in scalar function.
`Table`	`map(String mapFunction)` Performs a map operation with an user-defined scalar function or a built-in scalar function.
`Table`	`minus(Table right)` Minus of two `Table`s with duplicate records removed.
`Table`	`minusAll(Table right)` Minus of two `Table`s.
`Table`	`offset(int offset)` Limits a sorted result from an offset position.
`Table`	`orderBy(org.apache.flink.table.expressions.Expression... fields)` Sorts the given `Table`.
`Table`	`orderBy(String fields)` Sorts the given `Table`.
`void`	`printSchema()` Prints the schema of this table to the console in a tree format.
`Table`	`renameColumns(org.apache.flink.table.expressions.Expression... fields)` Renames existing columns.
`Table`	`renameColumns(String fields)` Renames existing columns.
`Table`	`rightOuterJoin(Table right, org.apache.flink.table.expressions.Expression joinPredicate)` Joins two `Table`s.
`Table`	`rightOuterJoin(Table right, String joinPredicate)` Joins two `Table`s.
`Table`	`select(org.apache.flink.table.expressions.Expression... fields)` Performs a selection operation.
`Table`	`select(String fields)` Performs a selection operation.
`String`	`toString()`
`Table`	`union(Table right)` Unions two `Table`s with duplicate records removed.
`Table`	`unionAll(Table right)` Unions two `Table`s.
`Table`	`where(org.apache.flink.table.expressions.Expression predicate)` Filters out elements that don't pass the filter predicate.
`Table`	`where(String predicate)` Filters out elements that don't pass the filter predicate.
`GroupWindowedTable`	`window(GroupWindow groupWindow)` Groups the records of a table by assigning them to windows defined by a time or row interval.
`OverWindowedTable`	`window(OverWindow... overWindows)` Defines over-windows on the records of a table.

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

- Method Detail
  - getTableEnvironment
```
public TableEnvironment getTableEnvironment()
```
  - createTable
```
public static TableImpl createTable(TableEnvironment tableEnvironment,
                                    QueryOperation operationTree,
                                    OperationTreeBuilder operationTreeBuilder,
                                    FunctionLookup functionLookup)
```
  - getSchema
```
public org.apache.flink.table.api.TableSchema getSchema()
```
    Description copied from interface: Table
    
    Returns the schema of this table.
    
    Specified by:
    
    getSchema in interface Table
  - printSchema
```
public void printSchema()
```
    Description copied from interface: Table
    
    Prints the schema of this table to the console in a tree format.
    
    Specified by:
    
    printSchema in interface Table
  - getQueryOperation
```
public QueryOperation getQueryOperation()
```
    Description copied from interface: Table
    
    Returns underlying logical representation of this table.
    
    Specified by:
    
    getQueryOperation in interface Table
  - select
```
public Table select(String fields)
```
    Description copied from interface: Table
    Performs a selection operation. Similar to a SQL SELECT statement. The field expressions can contain complex expressions and aggregations.
    Example:
```
 
   tab.select("key, value.avg + ' The average' as average")
 
 
```
    Specified by:
    
    select in interface Table
  - select
```
public Table select(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Performs a selection operation. Similar to a SQL SELECT statement. The field expressions can contain complex expressions and aggregations.
    Scala Example:
```
 
   tab.select('key, 'value.avg + " The average" as 'average)
 
 
```
    Specified by:
    
    select in interface Table
  - createTemporalTableFunction
```
public org.apache.flink.table.functions.TemporalTableFunction createTemporalTableFunction(String timeAttribute,
                                                                                          String primaryKey)
```
    Description copied from interface: Table
    
    Creates TemporalTableFunction backed up by this table as a history table. Temporal Tables represent a concept of a table that changes over time and for which Flink keeps track of those changes. TemporalTableFunction provides a way how to access those data.
    For more information please check Flink's documentation on Temporal Tables.
    Currently TemporalTableFunctions are only supported in streaming.
    
    Specified by:
    
    createTemporalTableFunction in interface Table
    
    Parameters:
    
    timeAttribute - Must points to a time attribute. Provides a way to compare which records are a newer or older version.
    
    primaryKey - Defines the primary key. With primary key it is possible to update a row or to delete it.
    
    Returns:
    
    TemporalTableFunction which is an instance of TableFunction. It takes one single argument, the timeAttribute, for which it returns matching version of the Table, from which TemporalTableFunction was created.
  - createTemporalTableFunction
```
public org.apache.flink.table.functions.TemporalTableFunction createTemporalTableFunction(org.apache.flink.table.expressions.Expression timeAttribute,
                                                                                          org.apache.flink.table.expressions.Expression primaryKey)
```
    Description copied from interface: Table
    
    Creates TemporalTableFunction backed up by this table as a history table. Temporal Tables represent a concept of a table that changes over time and for which Flink keeps track of those changes. TemporalTableFunction provides a way how to access those data.
    For more information please check Flink's documentation on Temporal Tables.
    Currently TemporalTableFunctions are only supported in streaming.
    
    Specified by:
    
    createTemporalTableFunction in interface Table
    
    Parameters:
    
    timeAttribute - Must points to a time indicator. Provides a way to compare which records are a newer or older version.
    
    primaryKey - Defines the primary key. With primary key it is possible to update a row or to delete it.
    
    Returns:
    
    TemporalTableFunction which is an instance of TableFunction. It takes one single argument, the timeAttribute, for which it returns matching version of the Table, from which TemporalTableFunction was created.
  - as
```
public Table as(String fields)
```
    Description copied from interface: Table
    Renames the fields of the expression result. Use this to disambiguate fields before joining to operations.
    Example:
```
 
   tab.as("a, b")
 
 
```
    Specified by:
    
    as in interface Table
  - as
```
public Table as(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Renames the fields of the expression result. Use this to disambiguate fields before joining to operations.
    Scala Example:
```
 
   tab.as('a, 'b)
 
 
```
    Specified by:
    
    as in interface Table
  - filter
```
public Table filter(String predicate)
```
    Description copied from interface: Table
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 
   tab.filter("name = 'Fred'")
 
 
```
    Specified by:
    
    filter in interface Table
  - filter
```
public Table filter(org.apache.flink.table.expressions.Expression predicate)
```
    Description copied from interface: Table
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Scala Example:
```
 
   tab.filter('name === "Fred")
 
 
```
    Specified by:
    
    filter in interface Table
  - where
```
public Table where(String predicate)
```
    Description copied from interface: Table
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 
   tab.where("name = 'Fred'")
 
 
```
    Specified by:
    
    where in interface Table
  - where
```
public Table where(org.apache.flink.table.expressions.Expression predicate)
```
    Description copied from interface: Table
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Scala Example:
```
 
   tab.where('name === "Fred")
 
 
```
    Specified by:
    
    where in interface Table
  - groupBy
```
public GroupedTable groupBy(String fields)
```
    Description copied from interface: Table
    Groups the elements on some grouping keys. Use this before a selection with aggregations to perform the aggregation on a per-group basis. Similar to a SQL GROUP BY statement.
    Example:
```
 
   tab.groupBy("key").select("key, value.avg")
 
 
```
    Specified by:
    
    groupBy in interface Table
  - groupBy
```
public GroupedTable groupBy(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Groups the elements on some grouping keys. Use this before a selection with aggregations to perform the aggregation on a per-group basis. Similar to a SQL GROUP BY statement.
    Scala Example:
```
 
   tab.groupBy('key).select('key, 'value.avg)
 
 
```
    Specified by:
    
    groupBy in interface Table
  - distinct
```
public Table distinct()
```
    Description copied from interface: Table
    Removes duplicate values and returns only distinct (different) values.
    Example:
```
 
   tab.select("key, value").distinct()
 
 
```
    Specified by:
    
    distinct in interface Table
  - join
```
public Table join(Table right)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL join. The fields of the two joined operations must not overlap, use as to rename fields if necessary. You can use where and select clauses after a join to further specify the behaviour of the join.
    Note: Both tables must be bound to the same TableEnvironment .
    Example:
```
 
   left.join(right).where("a = b && c > 3").select("a, b, d")
 
 
```
    Specified by:
    
    join in interface Table
  - join
```
public Table join(Table right,
                  String joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment .
    Example:
```
 
   left.join(right, "a = b")
 
 
```
    Specified by:
    
    join in interface Table
  - join
```
public Table join(Table right,
                  org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment .
    Scala Example:
```
 
   left.join(right, 'a === 'b).select('a, 'b, 'd)
 
 
```
    Specified by:
    
    join in interface Table
  - leftOuterJoin
```
public Table leftOuterJoin(Table right)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL left outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Example:
```
 
   left.leftOuterJoin(right).select("a, b, d")
 
 
```
    Specified by:
    
    leftOuterJoin in interface Table
  - leftOuterJoin
```
public Table leftOuterJoin(Table right,
                           String joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL left outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Example:
```
 
   left.leftOuterJoin(right, "a = b").select("a, b, d")
 
 
```
    Specified by:
    
    leftOuterJoin in interface Table
  - leftOuterJoin
```
public Table leftOuterJoin(Table right,
                           org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL left outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Scala Example:
```
 
   left.leftOuterJoin(right, 'a === 'b).select('a, 'b, 'd)
 
 
```
    Specified by:
    
    leftOuterJoin in interface Table
  - rightOuterJoin
```
public Table rightOuterJoin(Table right,
                            String joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL right outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Example:
```
 
   left.rightOuterJoin(right, "a = b").select("a, b, d")
 
 
```
    Specified by:
    
    rightOuterJoin in interface Table
  - rightOuterJoin
```
public Table rightOuterJoin(Table right,
                            org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL right outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Scala Example:
```
 
   left.rightOuterJoin(right, 'a === 'b).select('a, 'b, 'd)
 
 
```
    Specified by:
    
    rightOuterJoin in interface Table
  - fullOuterJoin
```
public Table fullOuterJoin(Table right,
                           String joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL full outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Example:
```
 
   left.fullOuterJoin(right, "a = b").select("a, b, d")
 
 
```
    Specified by:
    
    fullOuterJoin in interface Table
  - fullOuterJoin
```
public Table fullOuterJoin(Table right,
                           org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins two Tables. Similar to a SQL full outer join. The fields of the two joined operations must not overlap, use as to rename fields if necessary.
    Note: Both tables must be bound to the same TableEnvironment and its TableConfig must have null check enabled (default).
    Scala Example:
```
 
   left.fullOuterJoin(right, 'a === 'b).select('a, 'b, 'd)
 
 
```
    Specified by:
    
    fullOuterJoin in interface Table
  - joinLateral
```
public Table joinLateral(String tableFunctionCall)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL inner join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function.
    Example:
```
 
   class MySplitUDTF extends TableFunction<String> {
     public void eval(String str) {
       str.split("#").forEach(this::collect);
     }
   }

   TableFunction<String> split = new MySplitUDTF();
   tableEnv.registerFunction("split", split);
   table.joinLateral("split(c) as (s)").select("a, b, c, s");
 
 
```
    Specified by:
    
    joinLateral in interface Table
  - joinLateral
```
public Table joinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL inner join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function.
    Scala Example:
```
 
   class MySplitUDTF extends TableFunction[String] {
     def eval(str: String): Unit = {
       str.split("#").foreach(collect)
     }
   }

   val split = new MySplitUDTF()
   table.joinLateral(split('c) as ('s)).select('a, 'b, 'c, 's)
 
 
```
    Specified by:
    
    joinLateral in interface Table
  - joinLateral
```
public Table joinLateral(String tableFunctionCall,
                         String joinPredicate)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL inner join but works with a table function. Each row of the table is joined with all rows produced by the table function.
    Example:
```
 
   class MySplitUDTF extends TableFunction<String> {
     public void eval(String str) {
       str.split("#").forEach(this::collect);
     }
   }

   TableFunction<String> split = new MySplitUDTF();
   tableEnv.registerFunction("split", split);
   table.joinLateral("split(c) as (s)", "a = s").select("a, b, c, s");
 
 
```
    Specified by:
    
    joinLateral in interface Table
  - joinLateral
```
public Table joinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall,
                         org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL inner join but works with a table function. Each row of the table is joined with all rows produced by the table function.
    Scala Example:
```
 
   class MySplitUDTF extends TableFunction[String] {
     def eval(str: String): Unit = {
       str.split("#").foreach(collect)
     }
   }

   val split = new MySplitUDTF()
   table.joinLateral(split('c) as ('s), 'a === 's).select('a, 'b, 'c, 's)
 
 
```
    Specified by:
    
    joinLateral in interface Table
  - leftOuterJoinLateral
```
public Table leftOuterJoinLateral(String tableFunctionCall)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL left outer join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function. If the table function does not produce any row, the outer row is padded with nulls.
    Example:
```
 
   class MySplitUDTF extends TableFunction<String> {
     public void eval(String str) {
       str.split("#").forEach(this::collect);
     }
   }

   TableFunction<String> split = new MySplitUDTF();
   tableEnv.registerFunction("split", split);
   table.leftOuterJoinLateral("split(c) as (s)").select("a, b, c, s");
 
 
```
    Specified by:
    
    leftOuterJoinLateral in interface Table
  - leftOuterJoinLateral
```
public Table leftOuterJoinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL left outer join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function. If the table function does not produce any row, the outer row is padded with nulls.
    Scala Example:
```
 
   class MySplitUDTF extends TableFunction[String] {
     def eval(str: String): Unit = {
       str.split("#").foreach(collect)
     }
   }

   val split = new MySplitUDTF()
   table.leftOuterJoinLateral(split('c) as ('s)).select('a, 'b, 'c, 's)
 
 
```
    Specified by:
    
    leftOuterJoinLateral in interface Table
  - leftOuterJoinLateral
```
public Table leftOuterJoinLateral(String tableFunctionCall,
                                  String joinPredicate)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL left outer join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function. If the table function does not produce any row, the outer row is padded with nulls.
    Example:
```
 
   class MySplitUDTF extends TableFunction<String> {
     public void eval(String str) {
       str.split("#").forEach(this::collect);
     }
   }

   TableFunction<String> split = new MySplitUDTF();
   tableEnv.registerFunction("split", split);
   table.leftOuterJoinLateral("split(c) as (s)", "a = s").select("a, b, c, s");
 
 
```
    Specified by:
    
    leftOuterJoinLateral in interface Table
  - leftOuterJoinLateral
```
public Table leftOuterJoinLateral(org.apache.flink.table.expressions.Expression tableFunctionCall,
                                  org.apache.flink.table.expressions.Expression joinPredicate)
```
    Description copied from interface: Table
    Joins this Table with an user-defined TableFunction. This join is similar to a SQL left outer join with ON TRUE predicate but works with a table function. Each row of the table is joined with all rows produced by the table function. If the table function does not produce any row, the outer row is padded with nulls.
    Scala Example:
```
 
   class MySplitUDTF extends TableFunction[String] {
     def eval(str: String): Unit = {
       str.split("#").foreach(collect)
     }
   }

   val split = new MySplitUDTF()
   table.leftOuterJoinLateral(split('c) as ('s), 'a === 's).select('a, 'b, 'c, 's)
 
 
```
    Specified by:
    
    leftOuterJoinLateral in interface Table
  - minus
```
public Table minus(Table right)
```
    Description copied from interface: Table
    Minus of two Tables with duplicate records removed. Similar to a SQL EXCEPT clause. Minus returns records from the left table that do not exist in the right table. Duplicate records in the left table are returned exactly once, i.e., duplicates are removed. Both tables must have identical field types.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.minus(right)
 
 
```
    Specified by:
    
    minus in interface Table
  - minusAll
```
public Table minusAll(Table right)
```
    Description copied from interface: Table
    Minus of two Tables. Similar to a SQL EXCEPT ALL. Similar to a SQL EXCEPT ALL clause. MinusAll returns the records that do not exist in the right table. A record that is present n times in the left table and m times in the right table is returned (n - m) times, i.e., as many duplicates as are present in the right table are removed. Both tables must have identical field types.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.minusAll(right)
 
 
```
    Specified by:
    
    minusAll in interface Table
  - union
```
public Table union(Table right)
```
    Description copied from interface: Table
    Unions two Tables with duplicate records removed. Similar to a SQL UNION. The fields of the two union operations must fully overlap.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.union(right)
 
 
```
    Specified by:
    
    union in interface Table
  - unionAll
```
public Table unionAll(Table right)
```
    Description copied from interface: Table
    Unions two Tables. Similar to a SQL UNION ALL. The fields of the two union operations must fully overlap.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.unionAll(right)
 
 
```
    Specified by:
    
    unionAll in interface Table
  - intersect
```
public Table intersect(Table right)
```
    Description copied from interface: Table
    Intersects two Tables with duplicate records removed. Intersect returns records that exist in both tables. If a record is present in one or both tables more than once, it is returned just once, i.e., the resulting table has no duplicate records. Similar to a SQL INTERSECT. The fields of the two intersect operations must fully overlap.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.intersect(right)
 
 
```
    Specified by:
    
    intersect in interface Table
  - intersectAll
```
public Table intersectAll(Table right)
```
    Description copied from interface: Table
    Intersects two Tables. IntersectAll returns records that exist in both tables. If a record is present in both tables more than once, it is returned as many times as it is present in both tables, i.e., the resulting table might have duplicate records. Similar to an SQL INTERSECT ALL. The fields of the two intersect operations must fully overlap.
    Note: Both tables must be bound to the same TableEnvironment.
    Example:
```
 
   left.intersectAll(right)
 
 
```
    Specified by:
    
    intersectAll in interface Table
  - orderBy
```
public Table orderBy(String fields)
```
    Description copied from interface: Table
    Sorts the given Table. Similar to SQL ORDER BY. The resulting Table is sorted globally sorted across all parallel partitions.
    Example:
```
 
   tab.orderBy("name.desc")
 
 
```
    Specified by:
    
    orderBy in interface Table
  - orderBy
```
public Table orderBy(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Sorts the given Table. Similar to SQL ORDER BY. The resulting Table is globally sorted across all parallel partitions.
    Scala Example:
```
 
   tab.orderBy('name.desc)
 
 
```
    Specified by:
    
    orderBy in interface Table
  - offset
```
public Table offset(int offset)
```
    Description copied from interface: Table
    Limits a sorted result from an offset position. Similar to a SQL OFFSET clause. Offset is technically part of the Order By operator and thus must be preceded by it. Table.offset(int offset) can be combined with a subsequent Table.fetch(int fetch) call to return n rows after skipping the first o rows.
```
 
   // skips the first 3 rows and returns all following rows.
   tab.orderBy("name.desc").offset(3)
   // skips the first 10 rows and returns the next 5 rows.
   tab.orderBy("name.desc").offset(10).fetch(5)
 
 
```
    Specified by:
    
    offset in interface Table
    
    Parameters:
    
    offset - number of records to skip
  - fetch
```
public Table fetch(int fetch)
```
    Description copied from interface: Table
    Limits a sorted result to the first n rows. Similar to a SQL FETCH clause. Fetch is technically part of the Order By operator and thus must be preceded by it. Table.fetch(int fetch) can be combined with a preceding Table.offset(int offset) call to return n rows after skipping the first o rows.
```
 
   // returns the first 3 records.
   tab.orderBy("name.desc").fetch(3)
   // skips the first 10 rows and returns the next 5 rows.
   tab.orderBy("name.desc").offset(10).fetch(5)
 
 
```
    Specified by:
    
    fetch in interface Table
    
    Parameters:
    
    fetch - the number of records to return. Fetch must be >= 0.
  - insertInto
```
public void insertInto(String tablePath)
```
    Description copied from interface: Table
    
    Writes the Table to a TableSink that was registered under the specified path. For the path resolution algorithm see TableEnvironment.useDatabase(String).
    A batch Table can only be written to a org.apache.flink.table.sinks.BatchTableSink, a streaming Table requires a org.apache.flink.table.sinks.AppendStreamTableSink, a org.apache.flink.table.sinks.RetractStreamTableSink, or an org.apache.flink.table.sinks.UpsertStreamTableSink.
    
    Specified by:
    
    insertInto in interface Table
    
    Parameters:
    
    tablePath - The path of the registered TableSink to which the Table is written.
  - insertInto
```
public void insertInto(String tableName,
                       QueryConfig conf)
```
    Description copied from interface: Table
    
    Writes the Table to a TableSink that was registered under the specified name in the built-in catalog.
    A batch Table can only be written to a org.apache.flink.table.sinks.BatchTableSink, a streaming Table requires a org.apache.flink.table.sinks.AppendStreamTableSink, a org.apache.flink.table.sinks.RetractStreamTableSink, or an org.apache.flink.table.sinks.UpsertStreamTableSink.
    
    Specified by:
    
    insertInto in interface Table
    
    Parameters:
    
    tableName - The name of the TableSink to which the Table is written.
    
    conf - The QueryConfig to use.
  - insertInto
```
public void insertInto(QueryConfig conf,
                       String tablePath,
                       String... tablePathContinued)
```
    Description copied from interface: Table
    
    Writes the Table to a TableSink that was registered under the specified path. For the path resolution algorithm see TableEnvironment.useDatabase(String).
    A batch Table can only be written to a org.apache.flink.table.sinks.BatchTableSink, a streaming Table requires a org.apache.flink.table.sinks.AppendStreamTableSink, a org.apache.flink.table.sinks.RetractStreamTableSink, or an org.apache.flink.table.sinks.UpsertStreamTableSink.
    
    Specified by:
    
    insertInto in interface Table
    
    Parameters:
    
    conf - The QueryConfig to use.
    
    tablePath - The first part of the path of the registered TableSink to which the Table is written. This is to ensure at least the name of the TableSink is provided.
    
    tablePathContinued - The remaining part of the path of the registered TableSink to which the Table is written.
  - window
```
public GroupWindowedTable window(GroupWindow groupWindow)
```
    Description copied from interface: Table
    
    Groups the records of a table by assigning them to windows defined by a time or row interval.
    For streaming tables of infinite size, grouping into windows is required to define finite groups on which group-based aggregates can be computed.
    For batch tables of finite size, windowing essentially provides shortcuts for time-based groupBy.
    Note: Computing windowed aggregates on a streaming table is only a parallel operation if additional grouping attributes are added to the groupBy(...) clause. If the groupBy(...) only references a GroupWindow alias, the streamed table will be processed by a single task, i.e., with parallelism 1.
    
    Specified by:
    
    window in interface Table
    
    Parameters:
    
    groupWindow - groupWindow that specifies how elements are grouped.
    
    Returns:
    
    A windowed table.
  - window
```
public OverWindowedTable window(OverWindow... overWindows)
```
    Description copied from interface: Table
    Defines over-windows on the records of a table.
    An over-window defines for each record an interval of records over which aggregation functions can be computed.
    Example:
```
 
   table
     .window(Over partitionBy 'c orderBy 'rowTime preceding 10.seconds as 'ow)
     .select('c, 'b.count over 'ow, 'e.sum over 'ow)
 
 
```
    Note: Computing over window aggregates on a streaming table is only a parallel operation if the window is partitioned. Otherwise, the whole stream will be processed by a single task, i.e., with parallelism 1.
    Note: Over-windows for batch tables are currently not supported.
    Specified by:
    
    window in interface Table
    
    Parameters:
    
    overWindows - windows that specify the record interval over which aggregations are computed.
    
    Returns:
    
    An OverWindowedTable to specify the aggregations.
  - addColumns
```
public Table addColumns(String fields)
```
    Description copied from interface: Table
    Adds additional columns. Similar to a SQL SELECT statement. The field expressions can contain complex expressions, but can not contain aggregations. It will throw an exception if the added fields already exist.
    Example:
```
 
   tab.addColumns("a + 1 as a1, concat(b, 'sunny') as b1")
 
 
```
    Specified by:
    
    addColumns in interface Table
  - addColumns
```
public Table addColumns(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Adds additional columns. Similar to a SQL SELECT statement. The field expressions can contain complex expressions, but can not contain aggregations. It will throw an exception if the added fields already exist.
    Scala Example:
```
 
   tab.addColumns('a + 1 as 'a1, concat('b, "sunny") as 'b1)
 
 
```
    Specified by:
    
    addColumns in interface Table
  - addOrReplaceColumns
```
public Table addOrReplaceColumns(String fields)
```
    Description copied from interface: Table
    Adds additional columns. Similar to a SQL SELECT statement. The field expressions can contain complex expressions, but can not contain aggregations. Existing fields will be replaced if add columns name is the same as the existing column name. Moreover, if the added fields have duplicate field name, then the last one is used.
    Example:
```
 
   tab.addOrReplaceColumns("a + 1 as a1, concat(b, 'sunny') as b1")
 
 
```
    Specified by:
    
    addOrReplaceColumns in interface Table
  - addOrReplaceColumns
```
public Table addOrReplaceColumns(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Adds additional columns. Similar to a SQL SELECT statement. The field expressions can contain complex expressions, but can not contain aggregations. Existing fields will be replaced. If the added fields have duplicate field name, then the last one is used.
    Scala Example:
```
 
   tab.addOrReplaceColumns('a + 1 as 'a1, concat('b, "sunny") as 'b1)
 
 
```
    Specified by:
    
    addOrReplaceColumns in interface Table
  - renameColumns
```
public Table renameColumns(String fields)
```
    Description copied from interface: Table
    Renames existing columns. Similar to a field alias statement. The field expressions should be alias expressions, and only the existing fields can be renamed.
    Example:
```
 
   tab.renameColumns("a as a1, b as b1")
 
 
```
    Specified by:
    
    renameColumns in interface Table
  - renameColumns
```
public Table renameColumns(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Renames existing columns. Similar to a field alias statement. The field expressions should be alias expressions, and only the existing fields can be renamed.
    Scala Example:
```
 
   tab.renameColumns('a as 'a1, 'b as 'b1)
 
 
```
    Specified by:
    
    renameColumns in interface Table
  - dropColumns
```
public Table dropColumns(String fields)
```
    Description copied from interface: Table
    Drops existing columns. The field expressions should be field reference expressions.
    Example:
```
 
   tab.dropColumns("a, b")
 
 
```
    Specified by:
    
    dropColumns in interface Table
  - dropColumns
```
public Table dropColumns(org.apache.flink.table.expressions.Expression... fields)
```
    Description copied from interface: Table
    Drops existing columns. The field expressions should be field reference expressions.
    Scala Example:
```
 
   tab.dropColumns('a, 'b)
 
 
```
    Specified by:
    
    dropColumns in interface Table
  - map
```
public Table map(String mapFunction)
```
    Description copied from interface: Table
    Performs a map operation with an user-defined scalar function or a built-in scalar function. The output will be flattened if the output type is a composite type.
    Example:
```
 
   ScalarFunction func = new MyMapFunction();
   tableEnv.registerFunction("func", func);
   tab.map("func(c)");
 
 
```
    Specified by:
    
    map in interface Table
  - map
```
public Table map(org.apache.flink.table.expressions.Expression mapFunction)
```
    Description copied from interface: Table
    Performs a map operation with an user-defined scalar function or built-in scalar function. The output will be flattened if the output type is a composite type.
    Scala Example:
```
 
   val func = new MyMapFunction()
   tab.map(func('c))
 
 
```
    Specified by:
    
    map in interface Table
  - flatMap
```
public Table flatMap(String tableFunction)
```
    Description copied from interface: Table
    Performs a flatMap operation with an user-defined table function or built-in table function. The output will be flattened if the output type is a composite type.
    Example:
```
 
   TableFunction func = new MyFlatMapFunction();
   tableEnv.registerFunction("func", func);
   table.flatMap("func(c)");
 
 
```
    Specified by:
    
    flatMap in interface Table
  - flatMap
```
public Table flatMap(org.apache.flink.table.expressions.Expression tableFunction)
```
    Description copied from interface: Table
    Performs a flatMap operation with an user-defined table function or built-in table function. The output will be flattened if the output type is a composite type.
    Scala Example:
```
 
   val func = new MyFlatMapFunction
   table.flatMap(func('c))
 
 
```
    Specified by:
    
    flatMap in interface Table
  - aggregate
```
public AggregatedTable aggregate(String aggregateFunction)
```
    Description copied from interface: Table
    Performs a global aggregate operation with an aggregate function. You have to close the Table.aggregate(String) with a select statement. The output will be flattened if the output type is a composite type.
    Example:
```
 
   AggregateFunction aggFunc = new MyAggregateFunction()
   tableEnv.registerFunction("aggFunc", aggFunc);
   table.aggregate("aggFunc(a, b) as (f0, f1, f2)")
     .select("f0, f1")
 
 
```
    Specified by:
    
    aggregate in interface Table
  - aggregate
```
public AggregatedTable aggregate(org.apache.flink.table.expressions.Expression aggregateFunction)
```
    Description copied from interface: Table
    Performs a global aggregate operation with an aggregate function. You have to close the Table.aggregate(Expression) with a select statement. The output will be flattened if the output type is a composite type.
    Scala Example:
```
 
   val aggFunc = new MyAggregateFunction
   table.aggregate(aggFunc('a, 'b) as ('f0, 'f1, 'f2))
     .select('f0, 'f1)
 
 
```
    Specified by:
    
    aggregate in interface Table
  - flatAggregate
```
public FlatAggregateTable flatAggregate(String tableAggregateFunction)
```
    Description copied from interface: Table
    Perform a global flatAggregate without groupBy. FlatAggregate takes a TableAggregateFunction which returns multiple rows. Use a selection after the flatAggregate.
    Example:
```
 
   TableAggregateFunction tableAggFunc = new MyTableAggregateFunction();
   tableEnv.registerFunction("tableAggFunc", tableAggFunc);
   tab.flatAggregate("tableAggFunc(a, b) as (x, y, z)")
     .select("x, y, z")
 
 
```
    Specified by:
    
    flatAggregate in interface Table
  - flatAggregate
```
public FlatAggregateTable flatAggregate(org.apache.flink.table.expressions.Expression tableAggregateFunction)
```
    Description copied from interface: Table
    Perform a global flatAggregate without groupBy. FlatAggregate takes a TableAggregateFunction which returns multiple rows. Use a selection after the flatAggregate.
    Scala Example:
```
 
   val tableAggFunc = new MyTableAggregateFunction
   tab.flatAggregate(tableAggFunc('a, 'b) as ('x, 'y, 'z))
     .select('x, 'y, 'z)
 
 
```
    Specified by:
    
    flatAggregate in interface Table
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class TableImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getTableEnvironment

createTable

getSchema

printSchema

getQueryOperation

select

select

createTemporalTableFunction

createTemporalTableFunction

as

as

filter

filter

where

where

groupBy

groupBy

distinct

join

join

join

leftOuterJoin

leftOuterJoin

leftOuterJoin

rightOuterJoin

rightOuterJoin

fullOuterJoin

fullOuterJoin

joinLateral

joinLateral

joinLateral

joinLateral

leftOuterJoinLateral

leftOuterJoinLateral

leftOuterJoinLateral

leftOuterJoinLateral

minus

minusAll

union

unionAll

intersect

intersectAll

orderBy

orderBy

offset

fetch

insertInto

insertInto

insertInto

window

window

addColumns

addColumns

addOrReplaceColumns

addOrReplaceColumns

renameColumns

renameColumns

dropColumns

dropColumns

map

map

flatMap

flatMap

aggregate

aggregate

flatAggregate

flatAggregate

toString