Sumeta — the company behind Bridge
Question · bulk rollout

How do I create hundreds of pipelines without configuring each one?

A schema-per-tenant architecture turns a twenty-pipeline project into a four-hundred-pipeline one. The hard part is not the connector; it is the repetition — and repetition is where naming rules, table-creation policy and template drift decide whether the rollout takes a week or a quarter.

Bridge treats bulk creation as a product feature rather than a script you maintain. A batch job takes a set of source tables and produces the whole chain — target table, transformation, job — in one pass, with naming rules applied and an optional template carrying the intermediate logic.

3
Objects generated per source table: table, transformation, job
4
Naming rules: prefix, suffix, replacement, trim
2
Table-creation policies: keep existing, or drop and recreate
3
Start scopes: all jobs, succeeded only, failed only
One job, one chain

What one batch job actually produces

The unit of work is the batch, not the table. You select or search the source tables, and the platform creates the target table from the source column types, generates the column mapping and creates a job — then starts it. Doing that by hand costs minutes per table and leaves a permanent maintenance surface behind.

Batch pipeline generation in Bridge.
StageWhat the platform doesWhat it replaces
Target tableCreates the target table from the source column types, following the table-creation policyHand-written DDL, kept in sync with every source change
TransformationGenerates the source-to-target column mappingA mapping assembled table by table in the canvas
JobCreates a scheduled job and runs it on first executionCreating, scheduling and starting each job separately
CategoryOptionally files the generated transformations and jobs under a named categoryFiling them afterwards so the next engineer can find them

The generated resources are ordinary objects. They appear in transformation management and job management, and can be edited or scheduled like anything else — the batch is a factory, not a separate runtime.

Two operational details matter once the batch gets large. A generated resource cannot be deleted while it is in use or running: the delete fails, and succeeds on retry once the resource is idle. And deletion removes each resource individually, so removing a large batch takes proportionally longer than creating it. Plan retirement as its own step rather than treating it as instant.

Deterministic names

Naming rules decide whether the output is usable

Generated names are derived, which means every naming rule is applied hundreds of times without review. The four rules are prefix, suffix, string replacement and truncation, applied to target table names and column names.

Naming rules for generated pipelines.
RuleApplied toBehaviour worth knowing before a large run
Prefix / suffixTable and column namesAppends a fixed token — typically the tenant or environment identifier that makes generated names unique
String replacementTable and column namesSubstitutes a token in the source name, so a source-prefixed convention can be dropped from the target
TruncationTable and column namesShortens to the target length limit; if the string is already within the limit, nothing is changed
Forced caseTable and column names on selected targetsUpper, lower or custom creation, for targets whose identifier rules differ from the source engine's

Truncation is the rule that breaks rollouts quietly. If two source table names differ only after the truncation point, they collapse to the same target name — and the failure surfaces as a duplicate-object error somewhere in the middle of the batch, or worse, as two pipelines writing to one table. Before a large run, query the source catalog for the longest identifier in scope and set the trim length from that, not from the first sample table.

Forced case is available on Oracle, PostgreSQL, ADB, Greenplum, HUAWEI LibrA, DM, KingbaseES and KingbaseES7 targets, which is the set of engines where unquoted identifiers are folded by the server. A source-to-target pair that stays inside Oracle also exposes a cross-encoding option that converts byte-length fields to character-length fields — the difference matters when the two databases disagree on what a VARCHAR2(n) length means.

Reuse, not repetition

Templates are what separate a copy from a pipeline

A batch job on its own is input to output. Most real pipelines need something in the middle — a constant column, an ingestion timestamp, a masking rule, a filter. Without a template you would apply that logic by hand to every generated transformation, which puts the repetition straight back.

Turn a transformation into a template

Any transformation can be promoted to a template. It then appears as a selectable template in batch configuration, and the batch applies it to every pipeline it generates.

Constants and system information

Batch configuration can inject constant values and system information — the fields that usually identify the load rather than describe the business row.

Multi-table search

Source tables are searched by fuzzy name match, so selecting four hundred tables out of four thousand does not mean scrolling.

Bulk naming and filing

Generated transformations and jobs can be given custom names in bulk and saved into a specified category.

The practical consequence: one reviewed template covers the whole estate. Change the masking rule once, regenerate, and the change is consistent — instead of four hundred edits, each of which is a small chance to be wrong.

Coverage, not marketing

Destination coverage, stated per engine

Batch generation is not universal across the connector catalog. The table below is the batch-job coverage specifically — an engine can be a perfectly good CDC source and still not be a batch-job target. Coverage this specific is the difference between a plan and a surprise in week three.

Batch-job source and target coverage; CDC-only and file-source types are out of scope for batch generation.
EngineAs batch sourceAs batch targetConstraint that applies
OracleYesYesOracle to Oracle adds a cross-encoding option converting byte-length fields to character-length
MySQLYesYes—
PostgreSQLYesYesForced case available on the target
SQL ServerYesYes—
Db2YesYes—
ADBYesYesForced case available on the target
GreenplumYesYesForced case available on the target
HUAWEI LibrAYesYesForced case available on the target
KingbaseES / KingbaseES7YesYesForced case available on the target
DMYesNoSource only in batch jobs
HiveYesNoSource only in batch jobs
HUAWEI HiveYesNoSource only in batch jobs
MaxComputeNoYesTarget only; generated tables are unpartitioned
EMRNoYesTarget only; generated tables carry no lifecycle and default to permanent
GBase 8aNoYesTarget only, and accepts Oracle or MySQL sources only
GBase 8s / 8tNoYesTarget only

Two of those constraints deserve a planning decision rather than a footnote. Generated tables on MaxCompute and EMR are created without partitions, and on EMR without a lifecycle — so a batch that produces a hundred tables produces a hundred unpartitioned, permanent tables. If partitioning or expiry is part of your cost model, the batch creates the pipeline and you apply the table policy afterwards; decide that before the run, not when storage grows.

Retry semantics

Re-running a batch is not the same as re-creating it

Starting a batch is a separate decision from building it, with three scopes: start all jobs, start only the jobs that last succeeded, and start only the jobs that last failed. The first run of a newly created batch ignores the scope and runs everything, because nothing has a previous outcome yet.

That behaviour is what makes retry after a partial failure cheap: fix the failing subset, re-run with the failed-only scope, and the jobs that already loaded are left alone rather than reloaded.

Bulk creation, answered

Does a batch job create the target tables automatically?

Yes. Table, transformation and job are generated in one pass. Table creation follows the policy you set: keep the existing table if the target already has one, or drop and recreate it.

Can the generated pipelines carry intermediate logic?

Yes, through a template. Promote a transformation to a template, and the batch applies it to every pipeline it generates; constants and system information can be injected at the same time.

Why did deleting a batch fail?

A generated resource cannot be removed while it is in use or running. Stop the job, confirm nothing references the resource, then delete again. Large batches also take longer because each resource is removed individually.

Can a batch be moved to another environment?

Yes. Export the selected batch or all of them to a .dat archive and import it on the other instance. Resources with the same name are skipped on import, and references bind to the objects already there.

What happens to a source table whose name is very long?

The truncation rule shortens it to the target limit. Check that no two source names become identical after truncation before running the batch.

Generate a ten-table batch in the trial

Download the build, activate with a license key, and let the platform create the chain instead of the ticket queue.