Table (flink 1.11-SNAPSHOT API)

All Known Implementing Classes:: TableImpl

@PublicEvolving
public interface Table

A Table is the core component of the Table API. Similar to how the batch and streaming APIs have DataSet and DataStream, the Table API is built around Table.

Use the methods of Table to transform data. Use TableEnvironment to convert a Table back to a DataSet or DataStream.

When using Scala a Table can also be converted using implicit conversions.

Java Example:


 ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
 BatchTableEnvironment tEnv = BatchTableEnvironment.create(env);

 DataSet<Tuple2<String, Integer>> set = ...
 tEnv.registerTable("MyTable", set, "a, b");

 Table table = tEnv.scan("MyTable").select(...);
 ...
 Table table2 = ...
 DataSet<MyType> set2 = tEnv.toDataSet(table2, MyType.class);

Scala Example:


 val env = ExecutionEnvironment.getExecutionEnvironment
 val tEnv = BatchTableEnvironment.create(env)

 val set: DataSet[(String, Int)] = ...
 val table = set.toTable(tEnv, 'a, 'b)
 ...
 val table2 = ...
 val set2: DataSet[MyType] = table2.toDataSet[MyType]

Operations such as join, select, where and groupBy either take arguments in a Scala DSL or as an expression String. Please refer to the documentation for the expression syntax.

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`Table`	`addColumns(Expression... fields)` Adds additional columns.
`Table`	`addColumns(String fields)` Deprecated. use `addColumns(Expression...)`
`Table`	`addOrReplaceColumns(Expression... fields)` Adds additional columns.
`Table`	`addOrReplaceColumns(String fields)` Deprecated. use `addOrReplaceColumns(Expression...)`
`AggregatedTable`	`aggregate(Expression aggregateFunction)` Performs a global aggregate operation with an aggregate function.
`AggregatedTable`	`aggregate(String aggregateFunction)` Deprecated. use `aggregate(Expression)`
`Table`	`as(Expression... fields)` Deprecated. use `as(String, String...)`
`Table`	`as(String field, String... fields)` Renames the fields of the expression result.
`TemporalTableFunction`	`createTemporalTableFunction(Expression timeAttribute, Expression primaryKey)` Creates `TemporalTableFunction` backed up by this table as a history table.
`TemporalTableFunction`	`createTemporalTableFunction(String timeAttribute, String primaryKey)` Deprecated. use `createTemporalTableFunction(Expression, Expression)`
`Table`	`distinct()` Removes duplicate values and returns only distinct (different) values.
`Table`	`dropColumns(Expression... fields)` Drops existing columns.
`Table`	`dropColumns(String fields)` Deprecated. use `dropColumns(Expression...)`
`TableResult`	`execute()` Collects the contents of the current table local client.
`TableResult`	`executeInsert(String tablePath)` Writes the `Table` to a `TableSink` that was registered under the specified path, and then execute the insert operation.
`TableResult`	`executeInsert(String tablePath, boolean overwrite)` Writes the `Table` to a `TableSink` that was registered under the specified path, and then execute the insert operation.
`String`	`explain(ExplainDetail... extraDetails)` Returns the AST of this table and the execution plan to compute the result of this table.
`Table`	`fetch(int fetch)` Limits a sorted result to the first n rows.
`Table`	`filter(Expression predicate)` Filters out elements that don't pass the filter predicate.
`Table`	`filter(String predicate)` Deprecated. use `filter(Expression)`
`FlatAggregateTable`	`flatAggregate(Expression tableAggregateFunction)` Perform a global flatAggregate without groupBy.
`FlatAggregateTable`	`flatAggregate(String tableAggregateFunction)` Deprecated. use `flatAggregate(Expression)`
`Table`	`flatMap(Expression tableFunction)` Performs a flatMap operation with an user-defined table function or built-in table function.
`Table`	`flatMap(String tableFunction)` Deprecated. use `flatMap(Expression)`
`Table`	`fullOuterJoin(Table right, Expression joinPredicate)` Joins two `Table`s.
`Table`	`fullOuterJoin(Table right, String joinPredicate)` Deprecated. use `fullOuterJoin(Table, Expression)`
`QueryOperation`	`getQueryOperation()` Returns underlying logical representation of this table.
`TableSchema`	`getSchema()` Returns the schema of this table.
`GroupedTable`	`groupBy(Expression... fields)` Groups the elements on some grouping keys.
`GroupedTable`	`groupBy(String fields)` Deprecated. use `groupBy(Expression...)`
`void`	`insertInto(String tablePath)` Deprecated. use `executeInsert(String)` for single sink, use `TableEnvironment.createStatementSet()` for multiple sinks.
`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, Expression joinPredicate)` Joins two `Table`s.
`Table`	`join(Table right, String joinPredicate)` Deprecated. use `join(Table, Expression)`
`Table`	`joinLateral(Expression tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`joinLateral(Expression tableFunctionCall, Expression joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`joinLateral(String tableFunctionCall)` Deprecated. use `joinLateral(Expression)`
`Table`	`joinLateral(String tableFunctionCall, String joinPredicate)` Deprecated. use `joinLateral(Expression, Expression)`
`Table`	`leftOuterJoin(Table right)` Joins two `Table`s.
`Table`	`leftOuterJoin(Table right, Expression joinPredicate)` Joins two `Table`s.
`Table`	`leftOuterJoin(Table right, String joinPredicate)` Deprecated. use `leftOuterJoin(Table, Expression)`
`Table`	`leftOuterJoinLateral(Expression tableFunctionCall)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoinLateral(Expression tableFunctionCall, Expression joinPredicate)` Joins this `Table` with an user-defined `TableFunction`.
`Table`	`leftOuterJoinLateral(String tableFunctionCall)` Deprecated. use `leftOuterJoinLateral(Expression)`
`Table`	`leftOuterJoinLateral(String tableFunctionCall, String joinPredicate)` Deprecated. use `leftOuterJoinLateral(Expression, Expression)`
`Table`	`map(Expression mapFunction)` Performs a map operation with an user-defined scalar function or built-in scalar function.
`Table`	`map(String mapFunction)` Deprecated. use `map(Expression)`
`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(Expression... fields)` Sorts the given `Table`.
`Table`	`orderBy(String fields)` Deprecated. use `orderBy(Expression...)`
`void`	`printSchema()` Prints the schema of this table to the console in a tree format.
`Table`	`renameColumns(Expression... fields)` Renames existing columns.
`Table`	`renameColumns(String fields)` Deprecated. use `renameColumns(Expression...)`
`Table`	`rightOuterJoin(Table right, Expression joinPredicate)` Joins two `Table`s.
`Table`	`rightOuterJoin(Table right, String joinPredicate)` Deprecated. use `rightOuterJoin(Table, Expression)`
`Table`	`select(Expression... fields)` Performs a selection operation.
`Table`	`select(String fields)` Deprecated. use `select(Expression...)`
`Table`	`union(Table right)` Unions two `Table`s with duplicate records removed.
`Table`	`unionAll(Table right)` Unions two `Table`s.
`Table`	`where(Expression predicate)` Filters out elements that don't pass the filter predicate.
`Table`	`where(String predicate)` Deprecated. use `where(Expression)`
`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.

- Method Detail
  - getSchema
```
TableSchema getSchema()
```
    Returns the schema of this table.
  - printSchema
```
void printSchema()
```
    Prints the schema of this table to the console in a tree format.
  - getQueryOperation
```
QueryOperation getQueryOperation()
```
    Returns underlying logical representation of this table.
  - select
```
@Deprecated
Table select(String fields)
```
    Deprecated. use select(Expression...)
    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")
 
```
  - select
```
Table select(Expression... fields)
```
    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().plus(" The average").as("average"));
 
```
    Scala Example:
```
 tab.select($"key", $"value".avg + " The average" as "average")
 
```
  - createTemporalTableFunction
```
@Deprecated
TemporalTableFunction createTemporalTableFunction(String timeAttribute,
                                                              String primaryKey)
```
    Deprecated. use createTemporalTableFunction(Expression, Expression)
    
    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.
    
    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
```
TemporalTableFunction createTemporalTableFunction(Expression timeAttribute,
                                                  Expression primaryKey)
```
    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.
    
    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
```
Table as(String field,
         String... fields)
```
    Renames the fields of the expression result. Use this to disambiguate fields before joining to operations.
    Example:
```
 tab.as("a", "b")
 
```
  - as
```
@Deprecated
Table as(Expression... fields)
```
    Deprecated. use as(String, String...)
    Renames the fields of the expression result. Use this to disambiguate fields before joining to operations.
    Example:
```
 tab.as($("a"), $("b"))
 
```
    Scala Example:
```
 tab.as($"a", $"b")
 
```
  - filter
```
@Deprecated
Table filter(String predicate)
```
    Deprecated. use filter(Expression)
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 tab.filter("name = 'Fred'")
 
```
  - filter
```
Table filter(Expression predicate)
```
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 tab.filter($("name").isEqual("Fred"));
 
```
    Scala Example:
```
 tab.filter($"name" === "Fred")
 
```
  - where
```
@Deprecated
Table where(String predicate)
```
    Deprecated. use where(Expression)
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 tab.where("name = 'Fred'")
 
```
  - where
```
Table where(Expression predicate)
```
    Filters out elements that don't pass the filter predicate. Similar to a SQL WHERE clause.
    Example:
```
 tab.where($("name").isEqual("Fred"));
 
```
    Scala Example:
```
 tab.where($"name" === "Fred")
 
```
  - groupBy
```
@Deprecated
GroupedTable groupBy(String fields)
```
    Deprecated. use groupBy(Expression...)
    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")
 
```
  - groupBy
```
GroupedTable groupBy(Expression... fields)
```
    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());
 
```
    Scala Example:
```
 tab.groupBy($"key").select($"key", $"value".avg)
 
```
  - distinct
```
Table distinct()
```
    Removes duplicate values and returns only distinct (different) values.
    Example:
```
 tab.select($("key"), $("value")).distinct();
 
```
  - join
```
Table join(Table right)
```
    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").isEqual($("b")).and($("c").isGreater(3))
     .select($("a"), $("b"), $("d"));
 
```
  - join
```
@Deprecated
Table join(Table right,
                       String joinPredicate)
```
    Deprecated. use join(Table, Expression)
    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")
 
```
  - join
```
Table join(Table right,
           Expression joinPredicate)
```
    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").isEqual($("b")))
     .select($("a"), $("b"), $("d"));
 
```
    Scala Example:
```
 left.join(right, $"a" === $"b")
     .select($"a", $"b", $"d")
 
```
  - leftOuterJoin
```
Table leftOuterJoin(Table right)
```
    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"));
 
```
  - leftOuterJoin
```
@Deprecated
Table leftOuterJoin(Table right,
                                String joinPredicate)
```
    Deprecated. use leftOuterJoin(Table, Expression)
    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")
 
```
  - leftOuterJoin
```
Table leftOuterJoin(Table right,
                    Expression joinPredicate)
```
    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").isEqual($("b")))
     .select($("a"), $("b"), $("d"));
 
```
    Scala Example:
```
 left.leftOuterJoin(right, $"a" === $"b")
     .select($"a", $"b", $"d")
 
```
  - rightOuterJoin
```
@Deprecated
Table rightOuterJoin(Table right,
                                 String joinPredicate)
```
    Deprecated. use rightOuterJoin(Table, Expression)
    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")
 
```
  - rightOuterJoin
```
Table rightOuterJoin(Table right,
                     Expression joinPredicate)
```
    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").isEqual($("b")))
     .select($("a"), $("b"), $("d"));
 
```
    Scala Example:
```
 left.rightOuterJoin(right, $"a" === $"b")
     .select($"a", $"b", $"d")
 
```
  - fullOuterJoin
```
@Deprecated
Table fullOuterJoin(Table right,
                                String joinPredicate)
```
    Deprecated. use fullOuterJoin(Table, Expression)
    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")
 
```
  - fullOuterJoin
```
Table fullOuterJoin(Table right,
                    Expression joinPredicate)
```
    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").isEqual($("b")))
     .select($("a"), $("b"), $("d"));
 
```
    Scala Example:
```
 left.fullOuterJoin(right, $"a" === $"b")
     .select($"a", $"b", $"d")
 
```
  - joinLateral
```
@Deprecated
Table joinLateral(String tableFunctionCall)
```
    Deprecated. use joinLateral(Expression)
    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");
 
```
  - joinLateral
```
Table joinLateral(Expression tableFunctionCall)
```
    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);
   }
 }

 table.joinLateral(call(MySplitUDTF.class, $("c")).as("s"))
      .select($("a"), $("b"), $("c"), $("s"));
 
```
    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")
 
```
  - joinLateral
```
@Deprecated
Table joinLateral(String tableFunctionCall,
                              String joinPredicate)
```
    Deprecated. use joinLateral(Expression, Expression)
    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");
 
```
  - joinLateral
```
Table joinLateral(Expression tableFunctionCall,
                  Expression joinPredicate)
```
    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);
   }
 }

 table.joinLateral(call(MySplitUDTF.class, $("c")).as("s"), $("a").isEqual($("s")))
      .select($("a"), $("b"), $("c"), $("s"));
 
```
    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")
 
```
  - leftOuterJoinLateral
```
@Deprecated
Table leftOuterJoinLateral(String tableFunctionCall)
```
    Deprecated. use leftOuterJoinLateral(Expression)
    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");
 
```
  - leftOuterJoinLateral
```
Table leftOuterJoinLateral(Expression tableFunctionCall)
```
    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);
   }
 }

 table.leftOuterJoinLateral(call(MySplitUDTF.class, $("c")).as("s"))
      .select($("a"), $("b"), $("c"), $("s"));
 
```
    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")
 
```
  - leftOuterJoinLateral
```
@Deprecated
Table leftOuterJoinLateral(String tableFunctionCall,
                                       String joinPredicate)
```
    Deprecated. use leftOuterJoinLateral(Expression, Expression)
    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");
 
```
  - leftOuterJoinLateral
```
Table leftOuterJoinLateral(Expression tableFunctionCall,
                           Expression joinPredicate)
```
    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);
   }
 }

 table.leftOuterJoinLateral(call(MySplitUDTF.class, $("c")).as("s"), $("a").isEqual($("s")))
      .select($("a"), $("b"), $("c"), $("s"));
 
```
    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")
 
```
  - minus
```
Table minus(Table right)
```
    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);
 
```
  - minusAll
```
Table minusAll(Table right)
```
    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);
 
```
  - union
```
Table union(Table right)
```
    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);
 
```
  - unionAll
```
Table unionAll(Table right)
```
    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);
 
```
  - intersect
```
Table intersect(Table right)
```
    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);
 
```
  - intersectAll
```
Table intersectAll(Table right)
```
    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);
 
```
  - orderBy
```
@Deprecated
Table orderBy(String fields)
```
    Deprecated. use orderBy(Expression...)
    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")
 
```
  - orderBy
```
Table orderBy(Expression... fields)
```
    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());
 
```
    Scala Example:
```
 tab.orderBy($"name".desc)
 
```
  - offset
```
Table offset(int offset)
```
    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.
    offset(int offset) can be combined with a subsequent 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);
 
```
    Parameters:
    
    offset - number of records to skip
  - fetch
```
Table fetch(int fetch)
```
    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.
    fetch(int fetch) can be combined with a preceding 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);
 
```
    Parameters:
    
    fetch - the number of records to return. Fetch must be >= 0.
  - insertInto
```
@Deprecated
void insertInto(String tablePath)
```
    Deprecated. use executeInsert(String) for single sink, use TableEnvironment.createStatementSet() for multiple sinks.
    
    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.
    
    Parameters:
    
    tablePath - The path of the registered TableSink to which the Table is written.
  - window
```
GroupWindowedTable window(GroupWindow groupWindow)
```
    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.
    
    Parameters:
    
    groupWindow - groupWindow that specifies how elements are grouped.
    
    Returns:
    
    A windowed table.
  - window
```
OverWindowedTable window(OverWindow... overWindows)
```
    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(lit(10).seconds()).as("ow")
   .select($("c"), $("b").count().over($("ow")), $("e").sum().over($("ow")));
 
```
    Scala 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.
    Parameters:
    
    overWindows - windows that specify the record interval over which aggregations are computed.
    
    Returns:
    
    An OverWindowedTable to specify the aggregations.
  - addColumns
```
@Deprecated
Table addColumns(String fields)
```
    Deprecated. use addColumns(Expression...)
    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")
 
```
  - addColumns
```
Table addColumns(Expression... fields)
```
    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").plus(1).as("a1"),
    concat($("b"), "sunny").as("b1")
 );
 
```
    Scala Example:
```
 tab.addColumns(
    $"a" + 1 as "a1",
    concat($"b", "sunny") as "b1"
 )
 
```
  - addOrReplaceColumns
```
@Deprecated
Table addOrReplaceColumns(String fields)
```
    Deprecated. use addOrReplaceColumns(Expression...)
    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")
 
```
  - addOrReplaceColumns
```
Table addOrReplaceColumns(Expression... fields)
```
    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.
    Example:
```
 tab.addOrReplaceColumns(
    $("a").plus(1).as("a1"),
    concat($("b"), "sunny").as("b1")
 );
 
```
    Scala Example:
```
 tab.addOrReplaceColumns(
    $"a" + 1 as "a1",
    concat($"b", "sunny") as "b1"
 )
 
```
  - renameColumns
```
@Deprecated
Table renameColumns(String fields)
```
    Deprecated. use renameColumns(Expression...)
    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")
 
```
  - renameColumns
```
Table renameColumns(Expression... fields)
```
    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")
 );
 
```
    Scala Example:
```
 tab.renameColumns(
    $"a" as "a1",
    $"b" as "b1"
 )
 
```
  - dropColumns
```
@Deprecated
Table dropColumns(String fields)
```
    Deprecated. use dropColumns(Expression...)
    Drops existing columns. The field expressions should be field reference expressions.
    Example:
```
 tab.dropColumns("a, b")
 
```
  - dropColumns
```
Table dropColumns(Expression... fields)
```
    Drops existing columns. The field expressions should be field reference expressions.
    Example:
```
 tab.dropColumns($("a"), $("b"));
 
```
    Scala Example:
```
 tab.dropColumns($"a", $"b")
 
```
  - map
```
@Deprecated
Table map(String mapFunction)
```
    Deprecated. use map(Expression)
    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)");
 
```
  - map
```
Table map(Expression mapFunction)
```
    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.
    Example:
```
 tab.map(call(MyMapFunction.class, $("c")))
 
```
    Scala Example:
```
 val func = new MyMapFunction()
 tab.map(func($"c"))
 
```
  - flatMap
```
@Deprecated
Table flatMap(String tableFunction)
```
    Deprecated. use flatMap(Expression)
    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)");
 
```
  - flatMap
```
Table flatMap(Expression tableFunction)
```
    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:
```
 tab.flatMap(call(MyFlatMapFunction.class, $("c")))
 
```
    Scala Example:
```
 val func = new MyFlatMapFunction()
 tab.flatMap(func($"c"))
 
```
  - aggregate
```
@Deprecated
AggregatedTable aggregate(String aggregateFunction)
```
    Deprecated. use aggregate(Expression)
    Performs a global aggregate operation with an aggregate function. You have to close the 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")
 
```
  - aggregate
```
AggregatedTable aggregate(Expression aggregateFunction)
```
    Performs a global aggregate operation with an aggregate function. You have to close the aggregate(Expression) with a select statement. The output will be flattened if the output type is a composite type.
    Example:
```
 tab.aggregate(call(MyAggregateFunction.class, $("a"), $("b")).as("f0", "f1", "f2"))
   .select($("f0"), $("f1"));
 
```
    Scala Example:
```
 val aggFunc = new MyAggregateFunction
 table.aggregate(aggFunc($"a", $"b") as ("f0", "f1", "f2"))
   .select($"f0", $"f1")
 
```
  - flatAggregate
```
@Deprecated
FlatAggregateTable flatAggregate(String tableAggregateFunction)
```
    Deprecated. use flatAggregate(Expression)
    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")
 
```
  - flatAggregate
```
FlatAggregateTable flatAggregate(Expression tableAggregateFunction)
```
    Perform a global flatAggregate without groupBy. FlatAggregate takes a TableAggregateFunction which returns multiple rows. Use a selection after the flatAggregate.
    Example:
```
 tab.flatAggregate(call(MyTableAggregateFunction.class, $("a"), $("b")).as("x", "y", "z"))
   .select($("x"), $("y"), $("z"));
 
```
    Scala Example:
```
 val tableAggFunc: TableAggregateFunction = new MyTableAggregateFunction
 tab.flatAggregate(tableAggFunc($"a", $"b") as ("x", "y", "z"))
   .select($"x", $"y", $"z")
 
```
  - executeInsert
```
TableResult executeInsert(String tablePath)
```
    Writes the Table to a TableSink that was registered under the specified path, and then execute the insert operation.
    See the documentation of TableEnvironment.useDatabase(String) or TableEnvironment.useCatalog(String) for the rules on the path resolution.
    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.
    Example:
```
 Table table = tableEnv.fromQuery("select * from MyTable");
 TableResult tableResult = table.executeInsert("MySink");
 tableResult...
 
```
    Parameters:
    
    tablePath - The path of the registered TableSink to which the Table is written.
    
    Returns:
    
    The insert operation execution result.
  - executeInsert
```
TableResult executeInsert(String tablePath,
                          boolean overwrite)
```
    Writes the Table to a TableSink that was registered under the specified path, and then execute the insert operation.
    See the documentation of TableEnvironment.useDatabase(String) or TableEnvironment.useCatalog(String) for the rules on the path resolution.
    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.
    Example:
```
 Table table = tableEnv.fromQuery("select * from MyTable");
 TableResult tableResult = table.executeInsert("MySink", true);
 tableResult...
 
```
    Parameters:
    
    tablePath - The path of the registered TableSink to which the Table is written.
    
    overwrite - The flag that indicates whether the insert should overwrite existing data or not.
    
    Returns:
    
    The insert operation execution result.
  - execute
```
TableResult execute()
```
    Collects the contents of the current table local client.
```
 Table table = tableEnv.fromQuery("select * from MyTable");
 TableResult tableResult = table.execute();
 tableResult...
 
```
  - explain
```
String explain(ExplainDetail... extraDetails)
```
    Returns the AST of this table and the execution plan to compute the result of this table.
    
    Parameters:
    
    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.

Back to Flink Website

Interface Table

Method Summary

Method Detail

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

window

window

addColumns

addColumns

addOrReplaceColumns

addOrReplaceColumns

renameColumns

renameColumns

dropColumns

dropColumns

map

map

flatMap

flatMap

aggregate

aggregate

flatAggregate

flatAggregate

executeInsert

executeInsert

execute

explain