Qrulla Docs

Moving data

Copy and paste between servers

Qrulla's flagship feature. Copy tables, views, routines and data from one server to another, between different engines too, with progress and nothing left half done.

In two steps

  1. In the tree, pick one or more objects (tables, views, functions, sequences…) and press Ctrl+C. To take everything, right-click a schema or a folder → “Copy all”.
  2. Pick the target database or schema, on the same server or another one, and press Ctrl+V (or right-click → “Paste”).

“Paste objects” opens with the source, the target and what you're copying.

The options

  • Also copy the tables' data: unchecked, only the structure is copied.
  • If it exists: Qrulla checks which objects are already in the target. For each, or for all together, you choose:
    • Skip: leaves it as it is.
    • Append its rows: adds the copied rows to the existing table.
    • Replace: drops and recreates it. Its current data is lost, and Qrulla asks you to confirm that separately.
  • Verify the copy when done (Max plan): at the end, compares each table row by row with the source.
  • Hide sensitive data (Max plan): writes fake emails, names, phones, documents… See Sensitive data.

If the target is production, the dialog says so in large type.

What is copied and in what order

Objects are created in the order they're needed: types, sequences, tables, data, indexes and finally foreign keys. Each table is copied in its own transaction: if something fails, that table isn't left half done.

  • MongoDB: each document whole, with its types; then the indexes. If a collection fails midway, the documents that copy managed to write are removed.
  • Redis: each key whole, with its expiry. It's written aside and put in place at the end.

Between different engines

You can copy, for example, from MySQL to PostgreSQL or from SQL Server to Oracle. Between engines, tables are copied, with their data, primary key, indexes and foreign keys. Each column type becomes the closest one in the target, and before starting you see notes on what changes:

  • a type that may not hold every value (for example, a smaller decimal);
  • a type that doesn't exist in the target and is stored as text;
  • a date with a time zone that moves to UTC;
  • defaults, computed columns or special indexes that can't be translated;
  • in Oracle, empty text is stored as NULL.

Views, functions and procedures are written in their engine's dialect, so they aren't copied between different engines.

In the same place

If you paste in the same database and schema you copied from, Qrulla duplicates the tables: it creates a copy of each with its name plus the date and time. It brings columns, primary key, indexes, defaults and checks; not foreign keys, because their names can't repeat.

While it copies

A window shows the phase (reading the source, creating the structure, copying data, creating indexes…), the objects and rows copied and the speed in rows per second. You can:

  • Keep running in the background and work on something else; the copy goes on in the task bar.
  • Cancel: the table being copied is rolled back.

At the end you see each object's result (copied, skipped, failed) with the rows in source and target, and the full log, which you can copy.

Verify the copy

Max plan. With “Verify the copy” checked, Qrulla reads each table again on both sides and compares them row by row by primary key. At the end it says, per table, whether it's identical or how many rows are missing, different or extra. A table without a primary key is only counted.

Something missing or unclear? Write to support@qrulla.com.