What's New in DBConvert Streams

Three times the CDC throughput from MySQL

Streams joins the pieces of a MySQL transaction before writing them.

• 64,000 rows/s MySQL → PostgreSQL · was 21,000
• 20,000 rows/s MySQL → Snowflake · was 3,300

For transactions that change many rows.

Lag that stays flat

PostgreSQL keeps up with MySQL well past the old limit.

• 0.2 s behind the source at 40,000 changes per second
• 1 ms for a single-row change

The full measurements

Restart and go on

Close the app with a CDC stream running, open it again, and start CDC right away — the pipeline is yours again.

Any table size, bounded memory

Parquet, CSV and JSONL targets write part files of about 200 MB while the table is read, so memory stays flat however large the table.

Snowflake uploads while it reads

Each part file goes to your stage as soon as it is cut.

• 8 min 56 s for 260 million rows, 49 GB, from MySQL
• 10 s of upload left after the read

The run shows COPY INTO, removes its staging files, and creates a missing database or schema.

Run progress you can read

Each table shows rows copied out of its total, and says Finalizing while the target finishes it after the last row — building indexes, or Snowflake’s COPY INTO.

Jump to the end of a big table

In Data Explorer, the last page of a large table opens at once, however many rows come before it.

• 0.04 s to open the last page of a 73-million-row table

A plan before anything is written

Starting a Load lists every selected table as created, replaced, used as it is, or blocked, with the reason. Replacing tables needs a second confirmation, missing privileges are found before the run instead of halfway through it, and the plan you start is the plan you reviewed. Review and Verify a Load.

Verify data

One button compares a finished Load with the source: totals for every table, then the rows themselves wherever the totals differ. Turn on Verify data after run to check every Load when it finishes. 20 million rows compare row by row in about 72 seconds on a workstation.

The differing rows, side by side

See them in Compare opens the source and target tables narrowed to the rows that differ and lined up by key: the expected value in blue, the value found in red, and a row missing from one side held in place so nothing below it shifts.

Totals that match can still hide changes

Row counts and sums can agree while values differ. Row comparison reads both tables by primary key and converts source values the way the Load wrote them, so a type mapping is not reported as a difference.

PRO for the IDE

Data Explorer, SQL and connections stay free, with federated queries over up to two sources and 5 AI questions a day over live databases — the app shows how many are left. PRO ($9 a month) adds more sources, diagram export and unlimited AI questions. Licensing.

Load pass and CDC pipelines

A Load pass ($149, 30 days) makes Load output clean. CDC is paid per pipeline — one CDC stream running at a time — and every account gets a 7-day CDC trial on up to 3 tables. Both include PRO. The app’s Account page shows the pass and the trial.

Relations from the catalog

The diagram draws the foreign keys the database reports, not relations guessed from column names, and lays the tables out so the controls never cover them.

Exports that open

SVG export is a real vector file, the PNG no longer comes out blank, and each export gets its own name instead of overwriting the last one.

PostgreSQL range columns

A table with a tsrange, daterange or other range column stopped a PostgreSQL migration with an encoding error. Range values now arrive intact, through both bulk load and upsert.

The right reason for a missing table

A table dropped after the stream was configured was reported as a privileges problem. It is now reported as missing.

No changes lost at the start of a stream

A new PostgreSQL CDC stream began a moment later than it should have, so rows committed during those first seconds never arrived — and nothing reported it. Every change is now delivered from the point the stream was created.

Schema options that hold

Switching off indexes or foreign keys was forgotten when the configuration was saved, so the run rebuilt them anyway and then failed on them. Off now stays off.

Schemas that used to fail at the finish line

Custom types and full-text or spatial indexes stopped a PostgreSQL migration right at the end, after every row had already been copied. Both are handled now, so the run completes.

Errors that name the table and the fix

A table that cannot be replicated stops the run before anything is created, and says which table and what to change — instead of a database error halfway through.

Migration and replication, in and out

Move a MySQL or PostgreSQL database into YugabyteDB, or replicate changes continuously in either direction. The YugabyteDB guide covers the cluster settings it needs and where YugabyteDB differs from PostgreSQL.

Tables and sizes in Data Explorer

A YugabyteDB connection showed no tables and no sizes while the same tables answered queries. Both appear now.

Open it beside the grid

Pictures are drawn, documents and text are shown, and anything a browser cannot read is a hex dump. The value can be copied as hex or saved to a file through the application's own dialog.

Types named, not guessed

An AVIF, an ICO, a TIFF, an Ogg stream or a PDF is recognised as itself rather than as an unknown blob of a certain size, and a BIT column reads as bits.

One bar for what you staged

Selected rows and unsaved edits share a bar at the bottom of the grid — Clear, Copy, Export selected, Delete on one side, Review, Discard and Save on the other — instead of crowding the toolbar that acts on the whole table.

Nothing leaves until you save

An edited cell, a staged insert and a staged delete are marked in place and counted on the Save button. The review panel lists them one card per row, naming fields in the table's own column order.

Current state and history

Each source table gets an append-only change table and an ordinary current-state table, kept up to date by a Snowflake task on a schedule you choose. The changes can be trimmed at any time without touching the table you query.

Key-pair authentication

Snowpipe Streaming signs a JWT with a Snowflake key pair. Streams can generate the pair and refuses a CDC run whose connection cannot authenticate.

Nothing to install

Hand it connection strings and it serves them: npx @dbconvert/stream-mcp "postgres://…". No workspace, no services to start.

One click in VS Code and Cursor

The install button now asks for your connection string as it installs, instead of leaving a sample one for you to find and replace in a JSON file.

A Claude extension, or a container

One .mcpb file covers Windows and Linux and carries a form for the sources. Anything that launches a container can use the image instead.

It cannot write

No tool updates a row, drops a table or alters a schema — absent, not disabled. Every tool declares readOnlyHint, so a client can check rather than trust.

All your sources in one setting

Databases, buckets and folders go in a single DBCONVERT_MCP_SOURCES value, separated by spaces — which is what a client can prompt for, and what docker run -e takes.

Findable where you look

The server is published in the MCP registry, on npm and on Docker Hub, so your client can install it the way it installs any other.

/mcp works out of the box

Two images a Docker deployment needs were private, so docker compose up could not pull them: /mcp was a dead route and federated queries failed. The nginx route table is generated on every start instead of shipped stale.

Federated queries in parallel

DBCONVERT_MCP_QUERY_CONCURRENCY sets how many run at once. Worth raising on a deployment serving several sessions, where one slow query otherwise holds up everything behind it.

Money keeps its value

A PostgreSQL money column arrived as 123456 instead of $1,234.56. It now lands as DECIMAL(19,2).

CDC keeps the clock

Replicated timestamps were shifted by the host machine's UTC offset: a row written at 11:00 arrived at 13:00.

Wide tables keep their rows

A batch too large for the transport was dropped in silence — the run reported Finished over an empty target. Batch size is no longer a setting: batches are sized by what they hold.

Types stay themselves

A zero primary key is no longer renumbered, a NULL binary column no longer becomes empty, DATETIME keeps its precision, and long text no longer lands in an unmeasured VARCHAR(255).

No more silent stalls

A large load could stop making progress and stay Running for ever — and that one run then refused every later start until the service was restarted.

A failure says what happened

A failed run carries the database's own error instead of nothing at all, and an unreachable host now fails in a second, naming the connection.

Stopping is not failing

A run you stop reports Stopped and keeps its progress. Row-level failures no longer decide the run's outcome.

CDC checks the target first

An initial snapshot names the target tables that are not empty before the run, instead of failing mid-way.

Exports match the source

CSV, JSONL and Parquet, local or on S3: a column named order no longer fails the export, unsigned integers no longer wrap, decimals stay decimals and UUIDs stay UUIDs. Loading any of it back returns the values and the types it left with.

Your query runs on your database

A query against a single source now runs on that source — its SQL dialect, its column types, the result the editor previewed.

One slow query, one slow query

Queries across several databases moved out of the API into a service of their own, so two people querying at once no longer collide and a crash can no longer take the API with it. Large results arrive in pieces.