企业官网建设流程全解析

1. 单表追加同步：把一张 PostgreSQL 表同步到另一张 PostgreSQL 表

本节先从最简单的 PostgreSQL 到 PostgreSQL 单表同步开始。

这个场景非常基础：从源端 PostgreSQL 库test1中读取一张表t_test_1w，然后写入目标端 MySQL 库test2中的test_1w表。

本示例有几个特点：

• 不使用query
• 不做字段转换
• 不自动创建目标表
• 使用追加写入模式
• 适合先把最基础的 JDBC Source 和 JDBC Sink 跑通

编写单表同步 HOCON

下面是一个最简单的 PostgreSQL 到 PostgreSQL 单表同步配置：

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

这个任务的含义很简单：

从 PostgreSQL 的 public.t_test_1w 读取数据 追加写入到 MySQL 的 test_1w

这里没有配置query，而是直接使用table_path指定源表。

理解配置和注意事项

这个配置主要分为四部分：`env`、`source`、`transform` 和 `sink`。

env 表示任务运行方式。

env { job { mode = BATCH } parallelism = 1 }

mode = BATCH表示这是一个批处理任务。任务会读取当前源表中的存量数据，写入目标表后结束。

parallelism = 1表示并行度为 1。对于入门示例来说，这样更简单，也更容易观察任务执行结果。

source 表示数据从哪里来。

source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } }

这里使用的是Jdbc连接器，连接源端 PostgreSQL 数据库test1。

其中最重要的是：

"table_path" = "public.t_test_1w"

它表示读取 PostgreSQLpublicschema 下的t_test_1w表。

transform 暂时为空。

transform { }

这里不做字段映射、不做字段改名、不做 SQL 处理，数据会直接从 source 流向 sink。

sink 表示数据写到哪里去。

sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

这里连接的是目标端 MySQL 数据库test2，写入目标表test_1w。

需要注意的是，本示例不自动建表。

所以在运行任务之前，需要先在目标端 MySQL 中创建好表：

-- PostgreSQL 目标端建表示例，字段请根据源表结构调整CREATETABLEpublic.test_1w(idBIGINT,nameVARCHAR(128),emailVARCHAR(256),statusVARCHAR(32),create_timeTIMESTAMP);

如果目标表不存在，任务写入时会失败。

另外，这里使用的是追加写入模式：

"data_save_mode" = "APPEND_DATA"

它表示每次运行任务时，都会把源表数据追加写入目标表。

如果重复执行任务，目标表中可能会出现重复数据。

这里关闭了 upsert：

"enable_upsert" = false

因为这是最简单的追加同步场景，不需要根据主键判断插入还是更新。

如果后面要做主键更新，再单独讲enable_upsert = true和主键配置。

适用场景

这个配置适合下面几类场景：

• 第一次学习 PostgreSQL 到 PostgreSQL 同步

• 源端 PostgreSQL 表和目标端 MySQL 表结构一致

• 目标表已经提前创建好

• 只需要做一次全量数据搬迁

• 允许数据追加写入

• 用来验证 JDBC Source 和 JDBC Sink 是否正常
  比如下面这种情况就非常适合：

源表：public.t_test_1w
目标表：test_1w
同步方式：全量读取 + 追加写入
建表方式：目标表提前创建

运行前可以先检查源表数据量： ```text SELECT COUNT(*) FROM public.t_test_1w;

再检查目标表是否存在：

SELECT column_name, data_type, character_maximum_length FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'test_1w' ORDER BY ordinal_position;

如果目标表已经存在，并且字段结构和源表一致，就可以运行这个同步任务。

2. 单表条件同步：只同步符合条件的数据

这一节，我们在上一节基础上，增加条件过滤，只同步源表中符合条件的部分数据。

比如，源表test1.t_test_1w中有一个status字段，我们只想同步status = 'ACTIVE'的数据到目标端 MySQL 表test_1w。

编写带条件的 HOCON

HOCON 配置如下：

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" query = "SELECT * FROM public.t_test_1w WHERE status = 'ACTIVE'" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

核心变化是 source 里增加了query参数：

query = "SELECT * FROM public.t_test_1w WHERE status = 'ACTIVE'"

这样，SeaTunnel 只会读取符合条件的数据。

理解配置和注意事项

**query 参数**：

• 用于 SQL 级别过滤数据

• 可以写任意合法 SQL

• 不使用 query 时，会直接读取整个表（对应上节示例）
  例如：

  SELECT*FROMpublic.t_test_1wWHEREstatus='ACTIVE'ANDcreate_time>'2026-06-01'

  sink 配置：保持和上一节一致：

• 追加写入APPEND_DATA

• 每批写入batch_size条数据

• 不做 upsert
  注意事项：

• table_path+query组合使用时，会按照 query 获取数据

• query 中字段必须和源表字段一致，否则写入目标表可能失败

• 目标表依然需要提前创建

适用场景

这个配置适合：

• 只同步部分数据，例如：

• 只同步status = 'ACTIVE'

• 只同步最近一周新增的数据

• 只同步某个部门的数据

• 源表数据量大，但目标表只需要一部分

• 目标表已经创建，结构和源表一致

• 不希望一次同步整个表，提高效率
  示例：

源表：public.t_test_1w
目标表：test_1w
条件：status = ‘ACTIVE’
同步方式：全量读取符合条件 + 追加写入
```

3. 单表字段映射：源表字段和目标表字段不一致

在实际项目中，源端 PostgreSQL 表和目标端 MySQL 表字段不一定完全一致。
比如源表t_test_1w有字段id, name, email，目标表可能是user_id, full_name, email_address。

本节演示如何使用FieldMapper在 transform 阶段完成字段映射。

编写带字段映射的 HOCON

HOCON 配置如下：

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } } transform { FieldMapper { mappings = [ { sourceField = "id", targetField = "user_id", targetType = "bigint" } { sourceField = "name", targetField = "full_name", targetType = "varchar(128)" } { sourceField = "email", targetField = "email_address", targetType = "varchar(256)" } ] } } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

核心变化在transform部分，我们通过FieldMapper映射源表字段到目标表字段：

• id → user_id

• name → full_name

• email → email_address

理解配置和注意事项

**transform.FieldMapper** 配置：

• sourceField：源表字段名

• targetField：目标表字段名

• targetType：目标字段类型，可做类型转换
  注意事项：

• 映射的字段必须存在于源表，否则会报错

• 目标表必须提前创建，并且字段类型尽量与targetType匹配

• 不需要修改 sink 配置，FieldMapper 会在写入前自动处理字段对应关系

• 仍然使用追加模式APPEND_DATA，不会覆盖目标表数据

适用场景

字段映射适合以下场景：

• 源表字段和目标表字段名称不一致
• 目标表已经建好，但不能修改字段名
• 想在同步时做字段类型转换（如int → bigint或varchar → varchar(256))
• 保持数据一致性，同时对接已有业务系统

示例：

源表：id, name, email 目标表：user_id, full_name, email_address 同步方式：全量读取 + 字段映射 + 追加写入

4. 单表自动建表：目标表不存在时自动创建

在实际项目中，目标表可能尚未创建。
这时可以使用自动建表功能，SeaTunnel 会根据源表结构自动在目标库创建表，然后再写入数据。

编写自动建表 HOCON

HOCON 配置如下：

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false "schema_save_mode" = "CREATE_SCHEMA_WHEN_NOT_EXIST" } }

核心变化在 sink 配置：

"schema_save_mode" = "CREATE_SCHEMA_WHEN_NOT_EXIST"

这个参数表示：

• 如果目标表不存在，SeaTunnel 会自动根据源表结构创建

• 已存在的表不会覆盖

理解配置和注意事项

**sink.schema_save_mode** 说明：

• CREATE_SCHEMA_WHEN_NOT_EXIST：目标表不存在时自动建表

• 自动建表时，字段类型和源表一致

• 不会覆盖已有表，安全追加数据

• 配合generate_sink_sql = true使用，系统会生成完整 insert SQL
  注意事项：

• 自动建表功能依赖数据库账号有建表权限

• 如果目标端 MySQL 没有权限，会报错

• enable_upsert仍然可选，如果要做主键更新，需要确保建表时设置主键

适用场景

自动建表适合以下场景：

• 目标表尚未创建
• 想快速部署数据同步任务
• 源表字段结构固定，可以直接建表
• 适合测试环境或开发环境快速搭建

示例：

源表：public.t_test_1w 目标表：test_1w（不存在） 同步方式：全量读取 + 自动建表 + 追加写入

5. 单表主键更新：使用 upsert 避免重复数据

在实际业务中，源表可能会有更新或重复数据。
如果直接追加写入，目标表可能会产生重复记录。
这时可以使用upsert功能，根据主键判断插入或更新。

编写带 upsert 的 HOCON

HOCON 配置如下：

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } } transform { FieldMapper { mappings = [ { sourceField = "id", targetField = "user_id", targetType = "bigint" } { sourceField = "name", targetField = "full_name", targetType = "varchar(128)" } { sourceField = "email", targetField = "email_address", targetType = "varchar(256)" } ] } } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = true primary_keys = ["user_id"] } }

核心变化在 sink 配置：

"enable_upsert" = true primary_keys = ["user_id"]

• enable_upsert = true：启用增量更新

• primary_keys：指定目标表判断插入/更新的字段

理解配置和注意事项

**enable_upsert 注意事项**：

• 必须指定primary_keys，否则任务会报错

• primary_keys最好选择目标表中的主键字段或有索引的字段，否则 upsert 写入时需要频繁判断数据是否存在，性能会比较差

• upsert 模式会在写入前根据主键判断记录是否存在

• 存在 → 更新

• 不存在 → 插入

• data_save_mode仍可使用APPEND_DATA，upsert 会覆盖匹配主键的数据

• 与generate_sink_sql配合使用，系统自动生成带主键判断的 SQL
  其他注意事项：

• 确保目标表主键和primary_keys对应字段一致

• 目标表必须存在，或配合自动建表功能使用

• 对大表开启 upsert 时，建议设置合适的batch_size提升写入性能

适用场景

upsert 适合以下业务场景：

• 源表可能更新已有数据
• 避免目标表产生重复记录
• 保证目标表数据一致性
• 配合字段映射使用，实现源表字段和目标表字段不一致也能正确更新

示例：

源表：id, name, email 目标表：user_id, full_name, email_address 同步方式：增量更新 + 追加写入 + 字段映射 主键：user_id

6. 单表覆盖同步：每次同步前清空目标表

前面几个示例主要使用的是追加写入模式，也就是每次同步都会把数据继续写入目标表。

但在一些场景中，目标表不需要保留历史数据，只需要和源表当前数据保持一致。比如维表、字典表、配置表等，每次同步都以源表最新数据为准。

这时可以使用覆盖同步模式：

"data_save_mode" = "DROP_DATA"

它表示在写入目标表之前，先清空目标表中的已有数据，然后再重新写入本次同步的数据。

编写覆盖同步 HOCON

env { job { mode = BATCH } parallelism = 1 } source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_1w" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "DROP_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

这个任务的含义是：

从 PostgreSQL 的 public.t_test_1w 读取数据 写入 test_1w 写入前先清空目标表已有数据

也就是说，任务执行完成后，目标表中只保留本次从源表同步过来的数据。

理解配置和注意事项

覆盖同步的核心配置是：

"data_save_mode" = "DROP_DATA"

它和追加同步最大的区别是：

• APPEND_DATA：保留目标表原有数据，继续追加写入

• DROP_DATA：先清空目标表原有数据，再重新写入
  在覆盖同步场景中，一般不需要开启 upsert：

"enable_upsert" = false

因为目标表已经在写入前被清空，后续数据都是重新插入，不需要再根据主键判断更新或插入。

需要注意的是，DROP_DATA会清空目标表数据，所以使用前要确认目标表是否允许被清空。

另外，目标端 MySQL 表字段需要和写入数据匹配。可以提前创建目标表：

-- PostgreSQL 目标端建表示例，字段请根据源表结构调整CREATETABLEpublic.test_1w(idBIGINT,nameVARCHAR(128),emailVARCHAR(256),statusVARCHAR(32),create_timeTIMESTAMP);

如果想让目标表不存在时自动创建，也可以配合自动建表配置：

"schema_save_mode" = "CREATE_SCHEMA_WHEN_NOT_EXIST"

适用场景

覆盖同步适合下面几类场景：

• 维表同步，例如用户维表、部门维表、区域维表

• 字典表同步，例如状态码、类型码、枚举配置

• 配置表同步，例如业务参数、规则配置

• 测试环境刷新数据，每次以源表为准

• 目标表不需要保留历史数据，只需要最新快照
  比如下面这种情况就比较适合：

源表：public.t_test_1w 目标表：test_1w 同步方式：全量读取源表 写入方式：清空目标表后重新写入 目标效果：目标表和源表当前数据保持一致

如果目标表需要保留历史数据，建议使用APPEND_DATA。

如果目标表需要根据主键更新已有数据，建议使用enable_upsert = true。

7. 单表字段裁剪：只同步需要的字段

在很多场景中，源表字段较多，但目标表只需要其中部分字段。直接同步所有字段会增加网络和数据库压力，也可能写入冗余数据。

这时可以使用字段裁剪方式，通过 SQL 查询或 FieldMapper 只同步需要的字段。

编写字段裁剪 HOCON

sink { Jdbc { database = test2 table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true } }

这个配置的含义是：只读取源表的id、name和create_time字段，并写入目标表。

理解配置和注意事项

• 通过query选择需要的字段，减少网络传输和目标表写入压力

• 可以配合FieldMapper对字段重命名或类型转换

• 目标表字段需和查询字段匹配，否则写入可能失败

适用场景

• 源表字段多，但目标表只关心部分字段

• 开发或测试环境，只需要部分数据验证

• 需要减少冗余数据传输和存储压力
  示例：

目标表：只需要 id, name, create_time 同步方式：全量读取指定字段 + 追加写入

8. 单表时间范围同步：只同步某一天或某一周的数据

在实际同步任务中，并不是每次都需要同步整张表。

如果源表数据量比较大，或者任务是每天定时执行，通常只需要同步某个时间范围内的数据，比如昨天的数据、最近一周的数据，或者某个固定日期的数据。

这时可以通过query配置时间条件，只读取指定时间范围的数据。

编写时间范围同步 HOCON

} source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" query = "SELECT * FROM public.t_test_1w WHERE create_time >= '2026-06-01 00:00:00' AND create_time < '2026-06-02 00:00:00'" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_1w" "data_save_mode" = "APPEND_DATA" "batch_size" = 1000 "generate_sink_sql" = true "enable_upsert" = false } }

这个配置表示只同步2026-06-01当天的数据。

理解配置和注意事项

时间范围同步的核心是query中的时间条件：

AND create_time < '2026-06-02 00:00:00'

这里建议使用“左闭右开”的时间范围：

这样可以避免跨天同步时出现重复或遗漏。

如果是每天定时同步，也可以把时间写成变量，例如：

AND create_time < '${end_date}'

需要注意的是，时间字段最好建立索引，否则源表数据量较大时，查询速度可能会比较慢。

适用场景

• 每天同步昨天新增或变更的数据

• 每周同步最近一周的数据

• 源表数据量较大，不适合每次全量同步

• 需要按照创建时间、更新时间、业务时间进行范围过滤
  示例：

目标表：test_1w 同步范围：2026-06-01 当天数据 同步方式：按时间范围过滤 + 追加写入

9. 单表性能优化：batch_size 和 parallelism 怎么设置

当单表数据量比较小时，默认配置通常就可以满足需求。

但如果同步的数据量达到 10 万、100 万甚至更多，就需要关注两个比较常用的性能参数：batch_size和parallelism。

简单来说：

parallelism：控制任务并行度

配置 batch_size 和 parallelism

} source { Jdbc { database = test1 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test1" username = root password = "123456" "table_path" = "public.t_test_10w" } } transform { } sink { Jdbc { database = test2 driver = "org.postgresql.Driver" url = "jdbc:postgresql://127.0.0.1:5432/test2" username = root password = "123456" table = "public.test_10w" "data_save_mode" = "APPEND_DATA" "batch_size" = 5000 "generate_sink_sql" = true "enable_upsert" = false } }

这个配置中：

• parallelism = 4表示任务并行度为 4

• batch_size = 5000表示每批写入 5000 条数据

理解配置和注意事项

batch_size不是越大越好。

设置太小，写入次数会变多，整体效率可能较低。

设置太大，单次写入压力会变大，可能导致目标库连接超时、锁等待或内存压力增加。

一般可以先从下面的值开始测试：

中等数据量：3000 ~ 5000 大表：5000 ~ 10000

parallelism也需要根据数据库能力来调整。

如果数据库配置较低，并行度过高，反而可能把数据库压垮。

建议先从1或2开始，再逐步调整到4、8，观察同步耗时和数据库负载。

适用场景

• 单表数据量较大，希望缩短同步时间

• 目标端 MySQL 写入能力较好，可以适当提高批量写入大小

• 需要通过测试找到更合适的同步参数
  示例：

10 万数据：batch_size = 3000 ~ 5000，parallelism = 2 ~ 4 100 万数据：batch_size = 5000 ~ 10000，parallelism = 4 ~ 8

这些值不是固定标准，最终还是要结合数据库性能、网络情况和任务执行结果来调整。

10. 单表数据校验：同步完成后如何确认数据正确

同步任务执行成功，并不代表数据一定完全符合预期。

在实际项目中，任务运行完成后，通常还需要做一些简单的数据校验，比如数据量是否一致、关键字段是否为空、部分样例数据是否正确。

对于单表同步来说，最常见的校验方式就是先从数量开始。

编写数据校验 SQL

1. 校验源表数据量

2. 校验目标表数据量

如果是全量同步，源表和目标表数量通常应该一致。

3. 校验关键字段空值

如果id是关键字段，那么这里的结果应该为0。

4. 抽样检查部分数据

SELECT * FROM public.test_1w WHERE id IN (1, 100, 1000);

通过抽样对比，可以快速确认关键字段内容是否一致。

理解配置和注意事项

单表校验可以从三个层面进行：

• 数量校验：源表和目标表总数是否一致

• 字段校验：关键字段是否为空，字段内容是否符合预期

• 样例校验：抽取几条数据，对比源表和目标表内容
  如果使用的是条件同步，比如只同步某一天的数据，那么校验 SQL 也需要带上相同的过滤条件。

例如：

FROM public.t_test_1w WHERE create_time >= '2026-06-01 00:00:00' AND create_time < '2026-06-02 00:00:00';

目标表也要使用同样的时间范围进行校验。

适用场景

• 单表同步任务执行完成后，确认数据是否正确

• 测试环境验证同步配置是否可用

• 生产环境同步后做基础核对

• 排查目标表数据缺失、重复或字段异常问题
  示例：

目标表数量：10000 关键字段空值：0 抽样数据：源表和目标表一致 校验结论：本次同步结果符合预期

11. 单表失败排查：常见错误和解决办法

单表同步任务失败时，不一定是 SeaTunnel 本身的问题。

更多时候，问题出在数据库连接、驱动、表结构、字段类型、权限或数据内容上。

所以排查时可以先从几个常见方向入手。

常见错误类型

常见问题可以分为下面几类：

2. JDBC 驱动不存在 3. 目标表不存在 4. 字段名不匹配 5. 字段类型不兼容 6. 字段长度超长 7. 主键冲突 8. 数据库账号权限不足

这些问题在单表同步中都比较常见。

理解排查思路

1. 数据库连接失败

优先检查连接地址、端口、账号、密码是否正确。

username = root password = "123456"

如果地址、端口或账号密码错误，任务会在连接数据库时失败。

2. 驱动不存在

检查driver配置是否正确，以及运行环境中是否已经放入对应 JDBC 驱动。

3. 目标表不存在

如果没有开启自动建表，目标表需要提前创建。

CREATETABLEpublic.test_1w(idBIGINT,nameVARCHAR(128),emailVARCHAR(256),statusVARCHAR(32),create_timeTIMESTAMP);

4. 字段不匹配

如果源表字段和目标表字段不一致，可能会出现字段找不到、写入失败等问题。

这种情况可以检查源表和目标表结构：

FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 't_test_1w' ORDER BY ordinal_position; SELECT column_name, data_type, character_maximum_length FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'test_1w' ORDER BY ordinal_position;

5. 字段长度超长

如果目标表字段长度比源表短，可能会出现写入失败。

例如源表字段长度是varchar(255)，目标表字段长度是varchar(36)，当数据超过 36 个字符时，就可能失败。

6. 权限不足

如果账号没有查询、写入、建表或清空表的权限，也会导致任务失败。

特别是使用下面这些能力时，要注意账号权限：

• 读取源表：需要 SELECT 权限

• 写入目标表：需要 INSERT 权限

• 自动建表：需要 CREATE 权限

• 覆盖同步：可能需要 DELETE 或 TRUNCATE 权限

适用场景

单表失败排查适合下面这些情况：

• 任务启动后直接失败

• 数据库连接测试不通过

• 目标表没有写入数据

• 写入过程中报字段类型或长度错误

• 开启 upsert 后出现主键相关错误
  可以按照下面顺序排查：

先看连接是否正常 再看驱动是否存在 再看表是否存在 再看字段是否匹配 再看数据是否超长 最后看账号权限是否足够

大多数单表同步问题，都可以通过这个顺序快速定位。

写在最后

SeaTunnel Web 是我正在持续完善的一个 SeaTunnel 可视化项目，希望把数据源管理、Zeta Engine 连接、任务配置、运行日志和指标查看这些常用能力，做得更直观、更容易上手。

项目地址：

https://github.com/weifuwan/seatunnel-web

里面有体验地址、部署文档、社区交流群

如果你也在学习 SeaTunnel，或者正在做数据同步、数据集成相关的事情，也欢迎一起交流。

这里有一群上进的小伙伴，也有一群爱分享的大佬。大家可以一起讨论问题、分享实践、完善文档，也一起把 SeaTunnel 这件事讲得更清楚、做得更好用。