Engines

64 engines, any two of them as a pair, and what each can do.

Every engine this version has, and what it can do - read off the code, so this page claims no more and no less than it does. A hop names its two sides by their addresses; migkit's own decision engine finds the fastest, exact, consistent way for each source -> target pair, and says which it chose and why.

The engines

EngineNameAlso writtenAddress schemesRole
PostgreSQLpostgresalloydb, aurora-postgres, pgsql, postgresqlpostgres://, aurora-postgres://, alloydb://, postgresql://, pgsql://either side
MySQLmysqlaurora-mysql, mariadb, percona, tdsql, tdsql-cmysql://, mariadb://, percona://, aurora-mysql://, tdsql://, tdsql-c://either side
MongoDBmongodbcosmosdb-mongo, documentdbmongodb://, documentdb://, cosmosdb-mongo://, mongodb+srv://either side
SQL Servermssqlazure-sql, sqlservermssql://, azure-sql://, sqlserver://either side
Redisredisvalkeyredis://, valkey://, rediss://either side
Kafkakafka-kafka://either side
SQLitesqlite-sqlite://either side
Parquet filesparquet-parquet://, parquet+s3://either side
ClickHouseclickhouse-clickhouse://either side
DynamoDBdynamodb-dynamodb://either side
Oracle Databaseoracle-oracle://either side
Db2 (Linux, UNIX, Windows)db2-db2://either side
Db2 for idb2ias400, db2-for-i, ibmi, iseriesdb2i://, ibmi://, as400://, iseries://, db2-for-i://either side
Db2 for z/OSdb2zosdb2-zos, db2zdb2zos://, db2-zos://, db2z://either side
SAP ASEasesap-ase, sybasease://, sybase://, sap-ase://either side
Teradatateradatatd, vantageteradata://, td://, vantage://either side
OpenSearchopensearchelasticsearchopensearch://, elasticsearch://either side
Cassandracassandrascylla, scylladbcassandra://, scylladb://, scylla://either side
Amazon Redshiftredshift-redshift://either side
Snowflakesnowflake-snowflake://either side
BigQuerybigquery-bigquery://either side
Kinesis Data Streamskinesis-kinesis://a stream a pair delivers its changes into
Google Pub/Subpubsub-pubsub://a stream a pair delivers its changes into
DuckDBduckdb-duckdb://either side
Files described by COBOL copybookscopybookcobol, vsamcopybook://, vsam://, cobol://either side
Iceberg tablesiceberg-iceberg://, iceberg+http://, iceberg+https://either side
Delta tablesdeltadelta-lakedelta://, delta-lake://, delta+s3://either side
TiDBtidb-tidb://either side
CockroachDBcockroachdbcockroach, crdbcockroachdb://, cockroach://, crdb://either side
Aurora DSQLdsqlaurora-dsqldsql://, aurora-dsql://either side
Couchbasecouchbase-couchbase://, couchbases://either side
Cosmos DB for NoSQLcosmosdbazure-cosmos, cosmos, cosmosdb-nosqlcosmosdb://, cosmos://, cosmosdb-nosql://, azure-cosmos://either side
Google Cloud Spannerspannercloud-spanner, spanner-pgspanner://, cloud-spanner://, spanner-pg://either side
Google Cloud Bigtablebigtablecloud-bigtablebigtable://, cloud-bigtable://either side
Firestore (native mode)firestorefirestore-nativefirestore://, firestore-native://either side
Firestore in Datastore modedatastorecloud-datastore, firestore-datastoredatastore://, firestore-datastore://, cloud-datastore://either side
GaussDB (openGauss)gaussdbgaussdb-opengauss, opengaussgaussdb://, opengauss://, gaussdb-opengauss://either side
OceanBase (MySQL mode)oceanbaseoceanbase-mysqloceanbase://, oceanbase-mysql://either side
OceanBase (Oracle mode)oceanbase-oracle-oceanbase-oracle://either side
PolarDB-Xpolardbxdrds, polardb-xpolardbx://, polardb-x://, drds://either side
TDSQL (distributed)dcdbtdsql-distributed, tdsql-sharddcdb://, tdsql-distributed://, tdsql-shard://either side
Amazon Keyspaceskeyspacesamazon-keyspaces, aws-keyspaceskeyspaces://, amazon-keyspaces://, aws-keyspaces://either side
Amazon Neptuneneptuneamazon-neptuneneptune://, amazon-neptune://either side
Amazon Timestreamtimestreamamazon-timestreamtimestream://, amazon-timestream://either side
Lindormlindorm-lindorm://either side
GeminiDB (Cassandra API)geminidb-cassandrageminidbgeminidb-cassandra://, geminidb://either side
GeminiDB (Redis API)geminidb-redis-geminidb-redis://either side
GeminiDB (MongoDB API)geminidb-mongo-geminidb-mongo://either side
Qdrantqdrant-qdrant://either side
Neo4jneo4jneo4j-auraneo4j://, neo4j-aura://either side
AnalyticDB for MySQLanalyticdb-mysqladb-mysqlanalyticdb-mysql://, adb-mysql://either side
AnalyticDB for PostgreSQLanalyticdb-postgresadb-pg, analyticdb-pganalyticdb-postgres://, adb-pg://, analyticdb-pg://either side
Azure Synapse (dedicated SQL pool)synapseazure-synapsesynapse://, azure-synapse://either side
YugabyteDByugabytedbysql, yugabyteyugabytedb://, yugabyte://, ysql://either side
SingleStoresinglestorememsqlsinglestore://, memsql://either side
Netezzanetezzapure-data-netezzanetezza://, pure-data-netezza://either side
SAP HANAsaphanahana, sap-hanasaphana://, hana://, sap-hana://either side
Informixinformix-informix://either side
Progress OpenEdgeprogressopenedge, progress-openedgeprogress://, openedge://, progress-openedge://either side
Verticavertica-vertica://either side
Exasolexasol-exasol://either side
Databricks SQLdatabricksdatabricks-sqldatabricks://, databricks-sql://either side
SAP application data (ODP)sapodpodp, sap-odpsapodp://, sap-odp://, odp://, sapodp+http://a source, read and never written
SaaS applications, read by a connector programsaasprogram-a source, read and never written
Any pair of two engineshetero--the pair: a source of one engine, a target of another
Any other SQL enginegeneric-trino://, presto://either side, compared by the tables the hop lists

What each can do

yes: the code does it for this engine. n/a: it does not apply, and the reason is said. not yet: not done yet, and what to do meanwhile is said. Hover a cell for its reason.

Engineschemacountsdatadeepsequencesparamsbulk-movetable-copystreamfenceconfirmdeltausersguardstatisticssnapshot
PostgreSQLyesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
MySQLyesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
MongoDByesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
SQL Serveryesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
Redisyesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
Kafkayesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
SQLiteyesyesyesyesyesyesyesyesn/an/an/an/an/ayesyesyes
Parquet filesyesyesyesyesn/an/ayesyesn/an/an/an/an/ayesn/ayes
ClickHouseyesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
DynamoDByesyesyesyesn/ayesyesyesyesyesyesyesn/ayesn/ayes
Oracle Databaseyesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
Db2 (Linux, UNIX, Windows)yesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
Db2 for iyesyesyesyesyesyesyesyesyesyesyesyesyesyesn/ayes
Db2 for z/OSyesyesyesyesyesyesyesyesn/an/an/an/ayesyesyesyes
SAP ASEyesyesyesyesyesyesyesyesnot yetyesyesyesyesyesyesyes
Teradatayesyesyesyesn/an/an/ayesn/an/an/an/ayesyesyesn/a
OpenSearchyesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
Cassandrayesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
Amazon Redshiftyesyesyesyesyesyesn/ayesn/an/an/an/ayesyesn/an/a
Snowflakeyesyesyesyesyesyesn/ayesyesyesyesyesyesyesn/ayes
BigQueryyesyesyesyesn/an/ayesyesyesyesyesyesyesyesn/ayes
Kinesis Data Streamsn/an/an/an/an/an/an/an/an/an/an/an/an/an/an/an/a
Google Pub/Subn/an/an/an/an/an/an/an/an/an/an/an/an/an/an/an/a
DuckDByesyesyesyesyesn/ayesyesn/an/an/an/an/ayesn/ayes
Files described by COBOL copybooksyesyesyesyesn/an/ayesyesn/an/an/an/an/ayesn/ayes
Iceberg tablesyesyesyesnot yetn/an/anot yetyesnot yetnot yetnot yetnot yetn/ayesn/anot yet
Delta tablesyesyesyesnot yetn/an/anot yetyesnot yetnot yetnot yetnot yetn/ayesn/anot yet
TiDByesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
CockroachDByesyesyesyesyesyesyesyesyesyesyesyesyesyesn/ayes
Aurora DSQLyesyesyesyesyesn/an/ayesyesyesyesyesn/ayesyesyes
Couchbaseyesyesyesyesn/ayesyesyesyesyesyesyesyesyesyesyes
Cosmos DB for NoSQLyesyesyesyesn/ayesyesyesyesyesyesyesn/ayesn/ayes
Google Cloud Spanneryesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
Google Cloud Bigtableyesyesyesyesn/ayesyesyesyesyesyesyesn/ayesn/ayes
Firestore (native mode)yesyesyesyesn/ayesyesyesyesyesyesyesn/ayesn/ayes
Firestore in Datastore modeyesyesyesyesn/ayesyesyesn/an/an/an/an/ayesn/ayes
GaussDB (openGauss)yesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
OceanBase (MySQL mode)yesyesyesyesyesyesnot yetyesyesyesyesyesyesyesyesyes
OceanBase (Oracle mode)yesyesyesyesyesyesnot yetyesnot yetnot yetnot yetnot yetyesyesyesyes
PolarDB-Xyesyesyesyesyesyesnot yetyesyesyesyesyesyesyesyesyes
TDSQL (distributed)yesyesyesyesyesyesnot yetyesyesyesyesyesyesyesyesyes
Amazon Keyspacesyesyesyesyesn/ayesyesyesyesyesyesyesn/ayesn/ayes
Amazon Neptuneyesyesyesyesn/ayesyesyesyesyesyesyesn/ayesyesyes
Amazon Timestreamyesyesyesn/an/ayesyesyesn/an/an/an/an/ayesn/ayes
Lindormyesyesyesyesn/ayesn/ayesnot yetnot yetnot yetnot yetyesyesn/ayes
GeminiDB (Cassandra API)yesyesyesyesn/ayesyesyesn/an/an/an/ayesyesn/ayes
GeminiDB (Redis API)yesyesyesyesn/ayesn/ayesyesn/an/ayesyesyesn/ayes
GeminiDB (MongoDB API)yesyesyesyesn/ayesyesyesyesyesyesyesyesyesn/ayes
Qdrantyesyesyesyesn/ayesnot yetyesn/an/an/an/an/ayesn/anot yet
Neo4jyesyesyesyesn/ayesnot yetyesyesyesnot yetyesyesyesyesnot yet
AnalyticDB for MySQLyesyesyesyesyesyesn/ayesyesyesyesyesyesyesyesyes
AnalyticDB for PostgreSQLyesyesyesyesyesnot yetn/ayesyesyesyesyesyesyesnot yetnot yet
Azure Synapse (dedicated SQL pool)yesyesyesyesn/ayesn/ayesn/an/an/an/ayesyesyesyes
YugabyteDByesyesyesyesyesnot yetn/ayesyesyesyesyesyesyesnot yetnot yet
SingleStoreyesyesyesyesyesyesn/ayesyesyesyesyesyesyesyesyes
Netezzayesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
SAP HANAyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
Informixyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
Progress OpenEdgeyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
Verticayesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
Exasolyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
Databricks SQLyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a
SAP application data (ODP)yesyesyesn/an/an/an/an/an/an/an/an/an/an/an/an/a
SaaS applications, read by a connector programyesyesyesn/an/an/an/an/an/an/an/an/an/an/an/an/a
Any pair of two enginesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyesyes
Any other SQL engineyesyesyesyesn/an/an/ayesyesyesyesyesn/ayesn/an/a

Each shape of table

A table without a key, a key of many columns, a table too large for one range: each shape has a way of its own on each engine, chosen by the decision engine.

Enginekeylessno unique indexwide keytoo largelarge valuespartitionedread-only sourcemissing grantread-only targetslow linkwrites heldspread target
PostgreSQLyesyesyesyesyesyesyesyesyesyesyesyes
MySQLyesyesyesyesyesyesyesyesyesyesyesyes
MongoDBn/an/ayesyesyesn/ayesnot yetyesyesyesyes
SQL Serveryesyesyesyesyesyesyesn/ayesyesyesn/a
Redisn/an/an/ayesyesn/ayesn/ayesyesyesn/a
Kafkan/an/an/ayesyesyesyesn/ayesyesyesn/a
SQLiteyesyesyesyesyesn/ayesn/an/an/an/an/a
Parquet filesyesyesn/ayesyesyesyesn/an/an/an/an/a
ClickHouseyesyesyesyesyesyesyesn/ayesyesyesn/a
DynamoDByesyesn/ayesn/an/ayesn/ayesyesn/an/a
Oracle Databaseyesyesyesyesyesyesyesyesyesyesyesn/a
Db2 (Linux, UNIX, Windows)yesyesyesyesyesyesyesn/ayesyesyesn/a
Db2 for iyesyesyesyesyesyesyesn/ayesyesn/an/a
Db2 for z/OSyesyesyesyesyesyesyesn/ayesyesn/an/a
SAP ASEyesyesyesyesyesnot yetyesn/ayesyesyesn/a
Teradatayesyesn/ayesyesyesyesyesyesyesyesn/a
OpenSearchyesyesn/ayesyesn/ayesn/ayesyesyesn/a
Cassandrayesyesn/ayesn/an/ayesn/ayesyesyesyes
Amazon Redshiftyesyesyesyesn/an/ayesn/ayesyesyesn/a
Snowflakeyesyesyesyesyesn/ayesn/ayesyesyesn/a
BigQueryyesyesyesyesyesyesyesn/ayesyesn/an/a
Kinesis Data Streamsn/an/an/an/an/an/an/an/an/an/an/an/a
Google Pub/Subn/an/an/an/an/an/an/an/an/an/an/an/a
DuckDByesyesyesyesyesn/ayesn/an/an/an/an/a
Files described by COBOL copybooksyesyesn/ayesn/an/ayesn/an/an/an/an/a
Iceberg tablesyesyesn/ayesyesnot yetyesn/an/ayesn/an/a
Delta tablesyesyesn/ayesyesnot yetyesn/an/ayesn/an/a
TiDByesyesyesyesyesyesyesn/ayesyesyesn/a
CockroachDByesyesyesyesyesn/ayesn/ayesyesyesn/a
Aurora DSQLyesyesyesyesyesn/ayesn/ayesyesn/an/a
Couchbasen/an/an/ayesyesn/ayesn/ayesyesyesn/a
Cosmos DB for NoSQLn/an/an/ayesn/an/ayesn/an/ayesn/an/a
Google Cloud Spannern/an/ayesyesn/an/ayesn/an/ayesn/an/a
Google Cloud Bigtablen/an/an/ayesnot yetn/ayesn/an/ayesn/an/a
Firestore (native mode)n/an/an/ayesn/an/ayesn/an/ayesn/an/a
Firestore in Datastore moden/an/an/ayesn/an/ayesn/an/ayesn/an/a
GaussDB (openGauss)yesyesyesyesyesyesyesn/ayesyesyesn/a
OceanBase (MySQL mode)yesyesyesyesyesyesyesn/ayesyesyesn/a
OceanBase (Oracle mode)yesyesyesyesyesyesyesn/ayesyesyesn/a
PolarDB-Xyesyesyesyesyesyesyesn/ayesyesyesn/a
TDSQL (distributed)yesyesyesyesyesyesyesn/ayesyesyesn/a
Amazon Keyspacesyesyesn/ayesn/an/ayesn/an/ayesn/an/a
Amazon Neptunen/an/an/ayesnot yetn/ayesn/an/ayesn/an/a
Amazon Timestreamn/an/an/ayesnot yetn/ayesn/an/ayesn/an/a
Lindormn/an/ayesyesnot yetnot yetyesn/ayesyesn/an/a
GeminiDB (Cassandra API)yesyesn/ayesn/an/ayesn/ayesyesyesn/a
GeminiDB (Redis API)n/an/an/ayesyesn/ayesn/ayesyesyesn/a
GeminiDB (MongoDB API)n/an/ayesyesyesn/ayesn/ayesyesyesn/a
Qdrantn/an/an/ayesnot yetnot yetyesn/an/ayesn/an/a
Neo4jn/an/an/ayesnot yetnot yetyesn/an/ayesn/an/a
AnalyticDB for MySQLyesyesyesyesyesyesyesn/ayesyesyesn/a
AnalyticDB for PostgreSQLyesyesyesyesyesyesyesn/ayesyesyesn/a
Azure Synapse (dedicated SQL pool)yesyesyesyesyesyesyesn/ayesyesyesn/a
YugabyteDByesyesyesyesyesyesyesn/ayesyesyesn/a
SingleStoreyesyesyesyesyesyesyesn/ayesyesyesn/a
Netezzanot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
SAP HANAnot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
Informixnot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
Progress OpenEdgenot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
Verticanot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
Exasolnot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
Databricks SQLnot yetnot yetnot yetyesnot yetnot yetyesn/ayesyesyesn/a
SAP application data (ODP)yesyesn/ayesn/an/ayesn/an/ayesn/an/a
SaaS applications, read by a connector programyesyesn/ayesn/an/ayesn/an/ayesn/an/a
Any pair of two enginesyesyesyesyesyesnot yetyesnot yetyesyesyesyes
Any other SQL engineyesyesyesyesyesyesyesn/an/ayesn/an/a

Stored code carried and proved

Views, functions, procedures and triggers are converted one at a time by whichever way proves itself on each, and each version, whoever wrote it, is run on both sides in a sandbox and compared. Between any two of PostgreSQL, MySQL, SQL Server, SQLite, ClickHouse, Oracle Database, Teradata, BigQuery, TiDB, CockroachDB, Aurora DSQL, GaussDB (openGauss), OceanBase (MySQL mode), OceanBase (Oracle mode), PolarDB-X, TDSQL (distributed), AnalyticDB for MySQL, AnalyticDB for PostgreSQL, YugabyteDB, SingleStore, a routine is carried by:

and these pairs further, by migkit's own converters:

SourceTargetWhat is converted
PostgreSQLMySQLview, function, procedure, trigger
PostgreSQLTiDBview, function, procedure, trigger
PostgreSQLOceanBase (MySQL mode)view, function, procedure, trigger
PostgreSQLPolarDB-Xview, function, procedure, trigger
PostgreSQLTDSQL (distributed)view, function, procedure, trigger
PostgreSQLAnalyticDB for MySQLview, function, procedure, trigger
PostgreSQLSingleStoreview, function, procedure, trigger
MySQLPostgreSQLview, function, procedure, trigger, event
MySQLCockroachDBview, function, procedure, trigger, event
MySQLAurora DSQLview, function, procedure, trigger, event
MySQLGaussDB (openGauss)view, function, procedure, trigger, event
MySQLAnalyticDB for PostgreSQLview, function, procedure, trigger, event
MySQLYugabyteDBview, function, procedure, trigger, event
SQL ServerPostgreSQLview, function, procedure, trigger, event
SQL ServerMySQLview, function, procedure, trigger
SQL ServerTiDBview, function, procedure, trigger
SQL ServerCockroachDBview, function, procedure, trigger, event
SQL ServerAurora DSQLview, function, procedure, trigger, event
SQL ServerGaussDB (openGauss)view, function, procedure, trigger, event
SQL ServerOceanBase (MySQL mode)view, function, procedure, trigger
SQL ServerPolarDB-Xview, function, procedure, trigger
SQL ServerTDSQL (distributed)view, function, procedure, trigger
SQL ServerAnalyticDB for MySQLview, function, procedure, trigger
SQL ServerAnalyticDB for PostgreSQLview, function, procedure, trigger, event
SQL ServerYugabyteDBview, function, procedure, trigger, event
SQL ServerSingleStoreview, function, procedure, trigger
Oracle DatabasePostgreSQLview, function, procedure, trigger
Oracle DatabaseMySQLview, function, procedure, trigger
Oracle DatabaseTiDBview, function, procedure, trigger
Oracle DatabaseCockroachDBview, function, procedure, trigger
Oracle DatabaseAurora DSQLview, function, procedure, trigger
Oracle DatabaseGaussDB (openGauss)view, function, procedure, trigger
Oracle DatabaseOceanBase (MySQL mode)view, function, procedure, trigger
Oracle DatabasePolarDB-Xview, function, procedure, trigger
Oracle DatabaseTDSQL (distributed)view, function, procedure, trigger
Oracle DatabaseAnalyticDB for MySQLview, function, procedure, trigger
Oracle DatabaseAnalyticDB for PostgreSQLview, function, procedure, trigger
Oracle DatabaseYugabyteDBview, function, procedure, trigger
Oracle DatabaseSingleStoreview, function, procedure, trigger
TiDBPostgreSQLview, function, procedure, trigger, event
TiDBCockroachDBview, function, procedure, trigger, event
TiDBAurora DSQLview, function, procedure, trigger, event
TiDBGaussDB (openGauss)view, function, procedure, trigger, event
TiDBAnalyticDB for PostgreSQLview, function, procedure, trigger, event
TiDBYugabyteDBview, function, procedure, trigger, event
CockroachDBMySQLview, function, procedure, trigger
CockroachDBTiDBview, function, procedure, trigger
CockroachDBOceanBase (MySQL mode)view, function, procedure, trigger
CockroachDBPolarDB-Xview, function, procedure, trigger
CockroachDBTDSQL (distributed)view, function, procedure, trigger
CockroachDBAnalyticDB for MySQLview, function, procedure, trigger
CockroachDBSingleStoreview, function, procedure, trigger
Aurora DSQLMySQLview, function, procedure, trigger
Aurora DSQLTiDBview, function, procedure, trigger
Aurora DSQLOceanBase (MySQL mode)view, function, procedure, trigger
Aurora DSQLPolarDB-Xview, function, procedure, trigger
Aurora DSQLTDSQL (distributed)view, function, procedure, trigger
Aurora DSQLAnalyticDB for MySQLview, function, procedure, trigger
Aurora DSQLSingleStoreview, function, procedure, trigger
GaussDB (openGauss)MySQLview, function, procedure, trigger
GaussDB (openGauss)TiDBview, function, procedure, trigger
GaussDB (openGauss)OceanBase (MySQL mode)view, function, procedure, trigger
GaussDB (openGauss)PolarDB-Xview, function, procedure, trigger
GaussDB (openGauss)TDSQL (distributed)view, function, procedure, trigger
GaussDB (openGauss)AnalyticDB for MySQLview, function, procedure, trigger
GaussDB (openGauss)SingleStoreview, function, procedure, trigger
OceanBase (MySQL mode)PostgreSQLview, function, procedure, trigger, event
OceanBase (MySQL mode)CockroachDBview, function, procedure, trigger, event
OceanBase (MySQL mode)Aurora DSQLview, function, procedure, trigger, event
OceanBase (MySQL mode)GaussDB (openGauss)view, function, procedure, trigger, event
OceanBase (MySQL mode)AnalyticDB for PostgreSQLview, function, procedure, trigger, event
OceanBase (MySQL mode)YugabyteDBview, function, procedure, trigger, event
OceanBase (Oracle mode)PostgreSQLview, function, procedure, trigger
OceanBase (Oracle mode)MySQLview, function, procedure, trigger
OceanBase (Oracle mode)TiDBview, function, procedure, trigger
OceanBase (Oracle mode)CockroachDBview, function, procedure, trigger
OceanBase (Oracle mode)Aurora DSQLview, function, procedure, trigger
OceanBase (Oracle mode)GaussDB (openGauss)view, function, procedure, trigger
OceanBase (Oracle mode)OceanBase (MySQL mode)view, function, procedure, trigger
OceanBase (Oracle mode)PolarDB-Xview, function, procedure, trigger
OceanBase (Oracle mode)TDSQL (distributed)view, function, procedure, trigger
OceanBase (Oracle mode)AnalyticDB for MySQLview, function, procedure, trigger
OceanBase (Oracle mode)AnalyticDB for PostgreSQLview, function, procedure, trigger
OceanBase (Oracle mode)YugabyteDBview, function, procedure, trigger
OceanBase (Oracle mode)SingleStoreview, function, procedure, trigger
PolarDB-XPostgreSQLview, function, procedure, trigger, event
PolarDB-XCockroachDBview, function, procedure, trigger, event
PolarDB-XAurora DSQLview, function, procedure, trigger, event
PolarDB-XGaussDB (openGauss)view, function, procedure, trigger, event
PolarDB-XAnalyticDB for PostgreSQLview, function, procedure, trigger, event
PolarDB-XYugabyteDBview, function, procedure, trigger, event
TDSQL (distributed)PostgreSQLview, function, procedure, trigger, event
TDSQL (distributed)CockroachDBview, function, procedure, trigger, event
TDSQL (distributed)Aurora DSQLview, function, procedure, trigger, event
TDSQL (distributed)GaussDB (openGauss)view, function, procedure, trigger, event
TDSQL (distributed)AnalyticDB for PostgreSQLview, function, procedure, trigger, event
TDSQL (distributed)YugabyteDBview, function, procedure, trigger, event
AnalyticDB for MySQLPostgreSQLview, function, procedure, trigger, event
AnalyticDB for MySQLCockroachDBview, function, procedure, trigger, event
AnalyticDB for MySQLAurora DSQLview, function, procedure, trigger, event
AnalyticDB for MySQLGaussDB (openGauss)view, function, procedure, trigger, event
AnalyticDB for MySQLAnalyticDB for PostgreSQLview, function, procedure, trigger, event
AnalyticDB for MySQLYugabyteDBview, function, procedure, trigger, event
AnalyticDB for PostgreSQLMySQLview, function, procedure, trigger
AnalyticDB for PostgreSQLTiDBview, function, procedure, trigger
AnalyticDB for PostgreSQLOceanBase (MySQL mode)view, function, procedure, trigger
AnalyticDB for PostgreSQLPolarDB-Xview, function, procedure, trigger
AnalyticDB for PostgreSQLTDSQL (distributed)view, function, procedure, trigger
AnalyticDB for PostgreSQLAnalyticDB for MySQLview, function, procedure, trigger
AnalyticDB for PostgreSQLSingleStoreview, function, procedure, trigger
YugabyteDBMySQLview, function, procedure, trigger
YugabyteDBTiDBview, function, procedure, trigger
YugabyteDBOceanBase (MySQL mode)view, function, procedure, trigger
YugabyteDBPolarDB-Xview, function, procedure, trigger
YugabyteDBTDSQL (distributed)view, function, procedure, trigger
YugabyteDBAnalyticDB for MySQLview, function, procedure, trigger
YugabyteDBSingleStoreview, function, procedure, trigger
SingleStorePostgreSQLview, function, procedure, trigger, event
SingleStoreCockroachDBview, function, procedure, trigger, event
SingleStoreAurora DSQLview, function, procedure, trigger, event
SingleStoreGaussDB (openGauss)view, function, procedure, trigger, event
SingleStoreAnalyticDB for PostgreSQLview, function, procedure, trigger, event
SingleStoreYugabyteDBview, function, procedure, trigger, event

Both ways at once

A pair of hops, each side's changes carried to the other and migkit's own writes told apart, runs on: PostgreSQL, MySQL, MongoDB, Cassandra, Redis, DynamoDB, Kafka.

Managed services

A managed service is the engine it runs, reached at its address; migkit recognises these, and says the provider's own way of changing a setting on each.

ProviderServiceEngine
AWSAmazon RDS for PostgreSQLPostgreSQL
AWSAmazon RDS for MySQLMySQL
AWSAmazon RDS for MariaDBMySQL
AWSAmazon RDS for SQL ServerSQL Server
AWSAmazon RDS for OracleOracle Database
AWSAmazon RDS for Db2Db2
AWSAmazon Aurora PostgreSQLPostgreSQL
AWSAmazon Aurora MySQLMySQL
AWSAmazon Aurora DSQLAurora DSQL
AWSAmazon DocumentDBMongoDB
AWSAmazon DynamoDBDynamoDB
AWSAmazon ElastiCache (Valkey, Redis OSS)Redis
AWSAmazon MemoryDBRedis
AWSAmazon Keyspaces (for Apache Cassandra)Keyspaces
AWSAmazon NeptuneNeptune
AWSAmazon Timestream for LiveAnalyticsTimestream
AWSAmazon Timestream for InfluxDB
AWSAmazon RedshiftRedshift
AWSAmazon OpenSearch ServiceOpenSearch
AWSAmazon MSKKafka
AWSAmazon Kinesis Data Streamsa Kinesis stream
AzureAzure SQL DatabaseSQL Server
AzureAzure SQL Managed InstanceSQL Server
AzureAzure Database for PostgreSQL flexible serverPostgreSQL
AzureAzure Database for MySQL flexible serverMySQL
AzureAzure Cosmos DB for NoSQLCosmos DB
AzureAzure Cosmos DB for MongoDB (RU)MongoDB
AzureAzure DocumentDB (formerly Azure Cosmos DB for MongoDB vCore)MongoDB
AzureAzure Cosmos DB for Apache CassandraCassandra
AzureAzure Cosmos DB for PostgreSQLPostgreSQL
AzureAzure Cache for RedisRedis
AzureAzure Managed RedisRedis
AzureAzure Synapse Analytics (dedicated SQL pool)Synapse dedicated SQL pool
AzureAzure Event Hubs (Kafka endpoint)Kafka
Google CloudCloud SQL for PostgreSQLPostgreSQL
Google CloudCloud SQL for MySQLMySQL
Google CloudCloud SQL for SQL ServerSQL Server
Google CloudAlloyDB for PostgreSQLPostgreSQL
Google CloudSpannerSpanner
Google CloudBigtableBigtable
Google CloudFirestoreFirestore
Google CloudFirestore in Datastore modeFirestore in Datastore mode
Google CloudMemorystore for RedisRedis
Google CloudMemorystore for Redis ClusterRedis
Google CloudMemorystore for ValkeyRedis
Google CloudBigQueryBigQuery
Google CloudPub/Suba Pub/Sub topic
Tencent CloudTencentDB for PostgreSQLPostgreSQL
Tencent CloudTencentDB for MySQLMySQL
Tencent CloudTencentDB for MariaDBMySQL
Tencent CloudTencentDB for SQL ServerSQL Server
Tencent CloudTencentDB for MongoDBMongoDB
Tencent CloudTencentDB for RedisRedis
Tencent CloudTDSQL-C for MySQLMySQL
Tencent CloudTDSQL-C for PostgreSQLPostgreSQL
Tencent CloudTDSQL (distributed)TDSQL (distributed)
Tencent CloudTencent Cloud CKafkaKafka
Tencent CloudTencent Cloud Elasticsearch ServiceOpenSearch
Alibaba CloudApsaraDB RDS for MySQLMySQL
Alibaba CloudApsaraDB RDS for PostgreSQLPostgreSQL
Alibaba CloudApsaraDB RDS for SQL ServerSQL Server
Alibaba CloudApsaraDB RDS for MariaDBMySQL
Alibaba CloudPolarDB for MySQLMySQL
Alibaba CloudPolarDB for PostgreSQLPostgreSQL
Alibaba CloudPolarDB-XPolarDB-X
Alibaba CloudAnalyticDB for MySQLAnalyticDB for MySQL
Alibaba CloudAnalyticDB for PostgreSQLAnalyticDB for PostgreSQL
Alibaba CloudTair (ApsaraDB for Redis)Redis
Alibaba CloudApsaraDB for MongoDBMongoDB
Alibaba CloudLindormLindorm
Alibaba CloudApsaraDB for OceanBase (MySQL mode)OceanBase (MySQL mode)
Alibaba CloudApsaraDB for OceanBase (Oracle mode)OceanBase (Oracle mode)
Alibaba CloudAlibaba Cloud ElasticsearchOpenSearch
Alibaba CloudApsaraMQ for KafkaKafka
Huawei CloudHuawei Cloud RDS for MySQLMySQL
Huawei CloudHuawei Cloud RDS for PostgreSQLPostgreSQL
Huawei CloudHuawei Cloud RDS for SQL ServerSQL Server
Huawei CloudHuawei Cloud GaussDBGaussDB
Huawei CloudHuawei Cloud TaurusDB (formerly GaussDB(for MySQL))MySQL
Huawei CloudHuawei Cloud Document Database Service (DDS)MongoDB
Huawei CloudHuawei Cloud Distributed Cache Service (DCS) for RedisRedis
Huawei CloudHuawei Cloud GeminiDB (DynamoDB, HBase and InfluxDB APIs)
Huawei CloudHuawei Cloud GeminiDB (Cassandra API)GeminiDB's Cassandra API
Huawei CloudHuawei Cloud GeminiDB (Redis API)GeminiDB's Redis API
Huawei CloudHuawei Cloud GeminiDB (MongoDB API)GeminiDB's MongoDB API
Huawei CloudHuawei Cloud Distributed Message Service (DMS) for KafkaKafka
Huawei CloudHuawei Cloud Search Service (CSS)OpenSearch
Oracle CloudOracle Autonomous DatabaseOracle Database
Oracle CloudOracle Base Database ServiceOracle Database
Oracle CloudMySQL HeatWaveMySQL
Oracle CloudOCI Database with PostgreSQLPostgreSQL
Oracle CloudOCI CacheRedis
Oracle CloudOCI Streaming (Kafka-compatible)Kafka
IBM CloudIBM Cloud Databases for PostgreSQLPostgreSQL
IBM CloudIBM Cloud Databases for MySQLMySQL
IBM CloudIBM Cloud Databases for MongoDBMongoDB
IBM CloudIBM Cloud Databases for RedisRedis
IBM CloudIBM Cloud Databases for ElasticsearchOpenSearch
IBM CloudIBM Event StreamsKafka
IBM CloudIBM Db2 on Cloud (Db2 SaaS)Db2
IBM CloudIBM Db2 Warehouse on CloudDb2
MongoDB AtlasMongoDB AtlasMongoDB
Redis CloudRedis CloudRedis
AivenAiven for PostgreSQLPostgreSQL
AivenAiven for MySQLMySQL
AivenAiven for Apache KafkaKafka
AivenAiven for OpenSearchOpenSearch
AivenAiven for ValkeyRedis
AivenAiven for ClickHouseClickHouse
AivenAiven for Apache CassandraCassandra
NeonNeonPostgreSQL
SupabaseSupabasePostgreSQL
PlanetScalePlanetScale (MySQL, on Vitess)MySQL
PlanetScalePlanetScale for PostgresPostgreSQL
Crunchy BridgeCrunchy BridgePostgreSQL
Tiger Cloud (Timescale)Tiger Cloud (Timescale)PostgreSQL
CockroachDB CloudCockroachDB CloudCockroachDB
YugabyteDB AeonYugabyteDB AeonYugabyteDB
SingleStore HeliosSingleStore HeliosSingleStore
Confluent CloudConfluent CloudKafka
Teradata VantageCloudTeradata VantageCloud LakeTeradata

Each engine

PostgreSQL

postgres, also written alloydb, aurora-postgres, pgsql, postgresql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

MySQL

mysql, also written aurora-mysql, mariadb, percona, tdsql, tdsql-c - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

MongoDB

mongodb, also written cosmosdb-mongo, documentdb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

SQL Server

mssql, also written azure-sql, sqlserver - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Redis

redis, also written valkey - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Kafka

kafka - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

SQLite

sqlite - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

Parquet files

parquet - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

ClickHouse

clickhouse - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

DynamoDB

dynamodb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Oracle Database

oracle - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Db2 (Linux, UNIX, Windows)

db2 - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Db2 for i

db2i, also written as400, db2-for-i, ibmi, iseries - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Db2 for z/OS

db2zos, also written db2-zos, db2z - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

SAP ASE

ase, also written sap-ase, sybase - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Not yet:

Teradata

teradata, also written td, vantage - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load.

Does not apply:

OpenSearch

opensearch, also written elasticsearch - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Cassandra

cassandra, also written scylla, scylladb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Amazon Redshift

redshift - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing.

Does not apply:

Snowflake

snowflake - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

BigQuery

bigquery - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Kinesis Data Streams

kinesis - a stream a pair delivers its changes into.

Does not apply:

Google Pub/Sub

pubsub - a stream a pair delivers its changes into.

Does not apply:

DuckDB

duckdb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Files described by COBOL copybooks

copybook, also written cobol, vsam - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Iceberg tables

iceberg - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; copying table by table, resumably; noticing a move that moved nothing.

Does not apply:

Not yet:

Delta tables

delta, also written delta-lake - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; copying table by table, resumably; noticing a move that moved nothing.

Does not apply:

Not yet:

TiDB

tidb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

CockroachDB

cockroachdb, also written cockroach, crdb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Aurora DSQL

dsql, also written aurora-dsql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

Couchbase

couchbase - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

Cosmos DB for NoSQL

cosmosdb, also written azure-cosmos, cosmos, cosmosdb-nosql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Google Cloud Spanner

spanner, also written cloud-spanner, spanner-pg - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Google Cloud Bigtable

bigtable, also written cloud-bigtable - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Firestore (native mode)

firestore, also written firestore-native - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Firestore in Datastore mode

datastore, also written cloud-datastore, firestore-datastore - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

GaussDB (openGauss)

gaussdb, also written gaussdb-opengauss, opengauss - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

OceanBase (MySQL mode)

oceanbase, also written oceanbase-mysql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Not yet:

OceanBase (Oracle mode)

oceanbase-oracle - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Not yet:

PolarDB-X

polardbx, also written drds, polardb-x - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Not yet:

TDSQL (distributed)

dcdb, also written tdsql-distributed, tdsql-shard - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Not yet:

Amazon Keyspaces

keyspaces, also written amazon-keyspaces, aws-keyspaces - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Amazon Neptune

neptune, also written amazon-neptune - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

Amazon Timestream

timestream, also written amazon-timestream - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; comparing server settings; moving a whole database in bulk; copying table by table, resumably; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Lindorm

lindorm - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Not yet:

GeminiDB (Cassandra API)

geminidb-cassandra, also written geminidb - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

GeminiDB (Redis API)

geminidb-redis - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; copying table by table, resumably; keeping the target following the source; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

GeminiDB (MongoDB API)

geminidb-mongo - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; snapshotting the target so a cutover can be rolled back.

Does not apply:

Qdrant

qdrant - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; copying table by table, resumably; noticing a move that moved nothing.

Does not apply:

Not yet:

Neo4j

neo4j, also written neo4j-aura - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load.

Does not apply:

Not yet:

AnalyticDB for MySQL

analyticdb-mysql, also written adb-mysql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

AnalyticDB for PostgreSQL

analyticdb-postgres, also written adb-pg, analyticdb-pg - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing.

Does not apply:

Not yet:

Azure Synapse (dedicated SQL pool)

synapse, also written azure-synapse - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; comparing server settings; copying table by table, resumably; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

YugabyteDB

yugabytedb, also written ysql, yugabyte - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing.

Does not apply:

Not yet:

SingleStore

singlestore, also written memsql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Does not apply:

Netezza

netezza, also written pure-data-netezza - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

SAP HANA

saphana, also written hana, sap-hana - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

Informix

informix - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

Progress OpenEdge

progress, also written openedge, progress-openedge - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

Vertica

vertica - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

Exasol

exasol - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

Databricks SQL

databricks, also written databricks-sql - either side.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply:

SAP application data (ODP)

sapodp, also written odp, sap-odp - a source, read and never written.

It does: comparing the schema; comparing row counts; comparing the data itself.

Does not apply:

SaaS applications, read by a connector program

saas, also written program - a source, read and never written.

It does: comparing the schema; comparing row counts; comparing the data itself.

Does not apply:

Any pair of two engines

hetero - the pair: a source of one engine, a target of another.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; carrying sequences and auto-increment values; comparing server settings; moving a whole database in bulk; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; carrying users and their grants; noticing a move that moved nothing; refreshing the target's statistics after a load; snapshotting the target so a cutover can be rolled back.

Any other SQL engine

generic - either side, compared by the tables the hop lists.

It does: comparing the schema; comparing row counts; comparing the data itself; the deep checks; copying table by table, resumably; keeping the target following the source; proving the target has caught up before cutover; telling a difference still arriving from one that is wrong; verifying only what changed; noticing a move that moved nothing.

Does not apply: