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.
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.
| Stage | What the platform does | What it replaces |
|---|---|---|
| Target table | Creates the target table from the source column types, following the table-creation policy | Hand-written DDL, kept in sync with every source change |
| Transformation | Generates the source-to-target column mapping | A mapping assembled table by table in the canvas |
| Job | Creates a scheduled job and runs it on first execution | Creating, scheduling and starting each job separately |
| Category | Optionally files the generated transformations and jobs under a named category | Filing 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.
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.
| Rule | Applied to | Behaviour worth knowing before a large run |
|---|---|---|
| Prefix / suffix | Table and column names | Appends a fixed token — typically the tenant or environment identifier that makes generated names unique |
| String replacement | Table and column names | Substitutes a token in the source name, so a source-prefixed convention can be dropped from the target |
| Truncation | Table and column names | Shortens to the target length limit; if the string is already within the limit, nothing is changed |
| Forced case | Table and column names on selected targets | Upper, 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.
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.
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.
| Engine | As batch source | As batch target | Constraint that applies |
|---|---|---|---|
| Oracle | Yes | Yes | Oracle to Oracle adds a cross-encoding option converting byte-length fields to character-length |
| MySQL | Yes | Yes | — |
| PostgreSQL | Yes | Yes | Forced case available on the target |
| SQL Server | Yes | Yes | — |
| Db2 | Yes | Yes | — |
| ADB | Yes | Yes | Forced case available on the target |
| Greenplum | Yes | Yes | Forced case available on the target |
| HUAWEI LibrA | Yes | Yes | Forced case available on the target |
| KingbaseES / KingbaseES7 | Yes | Yes | Forced case available on the target |
| DM | Yes | No | Source only in batch jobs |
| Hive | Yes | No | Source only in batch jobs |
| HUAWEI Hive | Yes | No | Source only in batch jobs |
| MaxCompute | No | Yes | Target only; generated tables are unpartitioned |
| EMR | No | Yes | Target only; generated tables carry no lifecycle and default to permanent |
| GBase 8a | No | Yes | Target only, and accepts Oracle or MySQL sources only |
| GBase 8s / 8t | No | Yes | Target 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.
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.
