This is an automated email from the ASF dual-hosted git repository.

github-merge-queue[bot] pushed a commit to branch 
gh-readonly-queue/dev/pr-13204-cbc15363625b783b801fa4b105bfdbb41effbcf7
in repository https://gitbox.apache.org/repos/asf/seatunnel.git

commit dcf97867ac13c04661a35af8568f2e3e40d07ef1
Author: Jast <[email protected]>
AuthorDate: Fri Nov 13 09:48:44 2026 +0000

    [Docs] Fix architecture API snippets, connector examples and deployment 
docs verified against source code (#13204)
    
    Co-authored-by: zhangshenghang 
<[email protected]>
    Co-authored-by: jast <[email protected]>
---
 docs/en/architecture/api-design/catalog-table.md   | 307 +++++++-----
 .../architecture/api-design/sink-architecture.md   |  88 +++-
 .../architecture/api-design/source-architecture.md |  27 +-
 .../architecture/api-design/translation-layer.md   | 536 +++++++++++----------
 docs/en/connectors/sink/SensorsData.md             |  23 +-
 docs/en/connectors/source/GoogleBigtable.md        |   9 +
 docs/en/connectors/source/Phoenix.md               |   2 +-
 docs/en/connectors/source/Vertica.md               |   2 +-
 docs/en/developer/coding-guide.md                  |   5 +-
 docs/en/developer/setup.md                         |   2 +-
 .../application/kubernetes/configuration.md        |   2 +-
 .../getting-started/application/kubernetes/faq.md  |   2 +-
 .../en/getting-started/kubernetes/configuration.md |   2 +-
 .../getting-started/locally/quick-start-flink.md   |  37 +-
 .../getting-started/locally/quick-start-spark.md   |  37 +-
 docs/zh/architecture/api-design/catalog-table.md   |  18 +-
 .../architecture/api-design/sink-architecture.md   |   2 +-
 .../architecture/api-design/translation-layer.md   |  31 +-
 docs/zh/connectors/sink/SensorsData.md             |  22 +-
 docs/zh/connectors/source/GoogleBigtable.md        |   8 +
 docs/zh/connectors/source/Phoenix.md               |   2 +-
 docs/zh/connectors/source/Vertica.md               |   2 +-
 docs/zh/developer/coding-guide.md                  |   5 +-
 docs/zh/developer/setup.md                         |   2 +-
 .../application/kubernetes/configuration.md        |   2 +-
 .../getting-started/application/kubernetes/faq.md  |   2 +-
 .../zh/getting-started/kubernetes/configuration.md |   2 +-
 .../getting-started/locally/quick-start-flink.md   |  37 +-
 .../getting-started/locally/quick-start-spark.md   |  37 +-
 29 files changed, 714 insertions(+), 539 deletions(-)

diff --git a/docs/en/architecture/api-design/catalog-table.md 
b/docs/en/architecture/api-design/catalog-table.md
index 1a15c247613..b2fef831433 100644
--- a/docs/en/architecture/api-design/catalog-table.md
+++ b/docs/en/architecture/api-design/catalog-table.md
@@ -80,65 +80,73 @@ public class TableSchema implements Serializable {
 
 ### 2.3 Column
 
-Column definition with type and constraints.
+Column definition with type and constraints. `Column` is abstract; regular 
table columns are
+`PhysicalColumn` instances (`MetadataColumn` is the other subclass).
 
 ```java
-public class Column implements Serializable {
-    private final String name;
-    private final SeaTunnelDataType<?> dataType;
-    private final String comment;
+public abstract class Column implements Serializable {
+    protected final String name;
+    protected final SeaTunnelDataType<?> dataType;
 
-    // Column options
-    private final Map<String, Object> options;
+    // Length / scale of the column, e.g. VARCHAR(255) or DECIMAL(10, 2)
+    protected final Long columnLength;
+    protected final Integer scale;
 
     // Constraints
-    private final boolean nullable;
-    private final Object defaultValue;
+    protected final boolean nullable;
+    protected final Object defaultValue;
+
+    protected final String comment;
+
+    // Original type in the source system, e.g. "varchar(255)"
+    protected final String sourceType;
+
+    // Column options
+    protected final Map<String, Object> options;
 }
 ```
 
 ### 2.4 SeaTunnelDataType
 
-Unified type system across connectors.
+Unified type system across connectors. Types are constants or classes in the
+`org.apache.seatunnel.api.table.type` package (there is no `DataTypes` factory 
class).
 
 **Basic Types**:
 ```java
 // Numeric
-DataTypes.TINYINT()
-DataTypes.SMALLINT()
-DataTypes.INT()
-DataTypes.BIGINT()
-DataTypes.FLOAT()
-DataTypes.DOUBLE()
-DataTypes.DECIMAL(precision, scale)
-
-// String
-DataTypes.STRING()
-DataTypes.CHAR(length)
-DataTypes.VARCHAR(length)
+BasicType.BYTE_TYPE      // TINYINT
+BasicType.SHORT_TYPE     // SMALLINT
+BasicType.INT_TYPE       // INT
+BasicType.LONG_TYPE      // BIGINT
+BasicType.FLOAT_TYPE     // FLOAT
+BasicType.DOUBLE_TYPE    // DOUBLE
+new DecimalType(precision, scale)
+
+// String (CHAR/VARCHAR length is kept in Column#columnLength, not in the type)
+BasicType.STRING_TYPE
 
 // Binary
-DataTypes.BYTES()
+PrimitiveByteArrayType.INSTANCE
 
 // Date/Time
-DataTypes.DATE()
-DataTypes.TIME()
-DataTypes.TIMESTAMP()
+LocalTimeType.LOCAL_DATE_TYPE        // DATE
+LocalTimeType.LOCAL_TIME_TYPE        // TIME
+LocalTimeType.LOCAL_DATE_TIME_TYPE   // TIMESTAMP
 
 // Boolean
-DataTypes.BOOLEAN()
+BasicType.BOOLEAN_TYPE
 ```
 
 **Complex Types**:
 ```java
 // Array
-DataTypes.ARRAY(elementType)
+ArrayType.of(elementType)          // or constants such as 
ArrayType.INT_ARRAY_TYPE
 
 // Map
-DataTypes.MAP(keyType, valueType)
+new MapType<>(keyType, valueType)
 
 // Row (Struct)
-DataTypes.ROW(fields)
+new SeaTunnelRowType(fieldNames, fieldTypes)
 ```
 
 ## 3. Schema Creation
@@ -149,11 +157,11 @@ DataTypes.ROW(fields)
 CatalogTable catalogTable = CatalogTable.of(
     TableIdentifier.of("my_catalog", "my_db", "my_table"),
     TableSchema.builder()
-        .column("id", DataTypes.BIGINT())
-        .column("name", DataTypes.STRING())
-        .column("age", DataTypes.INT())
-        .column("created_at", DataTypes.TIMESTAMP())
-        .primaryKey("id")
+        
.column(PhysicalColumn.builder().name("id").dataType(BasicType.LONG_TYPE).build())
+        
.column(PhysicalColumn.builder().name("name").dataType(BasicType.STRING_TYPE).nullable(true).build())
+        
.column(PhysicalColumn.builder().name("age").dataType(BasicType.INT_TYPE).nullable(true).build())
+        
.column(PhysicalColumn.builder().name("created_at").dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE).nullable(true).build())
+        .primaryKey(PrimaryKey.of("pk_id", Collections.singletonList("id")))
         .build(),
     Map.of("connector", "jdbc"),
     Collections.emptyList(), // No partitions
@@ -161,31 +169,38 @@ CatalogTable catalogTable = CatalogTable.of(
 );
 ```
 
+`TableSchema.Builder` only accepts `Column` objects (`column(Column)` / 
`columns(List<Column>)`)
+and a `PrimaryKey` object. Note that the `PhysicalColumn` builder leaves 
`nullable` as `false`
+unless it is set explicitly.
+
 ### 3.2 Column Builder
 
 ```java
-Column column = Column.builder()
+Column column = PhysicalColumn.builder()
     .name("user_id")
-    .dataType(DataTypes.BIGINT())
+    .dataType(BasicType.LONG_TYPE)
     .nullable(false)
     .defaultValue(0L)
     .comment("User identifier")
     .build();
 ```
 
+`PhysicalColumn.of(name, dataType, columnLength, nullable, defaultValue, 
comment)` is an
+equivalent factory method.
+
 ### 3.3 Primary Key and Constraints
 
 ```java
 TableSchema schema = TableSchema.builder()
-    .column("id", DataTypes.BIGINT())
-    .column("email", DataTypes.STRING())
-    .column("username", DataTypes.STRING())
+    
.column(PhysicalColumn.builder().name("id").dataType(BasicType.LONG_TYPE).build())
+    
.column(PhysicalColumn.builder().name("email").dataType(BasicType.STRING_TYPE).build())
+    
.column(PhysicalColumn.builder().name("username").dataType(BasicType.STRING_TYPE).build())
 
     // Primary key
-    .primaryKey("id")
+    .primaryKey(PrimaryKey.of("pk_id", Collections.singletonList("id")))
 
     // Unique constraint
-    .constraint(ConstraintKey.of(
+    .constraintKey(ConstraintKey.of(
         ConstraintKey.ConstraintType.UNIQUE_KEY,
         "uk_email",
         Arrays.asList(
@@ -235,13 +250,17 @@ public class JdbcSource implements SeaTunnelSource<...> {
             int jdbcType = columns.getInt("DATA_TYPE");
             SeaTunnelDataType<?> type = JdbcTypeConverter.convert(jdbcType);
 
-            builder.column(columnName, type);
+            builder.column(
+                
PhysicalColumn.builder().name(columnName).dataType(type).nullable(true).build());
         }
 
         return Collections.singletonList(
             CatalogTable.of(
                 TableIdentifier.of(catalog, database, schema, table),
-                builder.build()
+                builder.build(),
+                Collections.emptyMap(),   // options
+                Collections.emptyList(),  // partition keys
+                null                      // comment
             )
         );
     }
@@ -251,20 +270,30 @@ public class JdbcSource implements SeaTunnelSource<...> {
 ### 4.3 Transform Schema Transformation
 
 ```java
-public class SqlTransform implements SeaTunnelTransform {
+public class SqlTransform implements SeaTunnelTransform<SeaTunnelRow> {
     @Override
     public CatalogTable getProducedCatalogTable() {
         CatalogTable inputTable = getInputCatalogTable();
+        TableSchema inputSchema = inputTable.getTableSchema();
 
         // Parse SQL to infer output schema
         // Example: SELECT id, UPPER(name) as name_upper, age FROM input
         TableSchema outputSchema = TableSchema.builder()
-            .column("id", inputTable.getColumn("id").getDataType())
-            .column("name_upper", DataTypes.STRING()) // Transformed
-            .column("age", inputTable.getColumn("age").getDataType())
+            .column(inputSchema.getColumn("id").copy())
+            .column(PhysicalColumn.builder()
+                .name("name_upper")
+                .dataType(BasicType.STRING_TYPE) // Transformed
+                .nullable(true)
+                .build())
+            .column(inputSchema.getColumn("age").copy())
             .build();
 
-        return inputTable.copy(outputSchema);
+        return CatalogTable.of(
+            inputTable.getTableId(),
+            outputSchema,
+            inputTable.getOptions(),
+            inputTable.getPartitionKeys(),
+            inputTable.getComment());
     }
 }
 ```
@@ -276,15 +305,17 @@ public class JdbcSink implements SeaTunnelSink<...> {
     @Override
     public Optional<CatalogTable> getWriteCatalogTable() {
         // Validate input schema matches target table
-        CatalogTable inputTable = getInputCatalogTable();
         CatalogTable targetTable = readTargetTableSchema();
+        TableSchema inputSchema = getInputCatalogTable().getTableSchema();
+        TableSchema targetSchema = targetTable.getTableSchema();
 
         // Check column compatibility
-        for (Column inputColumn : inputTable.getColumns()) {
-            Column targetColumn = targetTable.getColumn(inputColumn.getName());
-            if (targetColumn == null) {
+        for (Column inputColumn : inputSchema.getColumns()) {
+            // getColumn() throws for an unknown name, so check contains() 
first
+            if (!targetSchema.contains(inputColumn.getName())) {
                 throw new SchemaException("Column not found: " + 
inputColumn.getName());
             }
+            Column targetColumn = 
targetSchema.getColumn(inputColumn.getName());
 
             if (!isCompatible(inputColumn.getDataType(), 
targetColumn.getDataType())) {
                 throw new SchemaException("Incompatible types for " + 
inputColumn.getName());
@@ -303,20 +334,34 @@ public class JdbcSink implements SeaTunnelSink<...> {
 Represents DDL changes captured by CDC sources.
 
 ```java
-public abstract class SchemaChangeEvent implements Serializable {
-    private final TableIdentifier tableId;
+public interface SchemaChangeEvent extends Event {
+    TableIdentifier tableIdentifier();
+
+    default TablePath tablePath() {
+        return tableIdentifier().toTablePath();
+    }
+
+    // Table schema after the change, filled in along the pipeline
+    CatalogTable getChangeAfter();
+
+    void setChangeAfter(CatalogTable table);
 }
 
-public class AlterTableAddColumnEvent extends SchemaChangeEvent {
+// TableEvent implements SchemaChangeEvent; AlterTableEvent and 
AlterTableColumnEvent extend it
+public class AlterTableAddColumnEvent extends AlterTableColumnEvent {
     private final Column column;
+    private final boolean first;
+    private final String afterColumn;
 }
 
-public class AlterTableDropColumnEvent extends SchemaChangeEvent {
-    private final String columnName;
+public class AlterTableDropColumnEvent extends AlterTableColumnEvent {
+    private final String column;
 }
 
-public class AlterTableModifyColumnEvent extends SchemaChangeEvent {
+public class AlterTableModifyColumnEvent extends AlterTableColumnEvent {
     private final Column column;
+    private final boolean first;
+    private final String afterColumn;
 }
 ```
 
@@ -329,9 +374,9 @@ public class MysqlCDCSource {
         if (ddl.contains("ADD COLUMN")) {
             Column newColumn = parseDDL(ddl);
 
-            // Create schema change event
-            SchemaChangeEvent event = new AlterTableAddColumnEvent(
-                tableId,
+            // Create schema change event (see also addFirst / addAfter)
+            SchemaChangeEvent event = AlterTableAddColumnEvent.add(
+                tableIdentifier,
                 newColumn
             );
 
@@ -354,8 +399,8 @@ public class SqlTransform {
             // Map column through transform logic
             Column transformedColumn = transformColumn(addEvent.getColumn());
 
-            return new AlterTableAddColumnEvent(
-                event.getTableId(),
+            return AlterTableAddColumnEvent.add(
+                event.tableIdentifier(),
                 transformedColumn
             );
         }
@@ -377,7 +422,7 @@ public class JdbcSink {
             // Generate DDL
             String ddl = String.format(
                 "ALTER TABLE %s ADD COLUMN %s %s",
-                event.getTableId().getTableName(),
+                event.tablePath().getTableName(),
                 column.getName(),
                 toSqlType(column.getDataType())
             );
@@ -395,44 +440,48 @@ public class JdbcSink {
 
 ### 6.1 JDBC Type Mapping
 
+Simplified illustration. Real connectors implement
+`org.apache.seatunnel.api.table.converter.TypeConverter`, for example the JDBC 
dialect converters
+such as `MySqlTypeConverter`, which return a whole `Column` so that length, 
precision and scale are
+kept on the column.
+
 ```java
 public class JdbcTypeConverter {
     public static SeaTunnelDataType<?> convert(int jdbcType) {
         switch (jdbcType) {
             case Types.TINYINT:
-                return DataTypes.TINYINT();
+                return BasicType.BYTE_TYPE;
             case Types.SMALLINT:
-                return DataTypes.SMALLINT();
+                return BasicType.SHORT_TYPE;
             case Types.INTEGER:
-                return DataTypes.INT();
+                return BasicType.INT_TYPE;
             case Types.BIGINT:
-                return DataTypes.BIGINT();
+                return BasicType.LONG_TYPE;
             case Types.FLOAT:
             case Types.REAL:
-                return DataTypes.FLOAT();
+                return BasicType.FLOAT_TYPE;
             case Types.DOUBLE:
-                return DataTypes.DOUBLE();
+                return BasicType.DOUBLE_TYPE;
             case Types.DECIMAL:
             case Types.NUMERIC:
-                return DataTypes.DECIMAL(precision, scale);
+                return new DecimalType(precision, scale);
             case Types.CHAR:
-                return DataTypes.CHAR(length);
             case Types.VARCHAR:
-                return DataTypes.VARCHAR(length);
             case Types.LONGVARCHAR:
-                return DataTypes.STRING();
+                // The declared length is kept in Column#columnLength
+                return BasicType.STRING_TYPE;
             case Types.DATE:
-                return DataTypes.DATE();
+                return LocalTimeType.LOCAL_DATE_TYPE;
             case Types.TIME:
-                return DataTypes.TIME();
+                return LocalTimeType.LOCAL_TIME_TYPE;
             case Types.TIMESTAMP:
-                return DataTypes.TIMESTAMP();
+                return LocalTimeType.LOCAL_DATE_TIME_TYPE;
             case Types.BOOLEAN:
-                return DataTypes.BOOLEAN();
+                return BasicType.BOOLEAN_TYPE;
             case Types.BINARY:
             case Types.VARBINARY:
             case Types.LONGVARBINARY:
-                return DataTypes.BYTES();
+                return PrimitiveByteArrayType.INSTANCE;
             default:
                 throw new UnsupportedTypeException("Unsupported JDBC type: " + 
jdbcType);
         }
@@ -447,36 +496,36 @@ public class AvroTypeConverter {
     public static SeaTunnelDataType<?> convert(Schema avroSchema) {
         switch (avroSchema.getType()) {
             case INT:
-                return DataTypes.INT();
+                return BasicType.INT_TYPE;
             case LONG:
-                return DataTypes.BIGINT();
+                return BasicType.LONG_TYPE;
             case FLOAT:
-                return DataTypes.FLOAT();
+                return BasicType.FLOAT_TYPE;
             case DOUBLE:
-                return DataTypes.DOUBLE();
+                return BasicType.DOUBLE_TYPE;
             case BOOLEAN:
-                return DataTypes.BOOLEAN();
+                return BasicType.BOOLEAN_TYPE;
             case STRING:
-                return DataTypes.STRING();
+                return BasicType.STRING_TYPE;
             case BYTES:
-                return DataTypes.BYTES();
+                return PrimitiveByteArrayType.INSTANCE;
             case ARRAY:
-                return DataTypes.ARRAY(convert(avroSchema.getElementType()));
+                return ArrayType.of(convert(avroSchema.getElementType()));
             case MAP:
-                return DataTypes.MAP(
-                    DataTypes.STRING(),
+                return new MapType<>(
+                    BasicType.STRING_TYPE,
                     convert(avroSchema.getValueType())
                 );
             case RECORD:
                 // Convert to ROW type
-                List<TableSchema.Column> fields = new ArrayList<>();
-                for (Schema.Field field : avroSchema.getFields()) {
-                    fields.add(new Column(
-                        field.name(),
-                        convert(field.schema())
-                    ));
+                List<Schema.Field> avroFields = avroSchema.getFields();
+                String[] fieldNames = new String[avroFields.size()];
+                SeaTunnelDataType<?>[] fieldTypes = new 
SeaTunnelDataType<?>[avroFields.size()];
+                for (int i = 0; i < avroFields.size(); i++) {
+                    fieldNames[i] = avroFields.get(i).name();
+                    fieldTypes[i] = convert(avroFields.get(i).schema());
                 }
-                return DataTypes.ROW(fields);
+                return new SeaTunnelRowType(fieldNames, fieldTypes);
             default:
                 throw new UnsupportedTypeException("Unsupported Avro type: " + 
avroSchema.getType());
         }
@@ -556,8 +605,8 @@ public class IcebergSink {
 ```java
 // ✅ GOOD: Explicit schema
 TableSchema schema = TableSchema.builder()
-    .column("id", DataTypes.BIGINT())
-    .column("name", DataTypes.STRING())
+    
.column(PhysicalColumn.builder().name("id").dataType(BasicType.LONG_TYPE).build())
+    
.column(PhysicalColumn.builder().name("name").dataType(BasicType.STRING_TYPE).nullable(true).build())
     .build();
 
 // ❌ BAD: Implicit schema (relies on inference)
@@ -567,12 +616,12 @@ TableSchema schema = TableSchema.builder()
 **Use Appropriate Types**:
 ```java
 // ✅ GOOD: Use specific types
-.column("price", DataTypes.DECIMAL(10, 2))
-.column("created_at", DataTypes.TIMESTAMP())
+PhysicalColumn.builder().name("price").dataType(new DecimalType(10, 
2)).build();
+PhysicalColumn.builder().name("created_at").dataType(LocalTimeType.LOCAL_DATE_TIME_TYPE).build();
 
 // ❌ BAD: Overly generic types
-.column("price", DataTypes.STRING()) // Should be DECIMAL
-.column("created_at", DataTypes.STRING()) // Should be TIMESTAMP
+PhysicalColumn.builder().name("price").dataType(BasicType.STRING_TYPE).build();
 // Should be DECIMAL
+PhysicalColumn.builder().name("created_at").dataType(BasicType.STRING_TYPE).build();
 // Should be TIMESTAMP
 ```
 
 ### 8.2 Schema Validation
@@ -615,13 +664,18 @@ public void open() {
 
 ### 9.1 Schema Override
 
+Sources that cannot read a schema from the external system accept a 
user-declared `schema` block.
+Sources such as `Jdbc` derive the schema from table or query metadata instead; 
for `Jdbc`, `schema`
+is a string option that names the database schema, not a field list.
+
 ```hocon
 source {
-  JDBC {
-    url = "..."
-    query = "SELECT * FROM users"
+  Kafka {
+    bootstrap.servers = "localhost:9092"
+    topic = "users"
+    format = json
 
-    # Override inferred schema
+    # Declare the schema of the JSON messages
     schema {
       fields {
         id = "BIGINT"
@@ -635,18 +689,37 @@ source {
 
 ### 9.2 Schema Evolution Control
 
+There is no `schema-evolution` block. Schema evolution is enabled on CDC 
sources with
+`schema-changes.enabled` (disabled by default), and the sink's 
`schema_save_mode` decides how the
+target table is prepared when the job starts. See
+[Schema Evolution](../../introduction/configuration/schema-evolution.md) for 
the supported
+connectors and change types.
+
 ```hocon
+source {
+  MySQL-CDC {
+    url = "jdbc:mysql://localhost:3306"
+    username = "..."
+    password = "..."
+    table-names = ["mydb.users"]
+
+    # Emit DDL changes downstream as SchemaChangeEvents
+    schema-changes.enabled = true
+  }
+}
+
 sink {
-  JDBC {
-    url = "..."
-
-    # Schema evolution options
-    schema-evolution {
-      enabled = true
-      auto-create-table = true
-      auto-add-column = true
-      auto-drop-column = false # Dangerous!
-    }
+  Jdbc {
+    url = "jdbc:mysql://localhost:3306/target"
+    driver = "com.mysql.cj.jdbc.Driver"
+    username = "..."
+    password = "..."
+    generate_sink_sql = true
+    database = "target"
+    table = "${table_name}"
+
+    # Create the target table when it does not exist
+    schema_save_mode = "CREATE_SCHEMA_WHEN_NOT_EXIST"
   }
 }
 ```
diff --git a/docs/en/architecture/api-design/sink-architecture.md 
b/docs/en/architecture/api-design/sink-architecture.md
index 7a49559b754..9d81d278328 100644
--- a/docs/en/architecture/api-design/sink-architecture.md
+++ b/docs/en/architecture/api-design/sink-architecture.md
@@ -77,7 +77,10 @@ The top-level interface that serves as a factory for 
creating writers and commit
 
 ```java
 public interface SeaTunnelSink<IN, StateT, CommitInfoT, AggregatedCommitInfoT>
-    extends Serializable {
+    extends Serializable,
+        PluginIdentifierInterface, // requires String getPluginName()
+        SeaTunnelPluginLifeCycle,
+        SeaTunnelJobAware {
 
     /**
      * Create SinkWriter (called on worker)
@@ -226,21 +229,32 @@ public interface SinkWriter<IN, CommitInfoT, StateT> {
     void write(IN element) throws IOException;
 
     /**
-     * Prepare commit info during checkpoint.
+     * Prepare commit info during checkpoint (deprecated, but still the 
abstract method
+     * every writer must implement).
      *
      * Guideline: do not make data externally visible in this phase.
      */
-    Optional<CommitInfoT> prepareCommit(long checkpointId) throws IOException;
+    @Deprecated
+    Optional<CommitInfoT> prepareCommit() throws IOException;
+
+    /**
+     * Checkpoint-aware variant called by the engine. Delegates to 
prepareCommit() by default.
+     */
+    default Optional<CommitInfoT> prepareCommit(long checkpointId) throws 
IOException {
+        return prepareCommit();
+    }
 
     /**
-     * Abort prepared commit if checkpoint fails
+     * Abort prepared commit if prepareCommit fails
      */
     void abortPrepare();
 
     /**
-     * Snapshot writer state for checkpoint
+     * Snapshot writer state for checkpoint. Stateless writers can keep the 
default.
      */
-    List<StateT> snapshotState(long checkpointId) throws IOException;
+    default List<StateT> snapshotState(long checkpointId) throws IOException {
+        return Collections.emptyList();
+    }
 
     /**
      * Close writer
@@ -260,8 +274,9 @@ public interface SinkWriter<IN, CommitInfoT, StateT> {
 **Critical Requirements**:
 - `prepareCommit(checkpointId)` should not make data externally visible 
(commit is done in `SinkCommitter` / `SinkAggregatedCommitter`)
 - `prepareCommit(checkpointId)` returns commit info that will be passed to 
committer
+- The no-arg `prepareCommit()` is still abstract, so a writer that overrides 
`prepareCommit(checkpointId)` must implement it as well (the examples below 
omit it for brevity)
 - State returned by `snapshotState()` must capture all uncommitted writes
-- `abortPrepare()` is only used by Spark when `prepareCommit(...)` fails by 
throwing an exception
+- `abortPrepare()` is called when `prepareCommit(...)` fails by throwing an 
exception. Spark calls it, and the SeaTunnel Engine also calls it from the sink 
task before rethrowing the failure
 
 **Implementation Example (JDBC with XA Transactions)**:
 
@@ -381,26 +396,25 @@ public class FileSinkWriter implements 
SinkWriter<SeaTunnelRow, FileCommitInfo,
 
 ### 3.2 SinkCommitter Interface
 
-The committer runs on master and coordinates commits from multiple writers.
+The committer completes the second phase of the commit for the commit infos 
produced by writers.
+Where it runs depends on the engine: in the SeaTunnel Engine each sink task 
creates its own
+committer on the worker side and calls `commit()` from 
`notifyCheckpointComplete` (see section 2.2).
 
 ```java
-public interface SinkCommitter<CommitInfoT> extends Closeable {
+public interface SinkCommitter<CommitInfoT> extends Serializable {
 
     /**
      * Commit multiple commit infos (from multiple writers or retries)
      * MUST be idempotent - may be called multiple times with same commitInfo
+     * Returns the commit infos that need to be retried
      */
     List<CommitInfoT> commit(List<CommitInfoT> commitInfos) throws IOException;
 
     /**
-     * Abort commit infos (optional)
-     */
-    default void abort(List<CommitInfoT> commitInfos) throws IOException {}
-
-    /**
-     * Close committer
+     * Abort commit infos. Abstract: every committer must implement it.
+     * Spark calls it when a write task is aborted; the SeaTunnel Engine calls 
it when a checkpoint is aborted.
      */
-    void close() throws IOException;
+    void abort(List<CommitInfoT> commitInfos) throws IOException;
 }
 ```
 
@@ -497,6 +511,14 @@ public class FileSinkCommitter implements 
SinkCommitter<FileCommitInfo> {
 
         return failed;
     }
+
+    @Override
+    public void abort(List<FileCommitInfo> commitInfos) throws IOException {
+        // Remove the temporary files of the aborted commit
+        for (FileCommitInfo commitInfo : commitInfos) {
+            fileSystem.delete(new Path(commitInfo.getTempFilePath()), false);
+        }
+    }
 }
 ```
 
@@ -506,30 +528,38 @@ The aggregated committer performs single global commit 
for all writers.
 
 ```java
 public interface SinkAggregatedCommitter<CommitInfoT, AggregatedCommitInfoT>
-    extends Closeable {
+    extends Serializable {
 
     /**
-     * Combine commit infos from multiple writers into single aggregated info
+     * Initialize the committer. Called on every (re)start, not only once.
      */
-    AggregatedCommitInfoT combine(List<CommitInfoT> commitInfos);
+    default void init() {}
+
+    /**
+     * Re-commit restored aggregated commit infos after a failover.
+     * The default simply calls commit() again, so commit() MUST be idempotent.
+     */
+    default List<AggregatedCommitInfoT> restoreCommit(
+        List<AggregatedCommitInfoT> aggregatedCommitInfos) throws IOException {
+        return commit(aggregatedCommitInfos);
+    }
 
     /**
      * Commit aggregated info (single global operation)
-     * MUST be idempotent
+     * MUST be idempotent. Returns the infos that need to be retried.
      */
     List<AggregatedCommitInfoT> commit(List<AggregatedCommitInfoT> 
aggregatedCommitInfos)
         throws IOException;
 
     /**
-     * Abort aggregated commit infos
+     * Combine commit infos from multiple writers into single aggregated info
      */
-    default void abort(List<AggregatedCommitInfoT> aggregatedCommitInfos) 
throws IOException {}
+    AggregatedCommitInfoT combine(List<CommitInfoT> commitInfos);
 
     /**
-     * Restore committer state from checkpoint
+     * Abort aggregated commit infos. Abstract: every aggregated committer 
must implement it.
      */
-    default void restoreCommit(List<AggregatedCommitInfoT> 
aggregatedCommitInfos)
-        throws IOException {}
+    void abort(List<AggregatedCommitInfoT> aggregatedCommitInfos) throws 
Exception;
 
     /**
      * Close committer
@@ -583,6 +613,14 @@ public class HiveAggregatedCommitter
 
         return failed;
     }
+
+    @Override
+    public void abort(List<HiveCommitInfo> aggregatedCommitInfos) {
+        // Clean up the files written for the aborted commit
+    }
+
+    @Override
+    public void close() {}
 }
 ```
 
diff --git a/docs/en/architecture/api-design/source-architecture.md 
b/docs/en/architecture/api-design/source-architecture.md
index 7ce518770a3..28cd94cb7d3 100644
--- a/docs/en/architecture/api-design/source-architecture.md
+++ b/docs/en/architecture/api-design/source-architecture.md
@@ -70,7 +70,10 @@ The top-level interface that serves as a factory for 
creating readers and enumer
 
 ```java
 public interface SeaTunnelSource<T, SplitT extends SourceSplit, StateT extends 
Serializable>
-    extends Serializable {
+    extends Serializable,
+        PluginIdentifierInterface, // requires String getPluginName()
+        SeaTunnelPluginLifeCycle,
+        SeaTunnelJobAware {
 
     /**
      * Get source boundedness (BOUNDED for batch, UNBOUNDED for streaming)
@@ -83,9 +86,11 @@ public interface SeaTunnelSource<T, SplitT extends 
SourceSplit, StateT extends S
     SourceReader<T, SplitT> createReader(SourceReader.Context readerContext) 
throws Exception;
 
     /**
-     * Split serializer used for network transfer and checkpointing.
+     * Split serializer used for network transfer and checkpointing (optional).
      */
-    Serializer<SplitT> getSplitSerializer();
+    default Serializer<SplitT> getSplitSerializer() {
+        return new DefaultSerializer<>();
+    }
 
     /**
      * Create SourceSplitEnumerator (called on master)
@@ -101,14 +106,20 @@ public interface SeaTunnelSource<T, SplitT extends 
SourceSplit, StateT extends S
         StateT checkpointState) throws Exception;
 
     /**
-     * Enumerator-state serializer used for checkpointing.
+     * Enumerator-state serializer used for checkpointing (optional).
      */
-    Serializer<StateT> getEnumeratorStateSerializer();
+    default Serializer<StateT> getEnumeratorStateSerializer() {
+        return new DefaultSerializer<>();
+    }
 
     /**
-     * Get output schema (CatalogTable list, supports multi-table)
+     * Get output schema (CatalogTable list, supports multi-table).
+     * The default throws UnsupportedOperationException, so sources must 
override it.
      */
-    List<CatalogTable> getProducedCatalogTables();
+    default List<CatalogTable> getProducedCatalogTables() {
+        throw new UnsupportedOperationException(
+            "getProducedCatalogTables method has not been implemented.");
+    }
 }
 ```
 
@@ -118,7 +129,7 @@ public interface SeaTunnelSource<T, SplitT extends 
SourceSplit, StateT extends S
 - `createEnumerator()`: Factory for enumerator (single instance on master)
 - `restoreEnumerator()`: Restore enumerator from checkpoint state
 - `getProducedCatalogTables()`: Defines output schema (supports multi-table)
-- `getSplitSerializer()` / `getEnumeratorStateSerializer()`: 
Split/enumerator-state serializers for network transfer and checkpointing
+- `getSplitSerializer()` / `getEnumeratorStateSerializer()`: Optional 
split/enumerator-state serializers for network transfer and checkpointing; both 
default to `DefaultSerializer` (Java serialization)
 
 #### SourceSplit (Minimal Serializable Unit)
 
diff --git a/docs/en/architecture/api-design/translation-layer.md 
b/docs/en/architecture/api-design/translation-layer.md
index 02a45b979a4..454d74f9d84 100644
--- a/docs/en/architecture/api-design/translation-layer.md
+++ b/docs/en/architecture/api-design/translation-layer.md
@@ -72,55 +72,67 @@ Read the rest of this page when you want the combined view 
of shared translation
 
 ### 2.1 FlinkSource Adapter
 
-Adapts `SeaTunnelSource` to Flink's `Source` interface.
+Adapts `SeaTunnelSource` to Flink's `Source` interface. The Flink-side record 
type is always
+`SeaTunnelRow`, splits are wrapped in `SplitWrapper`, and the enumerator state 
type is passed to
+Flink as is.
 
 ```java
-public class FlinkSource<T, SplitT extends SourceSplit, StateT>
-    implements Source<T, SplitWrapper<SplitT>, EnumeratorStateWrapper<StateT>> 
{
+public class FlinkSource<SplitT extends SourceSplit, EnumStateT extends 
Serializable>
+    implements Source<SeaTunnelRow, SplitWrapper<SplitT>, EnumStateT>,
+        ResultTypeQueryable<SeaTunnelRow> {
 
     // Wrapped SeaTunnel source
-    private final SeaTunnelSource<T, SplitT, StateT> seaTunnelSource;
+    private final SeaTunnelSource<SeaTunnelRow, SplitT, EnumStateT> source;
+    private final Config envConfig;
 
     @Override
     public Boundedness getBoundedness() {
         // Delegate to SeaTunnel source
-        return seaTunnelSource.getBoundedness() == Boundedness.BOUNDED
+        return source.getBoundedness() == 
org.apache.seatunnel.api.source.Boundedness.BOUNDED
             ? Boundedness.BOUNDED
             : Boundedness.CONTINUOUS_UNBOUNDED;
     }
 
     @Override
-    public SourceReader<T, SplitWrapper<SplitT>> createReader(
+    public SourceReader<SeaTunnelRow, SplitWrapper<SplitT>> createReader(
         SourceReaderContext readerContext
-    ) {
+    ) throws Exception {
         // Create SeaTunnel reader with adapted context
-        org.apache.seatunnel.api.source.SourceReader<T, SplitT> 
seaTunnelReader =
-            seaTunnelSource.createReader(new 
FlinkSourceReaderContext(readerContext));
+        org.apache.seatunnel.api.source.SourceReader.Context context =
+            new FlinkSourceReaderContext(readerContext, source);
+        org.apache.seatunnel.api.source.SourceReader<SeaTunnelRow, SplitT> 
reader =
+            source.createReader(context);
 
         // Wrap in Flink adapter
-        return new FlinkSourceReader<>(seaTunnelReader, readerContext);
+        return new FlinkSourceReader<>(reader, context, envConfig);
     }
 
     @Override
-    public SplitEnumerator<SplitWrapper<SplitT>, 
EnumeratorStateWrapper<StateT>>
-        createEnumerator(SplitEnumeratorContext<SplitWrapper<SplitT>> context) 
{
+    public SplitEnumerator<SplitWrapper<SplitT>, EnumStateT> createEnumerator(
+        SplitEnumeratorContext<SplitWrapper<SplitT>> enumContext) throws 
Exception {
+
+        // Readers that were told "no more splits", re-signaled after a 
failover
+        Set<Integer> noMoreSplitsSignaledReaders = 
ConcurrentHashMap.newKeySet();
 
         // Create SeaTunnel enumerator with adapted context
-        SourceSplitEnumerator<SplitT, StateT> seaTunnelEnumerator =
-            seaTunnelSource.createEnumerator(
-                new FlinkSourceSplitEnumeratorContext<>(context)
-            );
+        SourceSplitEnumerator<SplitT, EnumStateT> enumerator =
+            source.createEnumerator(
+                new FlinkSourceSplitEnumeratorContext<>(
+                    enumContext, noMoreSplitsSignaledReaders::add));
 
         // Wrap in Flink adapter
-        return new FlinkSourceEnumerator<>(seaTunnelEnumerator, context);
+        return new FlinkSourceEnumerator<>(enumerator, enumContext, 
noMoreSplitsSignaledReaders);
     }
 
     @Override
     public SimpleVersionedSerializer<SplitWrapper<SplitT>> 
getSplitSerializer() {
         // Adapt SeaTunnel serializer to Flink serializer
-        return new FlinkSimpleVersionedSerializer<>(
-            seaTunnelSource.getSplitSerializer()
-        );
+        return new SplitWrapperSerializer<>(source.getSplitSerializer());
+    }
+
+    @Override
+    public SimpleVersionedSerializer<EnumStateT> 
getEnumeratorCheckpointSerializer() {
+        return new 
FlinkSimpleVersionedSerializer<>(source.getEnumeratorStateSerializer());
     }
 }
 ```
@@ -128,71 +140,63 @@ public class FlinkSource<T, SplitT extends SourceSplit, 
StateT>
 ### 2.2 FlinkSourceReader Adapter
 
 ```java
-public class FlinkSourceReader<T, SplitT extends SourceSplit>
-    implements SourceReader<T, SplitWrapper<SplitT>> {
+public class FlinkSourceReader<SplitT extends SourceSplit>
+    implements SourceReader<SeaTunnelRow, SplitWrapper<SplitT>> {
+
+    private final org.apache.seatunnel.api.source.SourceReader<SeaTunnelRow, 
SplitT> sourceReader;
+    private final org.apache.seatunnel.api.source.SourceReader.Context context;
+
+    // Adapts Flink's ReaderOutput to SeaTunnel's Collector
+    private final FlinkRowCollector flinkRowCollector;
 
-    private final org.apache.seatunnel.api.source.SourceReader<T, SplitT> 
seaTunnelReader;
-    private final SourceReaderContext flinkContext;
+    private InputStatus inputStatus = InputStatus.MORE_AVAILABLE;
 
     @Override
     public void start() {
         // Delegate to SeaTunnel reader
         try {
-            seaTunnelReader.open();
+            sourceReader.open();
         } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to open SeaTunnel reader", 
e);
+            throw new RuntimeException(e);
         }
     }
 
     @Override
-    public InputStatus pollNext(ReaderOutput<T> output) {
-        try {
-            // Adapt output collector
-            CollectorAdapter<T> collector = new CollectorAdapter<>(output);
-
-            // Poll from SeaTunnel reader
-            seaTunnelReader.pollNext(collector);
+    public InputStatus pollNext(ReaderOutput<SeaTunnelRow> output) throws 
Exception {
+        // Poll from SeaTunnel reader through the adapted collector
+        sourceReader.pollNext(flinkRowCollector.withReaderOutput(output));
 
-            if (collector.hasRecords()) {
-                return InputStatus.MORE_AVAILABLE;
-            } else {
-                return InputStatus.NOTHING_AVAILABLE;
-            }
-        } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to poll from SeaTunnel 
reader", e);
+        if (flinkRowCollector.isEmptyThisPollNext()) {
+            // Schedules the availability future to complete after a short wait
+            return InputStatus.NOTHING_AVAILABLE;
         }
+        // Switched to END_OF_INPUT once the enumerator relays 
NoMoreElementEvent back
+        return inputStatus;
     }
 
     @Override
     public void addSplits(List<SplitWrapper<SplitT>> splits) {
         // Unwrap and delegate
-        List<SplitT> unwrappedSplits = splits.stream()
-            .map(SplitWrapper::getSplit)
-            .collect(Collectors.toList());
-
-        seaTunnelReader.addSplits(unwrappedSplits);
+        sourceReader.addSplits(
+            
splits.stream().map(SplitWrapper::getSourceSplit).collect(Collectors.toList()));
     }
 
     @Override
-    public void notifyCheckpointComplete(long checkpointId) {
-        try {
-            seaTunnelReader.notifyCheckpointComplete(checkpointId);
-        } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to notify checkpoint 
complete", e);
-        }
+    public void notifyCheckpointComplete(long checkpointId) throws Exception {
+        sourceReader.notifyCheckpointComplete(checkpointId);
     }
 
     @Override
     public List<SplitWrapper<SplitT>> snapshotState(long checkpointId) {
         try {
-            List<SplitT> state = seaTunnelReader.snapshotState(checkpointId);
+            List<SplitT> state = sourceReader.snapshotState(checkpointId);
 
             // Wrap splits for Flink
             return state.stream()
                 .map(SplitWrapper::new)
                 .collect(Collectors.toList());
         } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to snapshot state", e);
+            throw new RuntimeException(e);
         }
     }
 }
@@ -201,51 +205,49 @@ public class FlinkSourceReader<T, SplitT extends 
SourceSplit>
 ### 2.3 FlinkSourceEnumerator Adapter
 
 ```java
-public class FlinkSourceEnumerator<SplitT extends SourceSplit, StateT>
-    implements SplitEnumerator<SplitWrapper<SplitT>, 
EnumeratorStateWrapper<StateT>> {
+public class FlinkSourceEnumerator<SplitT extends SourceSplit, EnumStateT>
+    implements SplitEnumerator<SplitWrapper<SplitT>, EnumStateT> {
 
-    private final SourceSplitEnumerator<SplitT, StateT> seaTunnelEnumerator;
-    private final SplitEnumeratorContext<SplitWrapper<SplitT>> flinkContext;
+    private final SourceSplitEnumerator<SplitT, EnumStateT> 
sourceSplitEnumerator;
+    private final SplitEnumeratorContext<SplitWrapper<SplitT>> 
enumeratorContext;
 
     @Override
     public void start() {
-        try {
-            seaTunnelEnumerator.open();
-            seaTunnelEnumerator.run();
-        } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to start enumerator", e);
-        }
+        // Only opens the enumerator; run() is deferred until all readers have 
registered
+        sourceSplitEnumerator.open();
     }
 
     @Override
     public void handleSplitRequest(int subtaskId, @Nullable String 
requesterHostname) {
         // Delegate to SeaTunnel enumerator
-        seaTunnelEnumerator.handleSplitRequest(subtaskId);
+        sourceSplitEnumerator.handleSplitRequest(subtaskId);
     }
 
     @Override
     public void addSplitsBack(List<SplitWrapper<SplitT>> splits, int 
subtaskId) {
         // Unwrap and delegate
         List<SplitT> unwrappedSplits = splits.stream()
-            .map(SplitWrapper::getSplit)
+            .map(SplitWrapper::getSourceSplit)
             .collect(Collectors.toList());
 
-        seaTunnelEnumerator.addSplitsBack(unwrappedSplits, subtaskId);
+        sourceSplitEnumerator.addSplitsBack(unwrappedSplits, subtaskId);
     }
 
     @Override
     public void addReader(int subtaskId) {
-        seaTunnelEnumerator.addReader(subtaskId);
+        sourceSplitEnumerator.registerReader(subtaskId);
+
+        // Once every reader (one per parallel subtask) has registered,
+        // run() is called a single time
+        if (allReadersRegistered()) {
+            sourceSplitEnumerator.run();
+        }
     }
 
     @Override
-    public EnumeratorStateWrapper<StateT> snapshotState(long checkpointId) {
-        try {
-            StateT state = seaTunnelEnumerator.snapshotState(checkpointId);
-            return new EnumeratorStateWrapper<>(state);
-        } catch (Exception e) {
-            throw new FlinkRuntimeException("Failed to snapshot enumerator 
state", e);
-        }
+    public EnumStateT snapshotState(long checkpointId) throws Exception {
+        // The SeaTunnel enumerator state is checkpointed directly
+        return sourceSplitEnumerator.snapshotState(checkpointId);
     }
 }
 ```
@@ -257,22 +259,22 @@ public class FlinkSourceEnumerator<SplitT extends 
SourceSplit, StateT>
 public class FlinkSourceReaderContext
     implements org.apache.seatunnel.api.source.SourceReader.Context {
 
-    private final SourceReaderContext flinkContext;
+    private final SourceReaderContext readerContext;
 
     @Override
     public int getIndexOfSubtask() {
-        return flinkContext.getIndexOfThisSubtask();
+        return readerContext.getIndexOfSubtask();
     }
 
     @Override
     public void sendSplitRequest() {
-        // Flink automatically handles split requests
-        // No explicit API needed
+        // Forward the request to Flink's SourceReaderContext
+        readerContext.sendSplitRequest();
     }
 
     @Override
     public void sendSourceEventToEnumerator(SourceEvent event) {
-        flinkContext.sendSourceEventToCoordinator(
+        readerContext.sendSourceEventToCoordinator(
             new SourceEventWrapper(event)
         );
     }
@@ -322,44 +324,57 @@ public class FlinkSourceSplitEnumeratorContext<SplitT 
extends SourceSplit>
 
 ### 2.5 FlinkSink Adapter
 
+The snippet below follows `seatunnel-translation-flink-common` (Flink 1.x 
`Sink` API). Flink's
+committable and writer-state types are wrappers around the SeaTunnel types 
(`CommitWrapper`,
+`FlinkWriterState`), and the input record is a `SeaTunnelRow`. 
`seatunnel-translation-flink-20`
+implements Flink's sink2 interfaces (`SupportsCommitter`, 
`SupportsWriterState`) instead.
+
 ```java
-public class FlinkSink<IN, CommitInfoT, WriterStateT, AggregatedCommitInfoT>
-    implements Sink<IN, CommitInfoT, WriterStateT, AggregatedCommitInfoT> {
+public class FlinkSink<InputT, CommT, WriterStateT, GlobalCommT>
+    implements Sink<InputT, CommitWrapper<CommT>, 
FlinkWriterState<WriterStateT>, GlobalCommT> {
 
-    private final SeaTunnelSink<IN, WriterStateT, CommitInfoT, 
AggregatedCommitInfoT> seaTunnelSink;
+    private final SeaTunnelSink<SeaTunnelRow, WriterStateT, CommT, 
GlobalCommT> sink;
+    private final int parallelism;
 
     @Override
-    public SinkWriter<IN, CommitInfoT, WriterStateT> createWriter(InitContext 
context) {
+    public SinkWriter<InputT, CommitWrapper<CommT>, 
FlinkWriterState<WriterStateT>> createWriter(
+        Sink.InitContext context, List<FlinkWriterState<WriterStateT>> states) 
throws IOException {
         // Create SeaTunnel writer with adapted context
-        org.apache.seatunnel.api.sink.SinkWriter<IN, CommitInfoT, 
WriterStateT> seaTunnelWriter =
-            seaTunnelSink.createWriter(new FlinkSinkWriterContext(context));
+        org.apache.seatunnel.api.sink.SinkWriter.Context stContext =
+            new FlinkSinkWriterContext(context, parallelism);
 
-        // Wrap in Flink adapter
-        return new FlinkSinkWriter<>(seaTunnelWriter);
+        if (states == null || states.isEmpty()) {
+            return new FlinkSinkWriter<>(sink.createWriter(stContext), 1, 
stContext);
+        }
+        // Restore the SeaTunnel writer from the unwrapped states
+        List<WriterStateT> restoredState =
+            
states.stream().map(FlinkWriterState::getState).collect(Collectors.toList());
+        return new FlinkSinkWriter<>(
+            sink.restoreWriter(stContext, restoredState),
+            states.get(0).getCheckpointId() + 1,
+            stContext);
     }
 
     @Override
-    public Optional<Committer<CommitInfoT>> createCommitter() {
-        return seaTunnelSink.createCommitter()
-            .map(FlinkCommitter::new);
+    public Optional<Committer<CommitWrapper<CommT>>> createCommitter() throws 
IOException {
+        return sink.createCommitter().map(FlinkCommitter::new);
     }
 
     @Override
-    public Optional<GlobalCommitter<CommitInfoT, AggregatedCommitInfoT>> 
createGlobalCommitter() {
-        return seaTunnelSink.createAggregatedCommitter()
-            .map(FlinkGlobalCommitter::new);
+    public Optional<GlobalCommitter<CommitWrapper<CommT>, GlobalCommT>> 
createGlobalCommitter()
+        throws IOException {
+        return sink.createAggregatedCommitter().map(FlinkGlobalCommitter::new);
     }
 
     @Override
-    public Optional<SimpleVersionedSerializer<CommitInfoT>> 
getCommittableSerializer() {
-        return seaTunnelSink.getCommitInfoSerializer()
-            .map(FlinkSimpleVersionedSerializer::new);
+    public Optional<SimpleVersionedSerializer<CommitWrapper<CommT>>> 
getCommittableSerializer() {
+        return 
sink.getCommitInfoSerializer().map(CommitWrapperSerializer::new);
     }
 
     @Override
-    public Optional<SimpleVersionedSerializer<WriterStateT>> 
getWriterStateSerializer() {
-        return seaTunnelSink.getWriterStateSerializer()
-            .map(FlinkSimpleVersionedSerializer::new);
+    public Optional<SimpleVersionedSerializer<FlinkWriterState<WriterStateT>>>
+        getWriterStateSerializer() {
+        return 
sink.getWriterStateSerializer().map(FlinkWriterStateSerializer::new);
     }
 }
 ```
@@ -367,33 +382,54 @@ public class FlinkSink<IN, CommitInfoT, WriterStateT, 
AggregatedCommitInfoT>
 ### 2.6 FlinkSinkWriter Adapter
 
 ```java
-public class FlinkSinkWriter<IN, CommitInfoT, WriterStateT>
-    implements SinkWriter<IN, CommitInfoT, WriterStateT> {
+public class FlinkSinkWriter<InputT, CommT, WriterStateT>
+    implements SinkWriter<InputT, CommitWrapper<CommT>, 
FlinkWriterState<WriterStateT>> {
 
-    private final org.apache.seatunnel.api.sink.SinkWriter<IN, CommitInfoT, 
WriterStateT> seaTunnelWriter;
+    private final org.apache.seatunnel.api.sink.SinkWriter<SeaTunnelRow, 
CommT, WriterStateT> sinkWriter;
     private long checkpointId;
+    private List<FlinkWriterState<WriterStateT>> pendingStates;
 
     @Override
-    public void write(IN element, Context context) throws IOException {
+    public void write(InputT element, Context context) throws IOException {
         // Delegate to SeaTunnel writer
-        seaTunnelWriter.write(element);
+        sinkWriter.write((SeaTunnelRow) element);
     }
 
     @Override
-    public List<CommitInfoT> prepareCommit(boolean flush) throws IOException {
-        Optional<CommitInfoT> commitInfo = 
seaTunnelWriter.prepareCommit(checkpointId);
-        return commitInfo.map(Collections::singletonList)
+    public List<CommitWrapper<CommT>> prepareCommit(boolean flush) throws 
IOException {
+        Optional<CommT> commitInfo = sinkWriter.prepareCommit(checkpointId);
+
+        // Snapshot the state for the same checkpoint right after prepareCommit
+        pendingStates = sinkWriter.snapshotState(checkpointId).stream()
+            .map(state -> new FlinkWriterState<>(checkpointId, state))
+            .collect(Collectors.toList());
+        checkpointId++;
+
+        return commitInfo.map(CommitWrapper::new)
+            .map(Collections::singletonList)
             .orElse(Collections.emptyList());
     }
 
     @Override
-    public List<WriterStateT> snapshotState(long checkpointId) throws 
IOException {
-        return seaTunnelWriter.snapshotState(checkpointId);
+    public List<FlinkWriterState<WriterStateT>> snapshotState() throws 
IOException {
+        // Flink's snapshotState() takes no checkpoint ID; return the states 
taken in prepareCommit
+        if (pendingStates != null) {
+            List<FlinkWriterState<WriterStateT>> states = pendingStates;
+            pendingStates = null;
+            return states;
+        }
+
+        // Without a preceding prepareCommit (e.g. sinks without 2PC), 
snapshot directly
+        List<FlinkWriterState<WriterStateT>> states = 
sinkWriter.snapshotState(checkpointId).stream()
+            .map(state -> new FlinkWriterState<>(checkpointId, state))
+            .collect(Collectors.toList());
+        checkpointId++;
+        return states;
     }
 
     @Override
     public void close() throws Exception {
-        seaTunnelWriter.close();
+        sinkWriter.close();
     }
 }
 ```
@@ -402,194 +438,170 @@ public class FlinkSinkWriter<IN, CommitInfoT, 
WriterStateT>
 
 Note: Spark 2.4 and Spark 3.x use different datasource APIs. SeaTunnel 
maintains separate Spark translation modules/adapters per Spark major version, 
so the exact adapter types and lifecycle hooks may differ.
 
-### 3.1 SparkSource Adapter
+### 3.1 Source Entry Point
 
-Adapts `SeaTunnelSource` to Spark's `DataSourceReader` interface.
+The snippets in this section follow the Spark 2.4 DataSourceV2 adapters in
+`seatunnel-translation-spark-2.4`. `SeaTunnelSourceSupport` (`DataSourceV2`, 
`ReadSupport`,
+`MicroBatchReadSupport`) creates a `BatchSourceReader` for batch jobs. In 
Spark 3.3 the
+equivalents are `SeaTunnelSparkSource` (`TableProvider`), `SeaTunnelScan`, 
`SeaTunnelBatch`,
+`SeaTunnelBatchInputPartition` and `SeaTunnelBatchPartitionReader`.
+
+Splits are not enumerated on the driver. `planInputPartitions()` creates one 
virtual partition per
+subtask (or a single partition for sources that implement 
`SupportCoordinate`), and each partition
+runs the SeaTunnel enumerator and reader inside its executor task.
 
 ```java
-public class SparkSource<T, SplitT extends SourceSplit, StateT>
-    implements DataSourceReader {
+public class BatchSourceReader implements DataSourceReader {
 
-    private final SeaTunnelSource<T, SplitT, StateT> seaTunnelSource;
+    private final SeaTunnelSource<SeaTunnelRow, ?, ?> source;
+    private final Integer parallelism;
+    // jobId, envOptions and multiTableManager fields omitted
 
     @Override
     public StructType readSchema() {
-        // Convert SeaTunnel schema to Spark schema
-        CatalogTable catalogTable = 
seaTunnelSource.getProducedCatalogTables().get(0);
-        return SparkTypeConverter.convert(catalogTable.getTableSchema());
+        // Spark schema converted from the produced CatalogTables
+        return multiTableManager.getTableSchema();
     }
 
     @Override
     public List<InputPartition<InternalRow>> planInputPartitions() {
-        // Create enumerator and generate splits
-        SourceSplitEnumerator<SplitT, StateT> enumerator =
-            seaTunnelSource.createEnumerator(new SparkEnumeratorContext());
-
-        try {
-            enumerator.open();
-            enumerator.run();
-
-            // Collect all splits
-            List<SplitT> splits = collectAllSplits(enumerator);
-
-            // Wrap each split as Spark InputPartition
-            return splits.stream()
-                .map(split -> new SparkInputPartition<>(seaTunnelSource, 
split))
-                .collect(Collectors.toList());
-
-        } catch (Exception e) {
-            throw new RuntimeException("Failed to plan input partitions", e);
+        List<InputPartition<InternalRow>> virtualPartitions;
+        if (source instanceof SupportCoordinate) {
+            // One partition runs one enumerator and all readers
+            virtualPartitions = new ArrayList<>(1);
+            virtualPartitions.add(
+                new BatchPartition(source, parallelism, jobId, 0, envOptions, 
multiTableManager));
+        } else {
+            // One partition per subtask; each one runs its own enumerator and 
reader
+            virtualPartitions = new ArrayList<>(parallelism);
+            for (int subtaskId = 0; subtaskId < parallelism; subtaskId++) {
+                virtualPartitions.add(
+                    new BatchPartition(
+                        source, parallelism, jobId, subtaskId, envOptions, 
multiTableManager));
+            }
         }
+        return virtualPartitions;
     }
 }
 ```
 
-### 3.2 SparkInputPartition
+### 3.2 BatchPartition
 
 ```java
-public class SparkInputPartition<T, SplitT extends SourceSplit>
-    implements InputPartition<InternalRow> {
+public class BatchPartition implements InputPartition<InternalRow> {
 
-    private final SeaTunnelSource<T, SplitT, ?> seaTunnelSource;
-    private final SplitT split;
+    private final SeaTunnelSource<SeaTunnelRow, ?, ?> source;
+    private final Integer subtaskId;
+    // parallelism, jobId, envOptions and multiTableManager fields omitted
 
     @Override
     public InputPartitionReader<InternalRow> createPartitionReader() {
-        // Create SeaTunnel reader
-        org.apache.seatunnel.api.source.SourceReader<T, SplitT> 
seaTunnelReader =
-            seaTunnelSource.createReader(new SparkReaderContext());
+        // ParallelBatchPartitionReader drives a ParallelSource (local 
enumerator + reader for this
+        // subtask); CoordinatedBatchPartitionReader drives a CoordinatedSource
+        ParallelBatchPartitionReader partitionReader =
+            source instanceof SupportCoordinate
+                ? new CoordinatedBatchPartitionReader(
+                    source, parallelism, jobId, subtaskId, envOptions, 
multiTableManager)
+                : new ParallelBatchPartitionReader(
+                    source, parallelism, jobId, subtaskId, envOptions, 
multiTableManager);
 
         // Wrap in Spark adapter
-        return new SparkPartitionReader<>(seaTunnelReader, split);
+        return new SeaTunnelInputPartitionReader(partitionReader);
     }
 }
 ```
 
-### 3.3 SparkPartitionReader
+### 3.3 SeaTunnelInputPartitionReader
 
 ```java
-public class SparkPartitionReader<T, SplitT extends SourceSplit>
-    implements InputPartitionReader<InternalRow> {
-
-    private final org.apache.seatunnel.api.source.SourceReader<T, SplitT> 
seaTunnelReader;
-    private final Queue<InternalRow> buffer = new LinkedList<>();
-
-    public SparkPartitionReader(
-        org.apache.seatunnel.api.source.SourceReader<T, SplitT> reader,
-        SplitT split
-    ) {
-        this.seaTunnelReader = reader;
+public class SeaTunnelInputPartitionReader implements 
InputPartitionReader<InternalRow> {
 
-        try {
-            seaTunnelReader.open();
-            seaTunnelReader.addSplits(Collections.singletonList(split));
-        } catch (Exception e) {
-            throw new RuntimeException("Failed to open reader", e);
-        }
-    }
+    private final ParallelBatchPartitionReader partitionReader;
 
     @Override
     public boolean next() throws IOException {
-        if (!buffer.isEmpty()) {
-            return true;
-        }
-
-        // Poll from SeaTunnel reader
+        // The partition reader polls the SeaTunnel reader in a background 
thread and hands
+        // rows over (already converted to InternalRow) through a queue
         try {
-            seaTunnelReader.pollNext(new Collector<T>() {
-                @Override
-                public void collect(T record) {
-                    // Convert to Spark InternalRow
-                    InternalRow row = SparkTypeConverter.convert(record);
-                    buffer.offer(row);
-                }
-            });
-
-            return !buffer.isEmpty();
-
+            return partitionReader.next();
         } catch (Exception e) {
-            throw new IOException("Failed to poll next", e);
+            throw new RuntimeException(e);
         }
     }
 
     @Override
     public InternalRow get() {
-        return buffer.poll();
+        return partitionReader.get();
     }
 
     @Override
     public void close() throws IOException {
-        try {
-            seaTunnelReader.close();
-        } catch (Exception e) {
-            throw new IOException("Failed to close reader", e);
-        }
+        partitionReader.close();
     }
 }
 ```
 
 ### 3.4 SparkSink Adapter
 
-```java
-public class SparkSink<IN, WriterStateT, CommitInfoT>
-    implements DataSourceWriter {
+`SparkSink` is the `WriteSupport` / `StreamWriteSupport` entry point; the 
commit logic lives in
+`SparkDataSourceWriter` (driver side) and `SparkDataWriter` (executor side). 
Each `SparkDataWriter`
+calls `prepareCommit` and the per-writer `SinkCommitter` inside 
`DataWriter#commit()`, and returns a
+`SparkWriterCommitMessage`. The driver then runs the `SinkAggregatedCommitter`:
 
-    private final SeaTunnelSink<IN, WriterStateT, CommitInfoT, ?> 
seaTunnelSink;
+```java
+public class SparkSink<StateT, CommitInfoT, AggregatedCommitInfoT>
+    implements WriteSupport, StreamWriteSupport, DataSourceV2 {
 
     @Override
-    public DataWriterFactory<InternalRow> createWriterFactory() {
-        return new SparkDataWriterFactory<>(seaTunnelSink);
+    public Optional<DataSourceWriter> createWriter(
+        String writeUUID, StructType schema, SaveMode mode, DataSourceOptions 
options) {
+        return Optional.of(new SparkDataSourceWriter<>(sink, catalogTables, 
jobId, parallelism));
     }
+}
+
+public class SparkDataSourceWriter<StateT, CommitInfoT, AggregatedCommitInfoT>
+    implements DataSourceWriter {
+
+    private final SinkAggregatedCommitter<CommitInfoT, AggregatedCommitInfoT> 
sinkAggregatedCommitter;
 
     @Override
-    public boolean useCommitCoordinator() {
-        // Use commit coordinator if sink has committer
-        return seaTunnelSink.createCommitter().isPresent();
+    public DataWriterFactory<InternalRow> createWriterFactory() {
+        return new SparkDataWriterFactory<>(sink, catalogTables, jobId, 
parallelism);
     }
 
     @Override
     public void commit(WriterCommitMessage[] messages) {
-        Optional<SinkCommitter<CommitInfoT>> committerOpt = 
seaTunnelSink.createCommitter();
-
-        if (committerOpt.isPresent()) {
-            SinkCommitter<CommitInfoT> committer = committerOpt.get();
-
-            // Extract commit infos from messages
-            List<CommitInfoT> commitInfos = Arrays.stream(messages)
-                .map(msg -> ((SparkCommitMessage<CommitInfoT>) 
msg).getCommitInfo())
-                .collect(Collectors.toList());
-
-            // Commit
+        if (sinkAggregatedCommitter != null) {
             try {
-                List<CommitInfoT> failed = committer.commit(commitInfos);
-                if (!failed.isEmpty()) {
-                    throw new IOException("Some commits failed: " + failed);
-                }
+                sinkAggregatedCommitter.commit(combineCommitMessage(messages));
             } catch (IOException e) {
-                throw new RuntimeException("Failed to commit", e);
+                throw new RuntimeException("SinkAggregatedCommitter commit 
failed in driver", e);
             }
         }
     }
 
     @Override
     public void abort(WriterCommitMessage[] messages) {
-        // Handle abort
-        Optional<SinkCommitter<CommitInfoT>> committerOpt = 
seaTunnelSink.createCommitter();
-
-        if (committerOpt.isPresent()) {
-            SinkCommitter<CommitInfoT> committer = committerOpt.get();
-
-            List<CommitInfoT> commitInfos = Arrays.stream(messages)
-                .map(msg -> ((SparkCommitMessage<CommitInfoT>) 
msg).getCommitInfo())
-                .collect(Collectors.toList());
-
+        if (sinkAggregatedCommitter != null) {
             try {
-                committer.abort(commitInfos);
-            } catch (IOException e) {
-                throw new RuntimeException("Failed to abort", e);
+                sinkAggregatedCommitter.abort(combineCommitMessage(messages));
+            } catch (Exception e) {
+                throw new RuntimeException("SinkAggregatedCommitter abort 
failed in driver", e);
             }
         }
     }
+
+    private List<AggregatedCommitInfoT> 
combineCommitMessage(WriterCommitMessage[] messages) {
+        if (messages.length == 0) {
+            return Collections.emptyList();
+        }
+        // Extract commit infos from messages and combine them into one 
aggregated commit info
+        List<CommitInfoT> commitInfos = Arrays.stream(messages)
+            .map(m -> ((SparkWriterCommitMessage<CommitInfoT>) m).getMessage())
+            .filter(Objects::nonNull)
+            .collect(Collectors.toList());
+        return 
Collections.singletonList(sinkAggregatedCommitter.combine(commitInfos));
+    }
 }
 ```
 
@@ -605,8 +617,8 @@ public class FlinkSimpleVersionedSerializer<T>
 
     @Override
     public int getVersion() {
-        // Delegate to SeaTunnel serializer
-        return seaTunnelSerializer.getVersion();
+        // SeaTunnel's Serializer has no version, so the adapter always 
reports 0
+        return 0;
     }
 
     @Override
@@ -625,26 +637,19 @@ public class FlinkSimpleVersionedSerializer<T>
 
 ### 5.1 Spark Type Conversion
 
-```java
-public class SparkTypeConverter {
-    public static StructType convert(TableSchema schema) {
-        List<StructField> fields = new ArrayList<>();
-
-        for (Column column : schema.getColumns()) {
-            StructField field = new StructField(
-                column.getName(),
-                convertDataType(column.getDataType()),
-                column.isNullable(),
-                Metadata.empty()
-            );
-            fields.add(field);
-        }
+`TypeConverterUtils` in `seatunnel-translation-spark-common` converts 
SeaTunnel types to Spark
+`DataType`s (simplified):
 
-        return new StructType(fields.toArray(new StructField[0]));
-    }
-
-    private static DataType convertDataType(SeaTunnelDataType<?> 
seaTunnelType) {
-        switch (seaTunnelType.getSqlType()) {
+```java
+public final class TypeConverterUtils {
+    public static DataType convert(SeaTunnelDataType<?> dataType) {
+        switch (dataType.getSqlType()) {
+            case NULL:
+                return DataTypes.NullType;
+            case STRING:
+                return DataTypes.StringType;
+            case BOOLEAN:
+                return DataTypes.BooleanType;
             case TINYINT:
                 return DataTypes.ByteType;
             case SMALLINT:
@@ -657,37 +662,34 @@ public class SparkTypeConverter {
                 return DataTypes.FloatType;
             case DOUBLE:
                 return DataTypes.DoubleType;
-            case DECIMAL:
-                DecimalType decimalType = (DecimalType) seaTunnelType;
-                return DataTypes.createDecimalType(
-                    decimalType.getPrecision(),
-                    decimalType.getScale()
-                );
-            case STRING:
-                return DataTypes.StringType;
-            case BOOLEAN:
-                return DataTypes.BooleanType;
+            case BYTES:
+                return DataTypes.BinaryType;
             case DATE:
                 return DataTypes.DateType;
+            case TIME:
+                // Spark has no TIME type; stored as LongType and flagged in 
the field metadata
+                return DataTypes.LongType;
             case TIMESTAMP:
                 return DataTypes.TimestampType;
-            case BYTES:
-                return DataTypes.BinaryType;
+            case TIMESTAMP_TZ:
+                return OffsetDateTimeUtils.OFFSET_DATETIME_WITH_DECIMAL;
             case ARRAY:
-                ArrayType arrayType = (ArrayType) seaTunnelType;
                 return DataTypes.createArrayType(
-                    convertDataType(arrayType.getElementType())
-                );
+                    convert(((ArrayType<?, ?>) dataType).getElementType()));
             case MAP:
-                MapType mapType = (MapType) seaTunnelType;
+                MapType<?, ?> mapType = (MapType<?, ?>) dataType;
                 return DataTypes.createMapType(
-                    convertDataType(mapType.getKeyType()),
-                    convertDataType(mapType.getValueType())
-                );
+                    convert(mapType.getKeyType()), 
convert(mapType.getValueType()));
+            case DECIMAL:
+                DecimalType decimalType = (DecimalType) dataType;
+                return new org.apache.spark.sql.types.DecimalType(
+                    decimalType.getPrecision(), decimalType.getScale());
+            case ROW:
+                // Converted to a StructType; every StructField is nullable
+                return convert((SeaTunnelRowType) dataType);
             default:
-                throw new UnsupportedOperationException(
-                    "Unsupported type: " + seaTunnelType);
         }
+        throw new IllegalArgumentException("Unsupported SeaTunnel's data type: 
" + dataType);
     }
 }
 ```
diff --git a/docs/en/connectors/sink/SensorsData.md 
b/docs/en/connectors/sink/SensorsData.md
index 61a9608b4fe..a772813e15e 100644
--- a/docs/en/connectors/sink/SensorsData.md
+++ b/docs/en/connectors/sink/SensorsData.md
@@ -258,26 +258,27 @@ sink {
 
 ### Item Tracking
 
+Item records must set `entity_name = items`. `entity_name` defaults to 
`users`, and with that
+default `record_type = items` is rejected with `UNSUPPORTED_RECORD_TYPE` when 
the writer starts.
+Item records only use `item_id_column`, `item_type_column`, `property_fields` 
and the optional
+`time_column`; user-only options such as `schema`, `event_name`, 
`distinct_id_column` and
+`identity_fields` are not needed.
+
 ```hocon
 sink {
   SensorsData {
     server_url = "http://10.1.136.63:8106/sa?project=default";
     time_free = true
 
+    entity_name = items
     record_type = items
-    schema = items
-    event_name = "$ItemViewed"
+    item_id_column = product_id
+    item_type_column = product_type
     time_column = view_time
-    distinct_id_column = user_id
-    identity_fields = [
-      { source = user_id, target = "$identity_login_id" }
-    ]
     property_fields = [
       { target = "view_duration", source = duration, type = INT }
       { target = "referrer", source = referrer_url, type = STRING }
     ]
-    item_id_column = product_id
-    item_type_column = product_type
   }
 }
 ```
@@ -346,6 +347,9 @@ sink {
 
 ### Console Output (for Testing)
 
+`entity_name` is left at its default `users`, so `identity_fields` is required 
here as in the
+other user-record examples; without it the job fails option validation.
+
 ```hocon
 sink {
   SensorsData {
@@ -356,6 +360,9 @@ sink {
     event_name = "$TestEvent"
     time_column = timestamp
     distinct_id_column = test_id
+    identity_fields = [
+      { source = test_id, target = "$identity_distinct_id" }
+    ]
     property_fields = [
       { target = "test", source = test_field, type = STRING }
     ]
diff --git a/docs/en/connectors/source/GoogleBigtable.md 
b/docs/en/connectors/source/GoogleBigtable.md
index b0417360a6c..0e420ca2242 100644
--- a/docs/en/connectors/source/GoogleBigtable.md
+++ b/docs/en/connectors/source/GoogleBigtable.md
@@ -42,6 +42,7 @@ The source is bounded. The enumerator calls Bigtable 
`sampleRowKeys` to cut the
 | end_timestamp    | long   | no       | -             |
 | max_versions     | int    | no       | 1             |
 | scan_row_limit   | int    | no       | -1            |
+| schema           | config | yes      | -             |
 | common-options   |        | no       | -             |
 
 ### project_id [string]
@@ -92,6 +93,14 @@ Maximum number of cell versions to return per column 
qualifier. Default `1` retu
 
 Maximum number of rows to return **per split**. `-1` (default) means no limit. 
When the enumerator produces multiple splits, the job-level upper bound is 
about `scan_row_limit × split count`, not a single table-wide cap. Use this 
option together with `start_rowkey` / `end_rowkey` to do paginated full-table 
scans across multiple jobs.
 
+### schema [config]
+
+The output schema of the source. This option is required: the source builds 
its output table from
+`schema` and fails at startup with `Schema config need option [schema]` when 
it is missing. Field
+names follow the `familyName:qualifier` pattern described in [Schema 
Mapping](#schema-mapping), and
+the row-key field is selected by `rowkey_column`. See
+[Schema Feature](../../introduction/concepts/schema-feature.md) for the 
general syntax.
+
 ### common options
 
 Source plugin common parameters, please refer to [Source Common 
Options](../common-options/source-common-options.md) for details.
diff --git a/docs/en/connectors/source/Phoenix.md 
b/docs/en/connectors/source/Phoenix.md
index 07de5c8e732..f94ed0ca6ff 100644
--- a/docs/en/connectors/source/Phoenix.md
+++ b/docs/en/connectors/source/Phoenix.md
@@ -43,7 +43,7 @@ Supports standard SQL queries and column projection.
 
|----------------|--------|----------|---------------|----------------------------------------------------------------------------------------------------------|
 | driver         | String | Yes      | -             | JDBC driver class. Use 
`org.apache.phoenix.jdbc.PhoenixDriver` for the thick driver, or 
`org.apache.phoenix.queryserver.client.Driver` for the thin driver. |
 | url            | String | Yes      | -             | JDBC connection URL. 
Use `jdbc:phoenix:localhost:2182/hbase` for the thick driver, or 
`jdbc:phoenix:thin:url=http://localhost:8765;serialization=PROTOBUF` for the 
thin driver. |
-| query          | String | Conditional | -             | SELECT query 
executed to read rows, for example `select age, name from test.source`. The 
column order in the SELECT list must match `schema.fields`. Required unless 
`table_path` or `table_list` is configured. |
+| query          | String | Conditional | -             | SELECT query 
executed to read rows, for example `select age, name from test.source`. The 
output schema is derived from the columns of the SELECT list, so no 
`schema.fields` declaration is needed. Required unless `table_path` or 
`table_list` is configured. |
 | common-options |        | No       | -             | Source plugin common 
parameters, please refer to [Source Common 
Options](../common-options/source-common-options.md) for details. |
 
 ### driver [string]
diff --git a/docs/en/connectors/source/Vertica.md 
b/docs/en/connectors/source/Vertica.md
index 43322611e07..7a5c935d906 100644
--- a/docs/en/connectors/source/Vertica.md
+++ b/docs/en/connectors/source/Vertica.md
@@ -71,7 +71,7 @@ Read external data source data through JDBC.
 | password                     | String     | No       | -               | 
Connection instance password                                                    
                                                                                
                                                                                
                  |
 | query                        | String     | No       | -               | 
Query statement. Required when neither `table_path` nor `table_list` is 
configured.                                                                     
                                                                                
                                                                                
              |
 | connection_check_timeout_sec | Int        | No       | 30              | The 
time in seconds to wait for the database operation used to validate the 
connection to complete                                                          
                                                                                
                      |
-| partition_column             | String     | No       | -               | The 
column name for parallelism's partition, only support numeric type,Only support 
numeric type primary key, and only can config one column.                       
                                                                                
              |
+| partition_column             | String     | No       | -               | The 
column name for parallelism's partition. Supports numeric, string and date 
columns; only one column can be configured.                                     
                                                                                
|
 | partition_lower_bound        | String     | No       | -               | The 
partition_column min value for scan, if not set SeaTunnel will query database 
get min value.                                                                  
                                                                                
                |
 | partition_upper_bound        | String     | No       | -               | The 
partition_column max value for scan, if not set SeaTunnel will query database 
get max value.                                                                  
                                                                                
                |
 | partition_num                | Int        | No       | 10              | The 
number of partition count, only support positive integer. default value is 10   
                                                                                
                                                                                
 |
diff --git a/docs/en/developer/coding-guide.md 
b/docs/en/developer/coding-guide.md
index 9995c16854e..076b4616e81 100644
--- a/docs/en/developer/coding-guide.md
+++ b/docs/en/developer/coding-guide.md
@@ -46,7 +46,10 @@ This guide documents an overview of the current Apache 
SeaTunnel modules and bes
    try {
        // read logic
    } catch (IOException e) {
-       throw SeaTunnelORCFormatException("This orc file is corrupted, please 
check it", e);
+       throw new FileConnectorException(
+               FileConnectorErrorCode.FILE_READ_FAILED,
+               "This orc file is corrupted, please check it",
+               e);
    }
    ```
 
diff --git a/docs/en/developer/setup.md b/docs/en/developer/setup.md
index e808f4503d9..8bb40334a4a 100644
--- a/docs/en/developer/setup.md
+++ b/docs/en/developer/setup.md
@@ -17,7 +17,7 @@ have installed the following software:
 
 * [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) 
installed.
 * [Java](https://www.java.com/en/download/) (JDK11/JDK17 are supported by now) 
installed and `JAVA_HOME` set.
-* [Scala](https://www.scala-lang.org/download/2.11.12.html) (only scala 
2.11.12 supported by now) installed.
+* [Scala](https://www.scala-lang.org/download/2.12.15.html) (the build uses 
scala 2.12.15) installed.
 * [JetBrains IDEA](https://www.jetbrains.com/idea/) installed.
 
 ## Set Up
diff --git a/docs/en/getting-started/application/kubernetes/configuration.md 
b/docs/en/getting-started/application/kubernetes/configuration.md
index 17277e76f03..f872abe4817 100644
--- a/docs/en/getting-started/application/kubernetes/configuration.md
+++ b/docs/en/getting-started/application/kubernetes/configuration.md
@@ -46,7 +46,7 @@ Command-line overrides (`-Dkey=value`) may be visible to 
other users on the subm
 | `kubernetes.env.<NAME>` | map | no | - | One environment variable per name: 
a literal value, `secret:<name>/<key>` or `configmap:<name>/<key>`. |
 | `kubernetes.env-from.secret` | string | no | - | Existing Secret whose keys 
are all injected as environment variables (Kubernetes `envFrom.secretRef`). |
 | `kubernetes.env-from.configmap` | string | no | - | Existing ConfigMap whose 
keys are all injected as environment variables (Kubernetes 
`envFrom.configMapRef`). |
-| `kubernetes.kubeconfig` | string | no | SDK default | Local submitter 
kubeconfig; it is not sent to the master. Configure it in a 
permission-restricted deployment file rather than with `-i`. |
+| `kubernetes.kubeconfig` | string | no | SDK default | Local submitter 
kubeconfig; it is not sent to the master. Configure it in a 
permission-restricted deployment file rather than with `-D`. |
 | `kubernetes.finished-job-retention-seconds` | int | no | `86400` | Positive 
retention period for completed or failed Jobs. |
 | `kubernetes.active-deadline-seconds` | long | no | - | Absolute deadline in 
seconds counted from Job creation for the whole application, including master 
startup. Set it for unattended batch runs; unset keeps the Job active until the 
job finishes or is canceled. |
 | `kubernetes.checkpoint-pvc` | string | no | - | Existing PVC mounted at 
`kubernetes.checkpoint-directory` in the master. |
diff --git a/docs/en/getting-started/application/kubernetes/faq.md 
b/docs/en/getting-started/application/kubernetes/faq.md
index f1fc528bb70..1aa9e57a6b3 100644
--- a/docs/en/getting-started/application/kubernetes/faq.md
+++ b/docs/en/getting-started/application/kubernetes/faq.md
@@ -71,5 +71,5 @@ admission policy, ResourceQuota, or node capacity.
 - Manage private image credentials through the ServiceAccount or cluster.
 - Restrict application Secret access and enable Kubernetes encryption at rest 
for Secrets when required by the cluster's security policy.
 - Keep connector credentials out of logs and prefer credential mechanisms 
supported by the connector, filesystem, or cluster.
-- Put `kubernetes.kubeconfig` in a permission-restricted deployment 
configuration file, or use the Kubernetes SDK default. Do not pass it with `-i` 
because command-line arguments may be visible to other users on the submission 
host.
+- Put `kubernetes.kubeconfig` in a permission-restricted deployment 
configuration file, or use the Kubernetes SDK default. Do not pass it with `-D` 
because command-line arguments may be visible to other users on the submission 
host.
 - Allow only required Hazelcast and external-system traffic in NetworkPolicy.
diff --git a/docs/en/getting-started/kubernetes/configuration.md 
b/docs/en/getting-started/kubernetes/configuration.md
index b94aeefaf4b..0fa234caacb 100644
--- a/docs/en/getting-started/kubernetes/configuration.md
+++ b/docs/en/getting-started/kubernetes/configuration.md
@@ -176,7 +176,7 @@ If object storage is used, every Master and Worker Pod must 
have network access
 
 Master nodes handle IMap state storage. In production, enable MapStore and 
write data to shared storage or object storage. In separated cluster mode, 
configure MapStore only in `hazelcast-master.yaml`; Workers do not need 
MapStore.
 
-MapStore uses `FileMapStoreFactory`. The `type: hdfs` entry is the identifier 
of the IMap file storage factory and must stay unchanged even when S3 or OSS is 
used. The actual backend is selected by `storage.type`, which currently 
supports `hdfs`, `s3`, and `oss`.
+MapStore uses `FileMapStoreFactory`. The `type: hdfs` entry is the identifier 
of the IMap file storage factory and must stay unchanged even when S3, OSS or 
GCS is used. The actual backend is selected by `storage.type`, which currently 
supports `hdfs`, `s3`, `oss`, and `gcs`.
 
 ### Checkpoint Monitor MapStore
 
diff --git a/docs/en/getting-started/locally/quick-start-flink.md 
b/docs/en/getting-started/locally/quick-start-flink.md
index 096b792fa67..6779baa9ef3 100644
--- a/docs/en/getting-started/locally/quick-start-flink.md
+++ b/docs/en/getting-started/locally/quick-start-flink.md
@@ -104,25 +104,26 @@ is a sign to determine whether the command ran 
successfully or not.
 
 The SeaTunnel console will print some logs as below:
 
+The log prefix (time, thread, logger layout) and the `tableId` value depend on 
the engine's logging configuration and the job, so they are shown as `...` 
below. `FieldMapper` outputs the fields in the order of `field_mapper` and 
renames `name` to `new_name`, so the output row type is `age<INT>, 
new_name<STRING>`.
+
 ```shell
-fields : name, age
-types : STRING, INT
-row=1 : elWaB, 1984352560
-row=2 : uAtnp, 762961563
-row=3 : TQEIB, 2042675010
-row=4 : DcFjo, 593971283
-row=5 : SenEb, 2099913608
-row=6 : DHjkg, 1928005856
-row=7 : eScCM, 526029657
-row=8 : sgOeE, 600878991
-row=9 : gwdvw, 1951126920
-row=10 : nSiKE, 488708928
-row=11 : xubpl, 1420202810
-row=12 : rHZqb, 331185742
-row=13 : rciGD, 1112878259
-row=14 : qLhdI, 1457046294
-row=15 : ZTkRx, 1240668386
-row=16 : SGZCr, 94186144
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
output rowType: age<INT>, new_name<STRING>
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=1:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1984352560, elWaB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=2:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 762961563, uAtnp
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=3:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2042675010, TQEIB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=4:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 593971283, DcFjo
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=5:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2099913608, SenEb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=6:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1928005856, DHjkg
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=7:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 526029657, eScCM
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=8:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 600878991, sgOeE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=9:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1951126920, gwdvw
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=10:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 488708928, nSiKE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=11:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1420202810, xubpl
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=12:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 331185742, rHZqb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=13:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1112878259, rciGD
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=14:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1457046294, qLhdI
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=15:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1240668386, ZTkRx
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=16:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 94186144, SGZCr
 ```
 
 ## What's More
diff --git a/docs/en/getting-started/locally/quick-start-spark.md 
b/docs/en/getting-started/locally/quick-start-spark.md
index 4249882f704..68e4a653128 100644
--- a/docs/en/getting-started/locally/quick-start-spark.md
+++ b/docs/en/getting-started/locally/quick-start-spark.md
@@ -129,25 +129,26 @@ is a sign to determine whether the command ran 
successfully or not.
 
 The SeaTunnel console will print some logs as below:
 
+The log prefix (time, thread, logger layout) and the `tableId` value depend on 
the engine's logging configuration and the job, so they are shown as `...` 
below. `FieldMapper` outputs the fields in the order of `field_mapper` and 
renames `name` to `new_name`, so the output row type is `age<INT>, 
new_name<STRING>`.
+
 ```shell
-fields : name, age
-types : STRING, INT
-row=1 : elWaB, 1984352560
-row=2 : uAtnp, 762961563
-row=3 : TQEIB, 2042675010
-row=4 : DcFjo, 593971283
-row=5 : SenEb, 2099913608
-row=6 : DHjkg, 1928005856
-row=7 : eScCM, 526029657
-row=8 : sgOeE, 600878991
-row=9 : gwdvw, 1951126920
-row=10 : nSiKE, 488708928
-row=11 : xubpl, 1420202810
-row=12 : rHZqb, 331185742
-row=13 : rciGD, 1112878259
-row=14 : qLhdI, 1457046294
-row=15 : ZTkRx, 1240668386
-row=16 : SGZCr, 94186144
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
output rowType: age<INT>, new_name<STRING>
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=1:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1984352560, elWaB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=2:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 762961563, uAtnp
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=3:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2042675010, TQEIB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=4:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 593971283, DcFjo
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=5:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2099913608, SenEb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=6:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1928005856, DHjkg
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=7:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 526029657, eScCM
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=8:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 600878991, sgOeE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=9:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1951126920, gwdvw
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=10:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 488708928, nSiKE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=11:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1420202810, xubpl
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=12:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 331185742, rHZqb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=13:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1112878259, rciGD
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=14:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1457046294, qLhdI
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=15:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1240668386, ZTkRx
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=16:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 94186144, SGZCr
 ```
 
 ## What's More
diff --git a/docs/zh/architecture/api-design/catalog-table.md 
b/docs/zh/architecture/api-design/catalog-table.md
index f0c9fb0a31f..2bea1ba1cf1 100644
--- a/docs/zh/architecture/api-design/catalog-table.md
+++ b/docs/zh/architecture/api-design/catalog-table.md
@@ -67,11 +67,13 @@ Column 通常由以下信息构成:
 
 ### 2.4 SeaTunnelDataType
 
-跨连接器的统一类型系统。
+跨连接器的统一类型系统。类型以 `org.apache.seatunnel.api.table.type` 包中的常量或类表示(例如 
`BasicType.INT_TYPE`、
+`new DecimalType(precision, 
scale)`、`LocalTimeType.LOCAL_DATE_TIME_TYPE`、`PrimitiveByteArrayType.INSTANCE`),
+并不存在 `DataTypes` 这样的工厂类。
 
 **基本类型**(示例):
 - 数值: TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/DECIMAL(precision, scale)
-- 字符串: STRING/CHAR(length)/VARCHAR(length)
+- 字符串: STRING(没有独立的 CHAR/VARCHAR 类型,声明长度记录在 Column 的 `columnLength` 中)
 - 二进制: BYTES
 - 日期/时间: DATE/TIME/TIMESTAMP
 - 布尔: BOOLEAN
@@ -322,13 +324,17 @@ Sink 侧的关键是:把输入行映射到正确分区并以目标系统要求
 
 ### 9.1 模式覆盖
 
+无法从外部系统读取 schema 的 Source 可以通过 `schema` 块显式声明字段。`Jdbc` 等 Source 会从表或查询的元数据推断
+schema;对 `Jdbc` 而言,`schema` 是一个字符串参数,表示数据库的 schema 名称,而不是字段列表。
+
 ```hocon
 source {
-  Jdbc {
-    url = "..."
-    query = "SELECT * FROM users"
+  Kafka {
+    bootstrap.servers = "localhost:9092"
+    topic = "users"
+    format = json
 
-    # 覆盖推断的模式
+    # 声明 JSON 消息的 schema
     schema {
       fields {
         id = "BIGINT"
diff --git a/docs/zh/architecture/api-design/sink-architecture.md 
b/docs/zh/architecture/api-design/sink-architecture.md
index 2474e72a851..0030b9238ca 100644
--- a/docs/zh/architecture/api-design/sink-architecture.md
+++ b/docs/zh/architecture/api-design/sink-architecture.md
@@ -183,7 +183,7 @@ sequenceDiagram
 **契约要点**:
 - `commit(commitInfos)`:对一批提交信息执行提交;必须支持重试,因此要求幂等
 - 返回值语义:返回“仍需重试/未完成”的提交信息集合(框架会在后续 checkpoint 或恢复路径中重试)
-- `abort(commitInfos)`(可选):放弃提交并做资源清理(例如回滚事务、删除临时文件)
+- `abort(commitInfos)`:放弃提交并做资源清理(例如回滚事务、删除临时文件)。这是抽象方法,每个 committer 
都必须实现;Spark 在写入任务中止时调用,SeaTunnel Engine 在 checkpoint 中止时调用
 
 **关键要求**:
 - `commit()` **必须**是幂等的(使用相同的 commitInfo 调用两次应该是安全的)
diff --git a/docs/zh/architecture/api-design/translation-layer.md 
b/docs/zh/architecture/api-design/translation-layer.md
index db11a265d78..61d7b75c44e 100644
--- a/docs/zh/architecture/api-design/translation-layer.md
+++ b/docs/zh/architecture/api-design/translation-layer.md
@@ -92,10 +92,10 @@ flowchart TB
 ### 2.3 FlinkSourceEnumerator 适配器
 
 **适配点(语义级)**:
-- 生命周期:Flink enumerator 的 `start` 驱动 SeaTunnel enumerator 的 open/run
+- 生命周期:Flink enumerator 的 `start` 只调用 SeaTunnel enumerator 的 `open`;`run` 会在所有 
reader 通过 `addReader`(内部调用 `registerReader`)注册完成后才执行一次
 - 分片请求:Flink 的 split request 透传给 SeaTunnel enumerator 的分片分配逻辑
 - 分片回退:把回退 split 解包并回交给 SeaTunnel enumerator
-- 状态快照:把 enumerator state 包装成 Flink 可持久化的 wrapper,以参与 checkpoint
+- 状态快照:SeaTunnel enumerator 的 state 不做包装,直接作为 Flink 的 enumerator checkpoint 
类型(`EnumStateT`),由 `FlinkSimpleVersionedSerializer` 序列化
 
 ### 2.4 上下文适配器
 
@@ -103,7 +103,7 @@ flowchart TB
 
 - 下标与并行度:把 Flink 的 subtask index 映射为 SeaTunnel reader 的 index
 - 事件通道:把 SeaTunnel 的 SourceEvent 包装后发送到 Flink 的 coordinator/event channel
-- 分片请求:Flink 会在运行时自动触发 split request,SeaTunnel 侧通常不需要显式触发
+- 分片请求:`sendSplitRequest()` 直接转发给 Flink `SourceReaderContext` 的 
`sendSplitRequest()`
 
 **FlinkSourceSplitEnumeratorContext**:
 
@@ -132,39 +132,44 @@ flowchart TB
 ### 3.1 SparkSource 适配器
 
 将 `SeaTunnelSource` 适配到 Spark 的数据源接口(Spark 2.4 与 Spark 3.x 使用的 DataSource API 
形态不同,具体以对应版本适配模块实现为准)。
+Spark 2.4 的入口是 `SeaTunnelSourceSupport`(批处理由 `BatchSourceReader` 实现 
`DataSourceReader`),Spark 3.3 的入口是
+`SeaTunnelSparkSource`(`SeaTunnelScan`、`SeaTunnelBatch`)。
 
 **适配点(语义级)**:
 - `readSchema`:把 SeaTunnel `CatalogTable/TableSchema` 映射为 Spark `StructType`
-- `planInputPartitions`:在 Spark 的批处理模型下,通常一次性生成全部 splits,并为每个 split 构造一个 
`InputPartition`
+- `planInputPartitions`:分片不会在 Driver 侧枚举。它按并行度为每个 subtask 生成一个虚拟分区;如果 Source 
实现了
+  `SupportCoordinate`,则只生成一个分区
 
-Spark 的执行模型偏“批式规划”,因此枚举器的职责更像是“规划阶段生成分片集合”,而不是长期运行的调度器。
+每个分区在 executor 任务中运行 SeaTunnel 的 enumerator 和 reader(通过 `ParallelSource` 或 
`CoordinatedSource`),
+因此 split 的生成与分配发生在 executor 侧,而不是 Spark 的规划阶段。
 
-### 3.2 SparkInputPartition
+### 3.2 BatchPartition
 
 **适配点(语义级)**:
-- 每个 `InputPartition` 绑定一个 SeaTunnel split
-- `createPartitionReader` 创建 SeaTunnel reader,注入该 split,并把输出转换为 Spark 
`InternalRow`
+- 每个 `InputPartition`(Spark 2.4 为 `BatchPartition`,Spark 3.3 为 
`SeaTunnelBatchInputPartition`)对应一个 subtask,而不是一个 split
+- `createPartitionReader` 创建 `ParallelBatchPartitionReader`(或 
`CoordinatedBatchPartitionReader`),由它在本地创建 enumerator 和 reader,并把输出转换为 Spark 
`InternalRow`
 
-### 3.3 SparkPartitionReader
+### 3.3 SeaTunnelInputPartitionReader
 
 **适配点(语义级)**:
-- 初始化:创建并打开 SeaTunnel reader,下发 split
+- 初始化:创建并打开本 subtask 的 SeaTunnel enumerator 和 reader,由 enumerator 分配 split
 - 读取循环:从 SeaTunnel reader 拉取记录并转换为 Spark `InternalRow`(必要时使用缓冲队列适配 pull-based 
API)
 - 资源释放:关闭 reader 并释放外部资源
 
 ### 3.4 SparkSink 适配器
 
 **适配点(语义级)**:
+- 入口:`SparkSink` 实现 `WriteSupport`/`StreamWriteSupport`,真正的 `DataSourceWriter` 
是 `SparkDataSourceWriter`
 - writer factory:在 executor 侧创建写入器实例并接收 Spark `InternalRow`
-- commit coordinator:当目标端存在提交器时启用 Spark 的提交协调路径
-- commit/abort:把 Spark 的提交消息转换为 SeaTunnel 的 commitInfo 列表,并交由 SeaTunnel 
`SinkCommitter` 执行(要求幂等/可重试)
+- executor 侧提交:每个 `SparkDataWriter` 在 `DataWriter#commit()` 中调用 
`prepareCommit`,并执行该 writer 的 SeaTunnel `SinkCommitter`,再把 commitInfo 放入 
`SparkWriterCommitMessage` 返回
+- driver 侧 commit/abort:`SparkDataSourceWriter` 把提交消息中的 commitInfo 交给 
SeaTunnel `SinkAggregatedCommitter` 的 `combine`,再执行 `commit`/`abort`(要求幂等/可重试)
 
 ## 4. 序列化适配器
 
 ### 4.1 FlinkSimpleVersionedSerializer
 
 **适配点(语义级)**:
-- 版本:将 SeaTunnel serializer 的版本号透传到 Flink 侧
+- 版本:SeaTunnel 的 `Serializer` 没有版本概念,适配器的 `getVersion()` 固定返回 `0`
 - 序列化/反序列化:直接委托给 SeaTunnel serializer,以保证跨引擎一致的状态编码
 
 ## 5. 类型转换
diff --git a/docs/zh/connectors/sink/SensorsData.md 
b/docs/zh/connectors/sink/SensorsData.md
index 113503a4d90..ecff0e7d61f 100644
--- a/docs/zh/connectors/sink/SensorsData.md
+++ b/docs/zh/connectors/sink/SensorsData.md
@@ -254,26 +254,26 @@ sink {
 
 ### 项目跟踪
 
+物品记录必须设置 `entity_name = items`。`entity_name` 的默认值是 `users`,在该默认值下
+`record_type = items` 会在写入器启动时以 `UNSUPPORTED_RECORD_TYPE` 报错。物品记录只使用
+`item_id_column`、`item_type_column`、`property_fields` 以及可选的 
`time_column`;`schema`、
+`event_name`、`distinct_id_column`、`identity_fields` 等仅用于用户记录的参数无需配置。
+
 ```hocon
 sink {
   SensorsData {
     server_url = "http://10.1.136.63:8106/sa?project=default";
     time_free = true
 
+    entity_name = items
     record_type = items
-    schema = items
-    event_name = "$ItemViewed"
+    item_id_column = product_id
+    item_type_column = product_type
     time_column = view_time
-    distinct_id_column = user_id
-    identity_fields = [
-      { source = user_id, target = "$identity_login_id" }
-    ]
     property_fields = [
       { target = "view_duration", source = duration, type = INT }
       { target = "referrer", source = referrer_url, type = STRING }
     ]
-    item_id_column = product_id
-    item_type_column = product_type
   }
 }
 ```
@@ -340,6 +340,9 @@ sink {
 
 ### 控制台输出(用于测试)
 
+这里 `entity_name` 保持默认值 `users`,因此和其他用户记录示例一样必须配置 `identity_fields`;
+缺少该参数时作业会在参数校验阶段失败。
+
 ```hocon
 sink {
   SensorsData {
@@ -350,6 +353,9 @@ sink {
     event_name = "$TestEvent"
     time_column = timestamp
     distinct_id_column = test_id
+    identity_fields = [
+      { source = test_id, target = "$identity_distinct_id" }
+    ]
     property_fields = [
       { target = "test", source = test_field, type = STRING }
     ]
diff --git a/docs/zh/connectors/source/GoogleBigtable.md 
b/docs/zh/connectors/source/GoogleBigtable.md
index 0b360ab97d5..62faba5729d 100644
--- a/docs/zh/connectors/source/GoogleBigtable.md
+++ b/docs/zh/connectors/source/GoogleBigtable.md
@@ -42,6 +42,7 @@ import ChangeLog from 
'../changelog/connector-google-bigtable.md';
 | end_timestamp   | long   | 否     | -    |
 | max_versions    | int    | 否     | 1    |
 | scan_row_limit  | int    | 否     | -1   |
+| schema          | config | 是     | -    |
 | common-options  |        | 否     | -    |
 
 ### project_id [string]
@@ -92,6 +93,13 @@ Cell 时间戳过滤的结束值,不包含该时间戳,单位是微秒。
 
 每个 split 最多读取的行数。默认值 `-1` 表示不限制。当 Enumerator 切出多个 split 时,作业级上限约为 
`scan_row_limit × split 数`,而不是整表一条上限。把 `scan_row_limit` 与 `start_rowkey` / 
`end_rowkey` 配合,可以在多个作业之间分页扫描整张表。
 
+### schema [config]
+
+Source 的输出 schema。该参数为必填:Source 根据 `schema` 构建输出表,缺少时会在启动阶段报错
+`Schema config need option [schema]`。字段名需遵循 [Schema 映射](#schema-映射) 中的
+`familyName:qualifier` 格式,行键字段由 `rowkey_column` 指定。通用语法见
+[Schema 特性](../../introduction/concepts/schema-feature.md)。
+
 ### common options
 
 Source 插件通用参数,详见 [Source Common 
Options](../common-options/source-common-options.md)。
diff --git a/docs/zh/connectors/source/Phoenix.md 
b/docs/zh/connectors/source/Phoenix.md
index 7f623eb6b4c..51c883af81c 100644
--- a/docs/zh/connectors/source/Phoenix.md
+++ b/docs/zh/connectors/source/Phoenix.md
@@ -44,7 +44,7 @@ import ChangeLog from '../changelog/connector-jdbc.md';
 
|----------------|--------|----------|--------|-------------------------------------------------------------------------------------------------|
 | driver         | String | 是       | -      | JDBC 驱动类。thick 驱动使用 
`org.apache.phoenix.jdbc.PhoenixDriver`,thin 驱动使用 
`org.apache.phoenix.queryserver.client.Driver`。 |
 | url            | String | 是       | -      | JDBC 连接 URL。thick 驱动使用 
`jdbc:phoenix:localhost:2182/hbase`,thin 驱动使用 
`jdbc:phoenix:thin:url=http://localhost:8765;serialization=PROTOBUF`。 |
-| query          | String | 条件必填    | -      | 读取数据时执行的 SELECT 查询,例如 `select 
age, name from test.source`。SELECT 列表的列顺序需要和 `schema.fields` 一致。未配置 
`table_path` 或 `table_list` 时必填。 |
+| query          | String | 条件必填    | -      | 读取数据时执行的 SELECT 查询,例如 `select 
age, name from test.source`。输出 schema 由 SELECT 列表中的列推断得到,无需声明 
`schema.fields`。未配置 `table_path` 或 `table_list` 时必填。 |
 | common-options |        | 否       | -      | 源插件通用参数,详见 [Source 
通用选项](../common-options/source-common-options.md)。           |
 
 ### driver [string]
diff --git a/docs/zh/connectors/source/Vertica.md 
b/docs/zh/connectors/source/Vertica.md
index 8249fa24032..a87faf3f2d4 100644
--- a/docs/zh/connectors/source/Vertica.md
+++ b/docs/zh/connectors/source/Vertica.md
@@ -71,7 +71,7 @@ import ChangeLog from '../changelog/connector-jdbc.md';
 | password | String | 否 | - | 连接实例密码 |
 | query | String | 否 | - | 查询语句。未配置 `table_path` 和 `table_list` 时必填。 |
 | connection_check_timeout_sec | Int | 否 | 30 | 等待用于验证连接的数据库操作完成的时间(秒) |
-| partition_column | String | 否 | - | 用于并行性分割的列名,仅支持数值类型,仅支持数值类型主键,只能配置一列。 |
+| partition_column | String | 否 | - | 用于并行性分割的列名,支持数值、字符串和日期类型的列,只能配置一列。 |
 | partition_lower_bound | String | 否 | - | partition_column 
的最小值用于扫描,如果未设置,SeaTunnel 将查询数据库获取最小值。 |
 | partition_upper_bound | String | 否 | - | partition_column 
的最大值用于扫描,如果未设置,SeaTunnel 将查询数据库获取最大值。 |
 | partition_num | Int | 否 | 10 | 分割数量,仅支持正整数。默认值是 10。 |
diff --git a/docs/zh/developer/coding-guide.md 
b/docs/zh/developer/coding-guide.md
index 8ee04d4374a..31396e15bf3 100644
--- a/docs/zh/developer/coding-guide.md
+++ b/docs/zh/developer/coding-guide.md
@@ -46,7 +46,10 @@
    try {
        // read logic
    } catch (IOException e) {
-       throw SeaTunnelORCFormatException("This orc file is corrupted, please 
check it", e);
+       throw new FileConnectorException(
+               FileConnectorErrorCode.FILE_READ_FAILED,
+               "This orc file is corrupted, please check it",
+               e);
    }
    ```
 
diff --git a/docs/zh/developer/setup.md b/docs/zh/developer/setup.md
index dbcaec14821..92f6f257f40 100644
--- a/docs/zh/developer/setup.md
+++ b/docs/zh/developer/setup.md
@@ -15,7 +15,7 @@
 
 * 安装 [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)。
 * 安装 [Java](https://www.java.com/en/download/) (目前只支持 JDK11/JDK17) 并且设置 
`JAVA_HOME` 环境变量。
-* 安装 [Scala](https://www.scala-lang.org/download/2.11.12.html) (目前只支持 scala 
2.11.12)。
+* 安装 [Scala](https://www.scala-lang.org/download/2.12.15.html) (项目构建使用 scala 
2.12.15)。
 * 安装 [JetBrains IDEA](https://www.jetbrains.com/idea/)。
 
 ## 设置
diff --git a/docs/zh/getting-started/application/kubernetes/configuration.md 
b/docs/zh/getting-started/application/kubernetes/configuration.md
index 8706844d3bc..a38e49373da 100644
--- a/docs/zh/getting-started/application/kubernetes/configuration.md
+++ b/docs/zh/getting-started/application/kubernetes/configuration.md
@@ -45,7 +45,7 @@ Application Mode 在提交机上读取部署文件(`-a`,包含 `application.
 | `kubernetes.env.<NAME>` | map | no | - | 每个环境变量一行:字面值、`secret:<name>/<key>` 
或 `configmap:<name>/<key>`。 |
 | `kubernetes.env-from.secret` | string | no | - | 已有 Secret,其全部 key 
注入为环境变量(等价 Kubernetes `envFrom.secretRef`)。 |
 | `kubernetes.env-from.configmap` | string | no | - | 已有 ConfigMap,其全部 key 
注入为环境变量(等价 Kubernetes `envFrom.configMapRef`)。 |
-| `kubernetes.kubeconfig` | string | no | SDK 默认 | 提交端本地 kubeconfig;不会分发到 
Master。应写入权限受限的部署配置文件,不要通过 `-i` 传递。 |
+| `kubernetes.kubeconfig` | string | no | SDK 默认 | 提交端本地 kubeconfig;不会分发到 
Master。应写入权限受限的部署配置文件,不要通过 `-D` 传递。 |
 | `kubernetes.finished-job-retention-seconds` | int | no | `86400` | 完成或失败 Job 
的保留秒数,必须为正数。 |
 | `kubernetes.active-deadline-seconds` | long | no | - | 整个 application 
的绝对超时秒数,从 Job 创建算起,包含 Master 启动。无人值守的批作业建议设置;不设置时 Job 会一直处于 Active,直到作业结束或被取消。 |
 | `kubernetes.checkpoint-pvc` | string | no | - | 已有 PVC,挂载到 Master 的 
`kubernetes.checkpoint-directory`。 |
diff --git a/docs/zh/getting-started/application/kubernetes/faq.md 
b/docs/zh/getting-started/application/kubernetes/faq.md
index 647424464c8..fadb3858285 100644
--- a/docs/zh/getting-started/application/kubernetes/faq.md
+++ b/docs/zh/getting-started/application/kubernetes/faq.md
@@ -71,5 +71,5 @@ Job 会一直处于 `Active`,`status --wait` 会持续轮询;可以用 `--wa
 - 私有镜像凭据通过 ServiceAccount 或集群配置管理。
 - 限制 application Secret 的读取权限;集群安全策略要求时,为 Kubernetes Secret 启用静态加密。
 - 不在日志中暴露 Connector 凭据,优先使用 Connector、文件系统或集群支持的凭据机制。
-- 将 `kubernetes.kubeconfig` 写入权限受限的部署配置文件,或使用 Kubernetes SDK 默认配置。不要通过 `-i` 
传递,因为提交主机上的其他用户可能看到命令行参数。
+- 将 `kubernetes.kubeconfig` 写入权限受限的部署配置文件,或使用 Kubernetes SDK 默认配置。不要通过 `-D` 
传递,因为提交主机上的其他用户可能看到命令行参数。
 - 使用 NetworkPolicy 时仅放行需要的 Hazelcast 与外部数据系统流量。
diff --git a/docs/zh/getting-started/kubernetes/configuration.md 
b/docs/zh/getting-started/kubernetes/configuration.md
index 2f961a22c98..295c6e80c06 100644
--- a/docs/zh/getting-started/kubernetes/configuration.md
+++ b/docs/zh/getting-started/kubernetes/configuration.md
@@ -176,7 +176,7 @@ seatunnel:
 
 Master 节点负责 IMap 状态存储。生产环境建议启用 MapStore,并将数据写入共享存储或对象存储。分离集群模式下只需要在 
`hazelcast-master.yaml` 中配置 MapStore,Worker 不需要配置。
 
-MapStore 使用 `FileMapStoreFactory`。其中 `type: hdfs` 是 IMap 文件存储工厂的标识,使用 S3 或 OSS 
时也保持不变;真正的底层存储由 `storage.type` 决定,当前支持 `hdfs`、`s3` 和 `oss`。
+MapStore 使用 `FileMapStoreFactory`。其中 `type: hdfs` 是 IMap 文件存储工厂的标识,使用 S3、OSS 或 
GCS 时也保持不变;真正的底层存储由 `storage.type` 决定,当前支持 `hdfs`、`s3`、`oss` 和 `gcs`。
 
 ### Checkpoint Monitor MapStore
 
diff --git a/docs/zh/getting-started/locally/quick-start-flink.md 
b/docs/zh/getting-started/locally/quick-start-flink.md
index 2cdd8aea3c7..53a5f6a7e49 100644
--- a/docs/zh/getting-started/locally/quick-start-flink.md
+++ b/docs/zh/getting-started/locally/quick-start-flink.md
@@ -103,25 +103,26 @@ cd "apache-seatunnel-${version}"
 
 SeaTunnel控制台将会打印一些如下日志信息:
 
+日志前缀(时间、线程、日志格式)以及 `tableId` 的取值取决于引擎的日志配置和具体作业,下面以 `...` 表示。`FieldMapper` 按 
`field_mapper` 中的顺序输出字段,并把 `name` 重命名为 `new_name`,因此输出的 row type 为 `age<INT>, 
new_name<STRING>`。
+
 ```shell
-fields : name, age
-types : STRING, INT
-row=1 : elWaB, 1984352560
-row=2 : uAtnp, 762961563
-row=3 : TQEIB, 2042675010
-row=4 : DcFjo, 593971283
-row=5 : SenEb, 2099913608
-row=6 : DHjkg, 1928005856
-row=7 : eScCM, 526029657
-row=8 : sgOeE, 600878991
-row=9 : gwdvw, 1951126920
-row=10 : nSiKE, 488708928
-row=11 : xubpl, 1420202810
-row=12 : rHZqb, 331185742
-row=13 : rciGD, 1112878259
-row=14 : qLhdI, 1457046294
-row=15 : ZTkRx, 1240668386
-row=16 : SGZCr, 94186144
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
output rowType: age<INT>, new_name<STRING>
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=1:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1984352560, elWaB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=2:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 762961563, uAtnp
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=3:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2042675010, TQEIB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=4:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 593971283, DcFjo
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=5:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2099913608, SenEb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=6:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1928005856, DHjkg
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=7:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 526029657, eScCM
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=8:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 600878991, sgOeE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=9:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1951126920, gwdvw
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=10:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 488708928, nSiKE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=11:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1420202810, xubpl
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=12:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 331185742, rHZqb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=13:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1112878259, rciGD
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=14:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1457046294, qLhdI
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=15:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1240668386, ZTkRx
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=16:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 94186144, SGZCr
 ```
 
 ## 此外
diff --git a/docs/zh/getting-started/locally/quick-start-spark.md 
b/docs/zh/getting-started/locally/quick-start-spark.md
index ca1fb521d4f..57689ba69c9 100644
--- a/docs/zh/getting-started/locally/quick-start-spark.md
+++ b/docs/zh/getting-started/locally/quick-start-spark.md
@@ -125,25 +125,26 @@ cd "apache-seatunnel-${version}"
 
 SeaTunnel控制台将会打印一些如下日志信息:
 
+日志前缀(时间、线程、日志格式)以及 `tableId` 的取值取决于引擎的日志配置和具体作业,下面以 `...` 表示。`FieldMapper` 按 
`field_mapper` 中的顺序输出字段,并把 `name` 重命名为 `new_name`,因此输出的 row type 为 `age<INT>, 
new_name<STRING>`。
+
 ```shell
-fields : name, age
-types : STRING, INT
-row=1 : elWaB, 1984352560
-row=2 : uAtnp, 762961563
-row=3 : TQEIB, 2042675010
-row=4 : DcFjo, 593971283
-row=5 : SenEb, 2099913608
-row=6 : DHjkg, 1928005856
-row=7 : eScCM, 526029657
-row=8 : sgOeE, 600878991
-row=9 : gwdvw, 1951126920
-row=10 : nSiKE, 488708928
-row=11 : xubpl, 1420202810
-row=12 : rHZqb, 331185742
-row=13 : rciGD, 1112878259
-row=14 : qLhdI, 1457046294
-row=15 : ZTkRx, 1240668386
-row=16 : SGZCr, 94186144
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
output rowType: age<INT>, new_name<STRING>
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=1:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1984352560, elWaB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=2:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 762961563, uAtnp
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=3:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2042675010, TQEIB
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=4:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 593971283, DcFjo
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=5:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 2099913608, SenEb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=6:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1928005856, DHjkg
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=7:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 526029657, eScCM
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=8:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 600878991, sgOeE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=9:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1951126920, gwdvw
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=10:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 488708928, nSiKE
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=11:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1420202810, xubpl
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=12:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 331185742, rHZqb
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=13:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1112878259, rciGD
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=14:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1457046294, qLhdI
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=15:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 1240668386, ZTkRx
+... INFO  
org.apache.seatunnel.connectors.seatunnel.console.sink.ConsoleSinkWriter - 
subtaskIndex=0  rowIndex=16:  SeaTunnelRow#tableId=... SeaTunnelRow#kind=INSERT 
: 94186144, SGZCr
 ```
 
 ## 此外

Reply via email to