Flink API

Flink API

We do not recommend using programming API. Paimon is designed for SQL first, unless you are a professional Flink developer, even if you do, it can be very difficult.

We strongly recommend that you use Flink SQL or Spark SQL, or simply use SQL APIs in programs.

The following documents are not detailed and are for reference only.

Dependency

Maven dependency:


1. <dependency>
2. <groupId>org.apache.paimon</groupId>
3. <artifactId>paimon-flink-1.17</artifactId>
4. <version>0.8.2</version>
5. </dependency>

7. <dependency>
8. <groupId>org.apache.flink</groupId>
9. <artifactId>flink-table-api-java-bridge</artifactId>
10. <version>1.17.0</version>
11. <scope>provided</scope>
12. </dependency>

Or download the jar file: Paimon Flink.

Please choose your Flink version.

Paimon relies on Hadoop environment, you should add hadoop classpath or bundled jar.

Not only DataStream API, you can also read or write to Paimon tables by the conversion between DataStream and Table in Flink. See DataStream API Integration.

Write to Table


1. import org.apache.paimon.catalog.Catalog;
2. import org.apache.paimon.catalog.Identifier;
3. import org.apache.paimon.flink.sink.FlinkSinkBuilder;
4. import org.apache.paimon.options.Options;
5. import org.apache.paimon.table.Table;

7. import org.apache.flink.api.common.typeinfo.Types;
8. import org.apache.flink.streaming.api.datastream.DataStream;
9. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
10. import org.apache.flink.table.api.DataTypes;
11. import org.apache.flink.table.types.DataType;
12. import org.apache.flink.types.Row;
13. import org.apache.flink.types.RowKind;

15. public class WriteToTable {

17. public static void writeTo() throws Exception {
18. // create environments of both APIs
19. StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
20. // for CONTINUOUS_UNBOUNDED source, set checkpoint interval
21. // env.enableCheckpointing(60_000);

23. // create a changelog DataStream
24. DataStream<Row> input =
25. env.fromElements(
26. Row.ofKind(RowKind.INSERT, "Alice", 12),
27. Row.ofKind(RowKind.INSERT, "Bob", 5),
28. Row.ofKind(RowKind.UPDATE_BEFORE, "Alice", 12),
29. Row.ofKind(RowKind.UPDATE_AFTER, "Alice", 100))
30. .returns(
31. Types.ROW_NAMED(
32. new String[] {"name", "age"}, Types.STRING, Types.INT));

34. // get table from catalog
35. Options catalogOptions = new Options();
36. catalogOptions.set("warehouse", "/path/to/warehouse");
37. Catalog catalog = FlinkCatalogFactory.createPaimonCatalog(catalogOptions);
38. Table table = catalog.getTable(Identifier.create("my_db", "T"));

40. DataType inputType =
41. DataTypes.ROW(
42. DataTypes.FIELD("name", DataTypes.STRING()),
43. DataTypes.FIELD("age", DataTypes.INT()));
44. FlinkSinkBuilder builder = new FlinkSinkBuilder(table).forRow(input, inputType);

46. // set sink parallelism
47. // builder.parallelism(_your_parallelism)

49. // set overwrite mode
50. // builder.overwrite(...)

52. builder.build();
53. env.execute();
54. }
55. }

Read from Table


1. import org.apache.paimon.catalog.Catalog;
2. import org.apache.paimon.catalog.Identifier;
3. import org.apache.paimon.flink.source.FlinkSourceBuilder;
4. import org.apache.paimon.options.Options;
5. import org.apache.paimon.table.Table;

7. import org.apache.flink.streaming.api.datastream.DataStream;
8. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
9. import org.apache.flink.types.Row;

11. public class ReadFromTable {

13. public static void readFrom() throws Exception {
14. // create environments of both APIs
15. StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

17. // get table from catalog
18. Options catalogOptions = new Options();
19. catalogOptions.set("warehouse", "/path/to/warehouse");
20. Catalog catalog = FlinkCatalogFactory.createPaimonCatalog(catalogOptions);
21. Table table = catalog.getTable(Identifier.create("my_db", "T"));

23. // table = table.copy(Collections.singletonMap("scan.file-creation-time-millis", "..."));

25. FlinkSourceBuilder builder = new FlinkSourceBuilder(table).env(env);

27. // builder.sourceBounded(true);
28. // builder.projection(...);
29. // builder.predicate(...);
30. // builder.limit(...);
31. // builder.sourceParallelism(...);

33. DataStream<Row> dataStream = builder.buildForRow();

35. // use this datastream
36. dataStream.executeAndCollect().forEachRemaining(System.out::println);

38. // prints:
39. // +I[Bob, 12]
40. // +I[Alice, 12]
41. // -U[Alice, 12]
42. // +U[Alice, 14]
43. }
44. }

Cdc ingestion Table

Paimon supports ingest data into Paimon tables with schema evolution.

You can use Java API to write cdc records into Paimon Tables.
You can write records to Paimon’s partial-update table with adding columns dynamically.

Here is an example to use RichCdcSinkBuilder API:


1. import org.apache.paimon.catalog.Catalog;
2. import org.apache.paimon.catalog.CatalogContext;
3. import org.apache.paimon.catalog.CatalogFactory;
4. import org.apache.paimon.catalog.Identifier;
5. import org.apache.paimon.flink.sink.cdc.RichCdcRecord;
6. import org.apache.paimon.flink.sink.cdc.RichCdcSinkBuilder;
7. import org.apache.paimon.fs.Path;
8. import org.apache.paimon.options.Options;
9. import org.apache.paimon.schema.Schema;
10. import org.apache.paimon.table.Table;
11. import org.apache.paimon.types.DataTypes;

13. import org.apache.flink.streaming.api.datastream.DataStream;
14. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

16. import static org.apache.paimon.types.RowKind.INSERT;

18. public class WriteCdcToTable {

20. public static void writeTo() throws Exception {
21. StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
22. // for CONTINUOUS_UNBOUNDED source, set checkpoint interval
23. // env.enableCheckpointing(60_000);

25. DataStream<RichCdcRecord> dataStream =
26. env.fromElements(
27. RichCdcRecord.builder(INSERT)
28. .field("order_id", DataTypes.BIGINT(), "123")
29. .field("price", DataTypes.DOUBLE(), "62.2")
30. .build(),
31. // dt field will be added with schema evolution
32. RichCdcRecord.builder(INSERT)
33. .field("order_id", DataTypes.BIGINT(), "245")
34. .field("price", DataTypes.DOUBLE(), "82.1")
35. .field("dt", DataTypes.TIMESTAMP(), "2023-06-12 20:21:12")
36. .build());

38. Identifier identifier = Identifier.create("my_db", "T");
39. Options catalogOptions = new Options();
40. catalogOptions.set("warehouse", "/path/to/warehouse");
41. Catalog.Loader catalogLoader =
42. () -> FlinkCatalogFactory.createPaimonCatalog(catalogOptions);
43. Table table = catalogLoader.load().getTable(identifier);

45. new RichCdcSinkBuilder(table)
46. .forRichCdcRecord(dataStream)
47. .identifier(identifier)
48. .catalogLoader(catalogLoader)
49. .build();

51. env.execute();
52. }
53. }