Hop options
Every key of a hop and of its sides: its type, the engines that read it, and what it does.
Every key a hop may say, from the one registry the configuration is checked against before anything runs: an unknown key is refused with the closest known one, a wrong type or a contradiction with where it is.
A hop's keys
The keys of a hop itself, beside its two sides.
| Key | Written as | Read on | What it is |
|---|---|---|---|
goal | text | every engine | what the hop is for - copy, cutover, verify, two-way, keep-in-sync, rehearse, upgrade, subset, consolidate, split, reshard or archive |
engine | text | every engine | the engine both sides run, or hetero - read from the addresses when they are addresses |
source | text or a mapping | every engine | where the data is: an address or the long form |
target | text or a mapping | every engine | where it goes: an address or the long form |
databases | a list | every engine | the source databases to move, all of them when left out |
exclude | a list or a mapping | every engine | databases, schemas or tables left alone - dotted names and patterns, or databases each with all, its tables or its schemas |
objects | a mapping | every engine | the kinds of object beside the tables carried: views, routines, triggers, events, sequences, dictionaries, roles - each all (the default), none, or a list of names; one not carried is out of scope as an excluded table is |
include | a list or a mapping | every engine | the only databases, schemas or tables taken - moved, followed, checked and repaired - the rest left alone as if excluded; exclude wins where both name one. Written as exclude is |
service | text | every engine | the playbook migkit advise shows |
big_rows | a whole number | every engine | read by nothing |
slice | a whole number | every engine | the rows one compared range of a large table holds - a number migkit otherwise decides; leave it out unless its own choice failed you |
workers | a whole number | every engine | the most workers migkit's own sizing may reach - a ceiling: migkit works the number out itself and never goes past this |
options | a mapping | every engine | the hop's options |
db_map | a mapping | every engine | source database name -> target database name |
mapping | a mapping | every engine | renames, column rules, row filters, the changes carried per table (ops: insert, update, delete), and the percentage a table's aggregates may drift by when read a second way - keys under it: tables, columns, where, tolerance, ops, names |
A hop's options
The keys under a hop's options:.
| Key | Written as | Read on | What it is |
|---|---|---|---|
accept_changes | a list | a pair across two engines | table.column patterns whose values may arrive as the target keeps them |
access | a mapping | every engine | who sees and does what on this hop in the web view and the API - viewer, operator, approver, admin - added to the file's own access - keys under it: viewer, operator, approver, admin |
account_host | text | MySQL | the host part of a MySQL account made on the target for a user the source names without one (the default is any host, %) |
accounts | true or false | every engine | false: the move does not carry users, roles or grants - the target's are made apart from it - so their checks are skipped and said as not compared, and no repair grants them (as objects: {roles: false}) |
app_roles | a list | every engine | the application's roles protect_target holds |
application_sql | text or a list | a pair across two engines | where the application's code is on this machine: the SQL written in it is found, carried into the target's SQL and proved on the sandbox, and never changed |
approvals | a mapping | every engine | the steps that wait for an approval - keys under it: steps, signers, count, expires |
at_rest | a mapping | every engine | who may read the files holding values (recipients), and the directory on an encrypted or memory-backed volume where the files a program writes lie (scratch) - keys under it: recipients, scratch |
bastion | a mapping or text | every engine | bastion jump host configuration for SSH/SSM port forwarding |
tunnel | a mapping or text | every engine | alias for bastion configuration |
archive | a mapping | every engine | goal archive: remove - the archived rows removed from the source once proved (with the source's answer, source_changes: {archived_rows: yes}), restore - the removed rows put back from the archive, batch - rows a batch - keys under it: remove, restore, batch |
charset | text or a mapping | every engine | the character set, and the collation, the target's text is converted to - a name, or {to, collation, repair: double-encoded | none}; converted by MySQL's own conversion after the copy, held to elsewhere - keys under it: to, collation, repair |
consolidate | a mapping | every engine | goal consolidate: column - the column each source's rows are held under, value or values - this source's, keys - how keys two sources hold are kept apart (refuse, tenant, offset, remap or prefix), offsets - each value's under offset, with - the other hops writing the same target - keys under it: column, value, values, keys, offsets, with |
index_advice | true or false | every engine | indexes the translated workload needs, made on the target hypothetically and advised only where its own planner's estimate falls by half |
nodes | a mapping | every engine | what only the operator knows of a many-node topology, read where migkit decides it: spaces - {source: {table: {range: [lo, hi], stride: [offset, step], values: [...]}}} the keys each source writes, conflict - the rule for a key two sources write (apply_remote, keep_local or last_update_wins), route - how a fan-out places a row (by table, range or hash, with tables or bounds), marks - {node: true} where the node tells migkit's writes apart - keys under it: spaces, conflict, route, marks |
split | a mapping | every engine | goal split: with - the other parts of the same source, shared - tables every part takes whole, rest - refuse or stays (the rows no part takes stay on the source) - keys under it: with, shared, rest |
reshard | a mapping | every engine | goal reshard: with - the other hops of the group (their sources and targets the group's), by - auto, hash, range, list, lookup or target (the one target cluster's own distribution), key - {table: shard key columns}, shared - tables every target takes whole, ranges - {target hop: upper bound or null}, values - {target hop: [values]}, lookup - {value: target hop}, default - the target hop of a value not named - keys under it: with, by, key, shared, ranges, values, lookup, default |
stream_lag | a number | Amazon Keyspaces | seconds a Keyspaces change position is held behind the clock, for writes the service has not yet made readable |
target_settings | text or a mapping or true or false | MySQL | the answer, given ahead, to a setting on the target a run needs raised: yes (migkit sets it for the run and puts the old value back, also after a killed run) or no - for every setting or by its name (max_allowed_packet: yes) |
table_engine | text or a mapping | MySQL, a pair across two engines | the storage engine the target's tables are made in - a name, or {to, accept: [group numbering, remote rows], foreign_keys: {child.column: parent.column}} - keys under it: to, accept, foreign_keys |
cdc_confidence_seconds | a number | Cassandra | seconds the follow of a change log stays behind the source's clock |
checksum | text | PostgreSQL | text or jsonb row rendering |
checksum_workers | a whole number | PostgreSQL | tables checksummed at once - a number migkit otherwise decides; leave it out unless its own choice failed you |
closure | text | every engine | what assess says of a table the hop takes that needs one it leaves out - a foreign key's parent, a view's, a routine's or a trigger's table, a sequence's owner, a partition: warn (each named, with the tables to take) or accept (said as accepted) |
cloud | text | every engine | the cloud the servers run in - aws, gcp or azure - where their addresses and the servers do not say; the machine and the target's class are named in it |
code_dir | text | a pair across two engines | where the operator's own versions of routines are kept, one <name>.sql each |
builtin_suites | text or a list | a pair across two engines | where the engines' own test suites are on this machine: each case calling a function the source's code calls is run on both sandboxes, and the ones answered apart become the translator's rules |
code_reference_days | a whole number or true or false | a pair across two engines | days after the cutover the source's answers stay the reference the target's routines are held to (true: 30) |
code_model | a mapping | a pair across two engines | the model a routine no converter proves is asked of - keys under it: provider, url, model |
code_model_rounds | a whole number | a pair across two engines | rounds the model gets on one routine - a number migkit otherwise decides; leave it out unless its own choice failed you |
compare_with | text | every engine | another tool's own check of this move - a Tencent or Alibaba DTS data check's report, AWS DMS's table statistics - held table by table against migkit's answers in the evidence |
create_streams | true or false | Kinesis Data Streams | create a missing stream |
cutover | a mapping or true or false | every engine | the cutover as one timed path that freezes the source and undoes itself (migkit.cutover) - keys under it: budget, start_below, freeze, pooler, flip, flip_undo, keys, jobs, no_return, restore_points |
ddl | text or a mapping | every engine | what a DDL on the source does to a running tail: stop it, park only the table it touched, or apply what can be carried at its place in the log - one word, or a mapping of default, tables or patterns to a word each, and skip: the kinds left out (truncate, drop, create) |
deadline | text or a number | every engine | when the move must be done by - a duration (6h, 90m, 2d) or a moment (2026-10-01T02:00): the plan names the cheapest machine for migkit that meets it |
edition | a mapping | SQL Server, Oracle Database, MySQL, MongoDB | what a change of edition may leave behind on the target - accept: [the features whose loss the hop accepts, as assess names them: encryption at rest, auditing, change data capture] - keys under it: accept |
deep | true or false | Redis | compare every key's value, not a sample |
exact_batches | true or false | every engine | a one-way tail numbers its batches on the target, so a stop resumes after the last committed - false turns off one of the ways migkit may choose; left out, migkit chooses |
follow_until | text | every engine | stopped or caught_up: how long a follow runs |
exclude_schema | text | PostgreSQL | schemas left out of the schema dump |
export_bucket | text | DynamoDB, Firestore (native mode), Firestore in Datastore mode, Amazon Neptune, Amazon Timestream | s3://bucket/prefix the source's own export of a table is written under, for a copy that reads the table off it |
fence_timeout | a whole number | every engine | seconds a fenced re-check waits |
fk_scan_seconds | a whole number | PostgreSQL | the budget of the orphaned-row scan |
float_tolerance | a number | PostgreSQL, Cassandra, CockroachDB, Aurora DSQL | how far two floats may differ |
format | text | Kafka, Kinesis Data Streams, Google Pub/Sub | the change stream's message format |
keep_proof | true or false | every engine | the tail keeps every table's digest leaves up as it applies, so a check reads only what changed |
key | text or a list | Any other SQL engine | the key column(s) of a listed table |
limits | a mapping | every engine | what the move may take at most, kept to as hard limits by its plan (LIMITS): source_load (the share of the source's reads, 0.3 or 30%), money (in the currency transfer_price_per_gb is in), bytes_billed (a warehouse's), outage (the cutover's write outage, seconds), replica_lag (seconds the source's replica may fall behind), target_memory and target_connections - keys under it: source_load, money, bytes_billed, outage, replica_lag, target_memory, target_connections |
lob_scan_seconds | a whole number | MySQL | the budget of the large-value scan |
mask | text or a list or true or false | every engine | values reports show as salted hashes |
mask_on_write | a mapping | every engine | [db.][schema.]table.column (names or patterns) -> null, constant <text>, hash or truncate <n>: written so into the target by every way that carries the table, and proved as written |
transform | a mapping | every engine | [db.][schema.]table.column -> an expression of the column's value in the analytic SQL (lower(email)), run over each batch as it passes and over the source by the check; on_target: true lets the target rewrite it after the copy where that is cheaper |
mask_key | text | every engine | the key a hash in mask_on_write is taken with - a reference to a secret (env:, file:, vault:, ...); the same value gives the same digest on every run |
max_message_bytes | a whole number | Kafka, Kinesis Data Streams, Google Pub/Sub | the largest message a stream takes |
newer_wins | text | every engine | the column that keeps the newer row |
noise_prefix | text | every engine | the beginnings of the names of tables another tool keeps for itself, left out of everything (Hop.excluded), comma-separated |
notify | text or a list or a mapping | every engine | who is told what the migration is doing - an address, a list of them, or {to, events, lag, detail}: the events told (verdict, drift, lag, cutover, approval, failure, fallback, done), the seconds a change tail may be behind, and whether an error's words are sent and not only its kind - keys under it: to, events, lag, detail |
egress | text or a list or a mapping or true or false | every engine | what may leave the machine for this hop - none, or the kinds that may (notify, traces, assist, evidence, anchor), or {allow, to}: the kinds and the hosts they may go to - keys under it: allow, to |
anchor | a mapping | every engine | the audit record's signed checkpoints, kept in a bucket whose Object Lock holds them unchangeable so a record rewritten later shows - the bucket, a prefix, a retention {mode: GOVERNANCE or COMPLIANCE, days}, and required: true to stop a writing command that cannot anchor (credentials are the machine's own, never here) - keys under it: bucket, prefix, region, endpoint_url, retention, required, allowed_signers |
evidence | a mapping | every engine | the evidence export: {sign: a private SSH key} it is signed with - keys under it: sign |
offset_header | true or false | Kafka | each message the copy carries keeps its source partition and offset in a header, so a group's position is placed on the target exactly |
offsets | text | Kafka | how a copied topic's offsets are kept: auto gives a partition whose source offsets have no gap the very same offsets on the target, map also writes every other partition's source-to-target offsets into the target in the same transaction as the messages they describe, off copies as before - false turns off one of the ways migkit may choose; left out, migkit chooses |
offsets_pad_limit | a whole number | Kafka | the most records migkit may produce and then delete to make a partition's first offset the source's; a partition that needs more is copied without identical offsets - a ceiling: migkit works the number out itself and never goes past this |
on_conflict | text | every engine | source-wins or keep-target |
origin_table | text | every engine | keep or drop: the table of migkit's batches on a one-way target (migkit_origin), taken away when the stream is torn down for good - at a --drop, and at the cutover's point of no return - once no tail of the hop runs |
partition_by | text | Kafka, Kinesis Data Streams, Google Pub/Sub | the column a stream partitions by |
performance | text | every engine | gate: a slower target fails the check |
physical | a mapping | PostgreSQL, MySQL, SQL Server | the target may be seeded from a copy of the source's pages, SQL Server's own backup restored, or a cloud's own copy (physical, backupseed, cloudseed), and how - keys under it: data, run, stop, start, restart, source, source_plugin, cloud, source_id, target_id, region, target_region, target_role_arn, kms_key, instance_class, way, subnet_group, security_groups, subscription, resource_group, location, project, address, upgrade, backup, restore_from, profile, role, product, zone, vpc, subnet, spec, storage |
proof_sandbox | text or a mapping | a pair across two engines | the two scratch servers stored code, the constraints, the collations and the sized types are run and compared on, or docker for migkit to start them - keys under it: source, target, docker |
production | text or a list | every engine | host patterns of production servers: a target matching one is written only when the hop names it (production_target) |
production_target | text or a list | every engine | the production server this hop writes to on purpose, by a name it answers to |
protect_target | true or false | every engine | the application may not write the target while migkit moves into it: its rights taken where the engine grants rights, its access policy changed where the hop answers yes (target_access), its writes named before the cutover where nothing holds a writer |
region | text | every engine | the region the machine and the target's class are priced in, where the addresses do not say |
rehearses | text or a mapping | every engine | goal rehearse: the hop this one rehearses, whose plan is forecast from what this one measures - its name, or {hop, databases: {this hop's database: that hop's}} - keys under it: hop, databases |
repair_window | a whole number | every engine | seconds a writer is paused for a repair |
replica_server_ids | a list | MySQL | server IDs of replicas known to the source MySQL server |
replication_factor | a whole number | Kafka | a created topic's replicas |
reverse | text | every engine | at_cutover: a stream back starts at cutover |
rules | a mapping | every engine | questions both sides must answer alike |
sample | a whole number | Redis, Kafka | how many keys or messages are compared |
sap_licence | text | Oracle Database, SQL Server, Db2 (Linux, UNIX, Windows), Db2 for i, Db2 for z/OS, SAP ASE, hana, a pair across two engines, SAP application data (ODP) | the licence of a database that holds an SAP system: full-use (bought apart from SAP, so a direct read is the customer's) or runtime (bought through SAP, which allows no direct read) |
schedule | a mapping | every engine | when the hop runs by itself - keys under it: cron, timezone, run, args, catchup, pause_after_failures, max_duration, retry_window |
schema_authority | text | every engine | which schema reading decides: schema-aware (the default) or every-reading |
server_id | a whole number | MySQL | the replica id the binlog reader uses |
server_to_server | true or false or a mapping | PostgreSQL | the target may pull the rows from the source itself, with the objects that needs made on the servers for the copy and dropped after: true, or {source: host:port} where the target reaches the source at another address - keys under it: source |
settle | a number | every engine | seconds a re-check waits for a stream to settle - left out, none before a re-check of what a stream may still carry, and 2 between the proof's generations |
share_tables | true or false or text | every engine | machines share one move's tables: true, each table to one machine; ranges, a large table's ranges as well, every write held to the number of the claim that took it |
ship | a mapping | every engine | the seed may go on media where the link is too narrow (ship): the carrier (disk, snowball, databox, transfer_appliance), where it is written (path, or endpoint with bucket or container, prefix, region, profile, ca_bundle, credential), its model or capacity, where the far end reads it (load_from, load_endpoint, load_region, load_profile, load_credential), how long it takes to reach the far end as the operator states it (shipping), and who must have signed its manifest (signers) - keys under it: carrier, path, endpoint, bucket, container, prefix, region, profile, ca_bundle, model, capacity, load_from, load_endpoint, load_region, load_profile, shipping, signers, gather, credential, load_credential |
slot | text or a list | PostgreSQL | the slot a pipeline migkit did not set up reads, which the fence waits for |
standby | true or false | every engine | the same move run on two or more machines: one moves it, the others take it over from the last position committed once it stops renewing its lease, the target refusing the one that lost it |
source_changes | text or a mapping or true or false | every engine | the answer, given ahead, to a change on the source a faster way needs: yes (migkit makes it and takes it off again), no or dba - for every change, or by its name (clone_plugin: yes) |
seed_snapshot | text | every engine | the manifest of the source volume's snapshot a block seed is carried from (written by blockseed.manifest): with seed_snapshot_parent only the blocks changed between the two travel |
seed_snapshot_parent | text | every engine | the manifest of the snapshot of the same volume the target already holds |
shards | a whole number | Kinesis Data Streams | a created stream's shards |
snapshot_limit | a number | PostgreSQL | how old a snapshot may get |
source_engine | text | a pair across two engines, SAP application data (ODP) | the source's engine of a hetero hop |
spool_limit | a whole number | every engine | bytes a parked table's changes may take on this machine before the table is copied again instead - a number migkit otherwise decides; leave it out unless its own choice failed you |
state | a mapping | every engine | where run state is kept, and a directory every machine of the hop sees (shared) - keys under it: backend, bucket, prefix, region, endpoint_url, mirror, shared |
subset | a mapping | every engine | goal subset: the rows a copy for testing starts from - start: {table: a condition, a share like 10% or a number of rows} - whether the rows that refer to them come too (children), and the most rows it may hold (most) - keys under it: start, children, most |
tables | a list | Any other SQL engine | the tables of a generic hop |
target_access | text or true or false | DynamoDB, BigQuery | the answer, given ahead, to the change of the target's access policy protect_target offers where the engine's writes are allowed outside the data (a table's own policy, a dataset's access): yes - migkit makes it and gives it back at cutover - or no |
target_engine | text | a pair across two engines, SAP application data (ODP), MySQL | the target's engine of a hetero hop |
target_has_replicas | true or false | MySQL | false: the target has no replicas and no restore replays its binlog, so a load may leave the binlog off |
target_rows | text | every engine | refuse, replace or keep: what a copy does with the rows a table on the target already holds |
tombstones | true or false | Kafka | carry deletes' empty messages |
topic | text | Kafka, Kinesis Data Streams, Google Pub/Sub | the stream name template |
topology | text | every engine | one_way or two_way |
transfer_price_per_gb | a number | every engine | what a carried gigabyte costs |
two_readings | true or false or a mapping | every engine | a second, independent reading of every table, row by row where it has a key (a table that differs is read twice whatever this says): true, or rows, sample and case_insensitive - keys under it: rows, sample, case_insensitive |
two_way | a mapping or true or false | every engine | migkit's own tails both ways, a row both sides changed settled column by column: the rule of a column nothing names (on_conflict), each table's rules by column (tables), and what settles a row one side deleted - keys under it: on_conflict, column, source_rank, target_rank, delta, tables, delete_vs_update, delete_missing |
types_from_data | true or false | a pair across two engines | a column whose declaration leaves its domain open (a bare decimal, a text of no length) is built sized from the data it holds, each narrowing recorded and proved |
verify_batches | true or false | every engine | compare a bulk copy with the source |
versions | a mapping | Amazon Redshift, Snowflake, BigQuery | {table: the column whose value orders a row's versions}, for a warehouse fed from more than one place: rows arrive in any order, and a late row never overwrites a newer one |
wal_archive | text | PostgreSQL | the directory the write-ahead log is archived to, read after the live one |
wal_dir | text | PostgreSQL | where the PostgreSQL write-ahead log is read from on this machine, when the data directory is not |
workload_replay | true or false | every engine | the source's record of what the application ran, every statement on it translated, run on both sandboxes and compared by its answers and the rows it writes, and timed on both sides, weighted by how often each ran |
A side's keys
A side written in the long form rather than as an address.
| Key | Written as | Read on | What it is |
|---|---|---|---|
host | text | every engine | the server's name or address |
port | a whole number | every engine | the server's port |
user | text | every engine | the user migkit signs in as |
password | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | every engine | a reference to the password - env:, file:, vault:, keyring:, aws-sm:, gcp-sm:, azure-kv: |
options | a mapping | every engine | the endpoint's options, the same as writing them beside host |
A side's options
The keys of a side's own options, under it or under its options: - most may also be written in its address.
| Key | Written as | Read on | What it is |
|---|---|---|---|
api_key | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | Qdrant | a reference to the key the service is signed in with - env:, file:, vault:, keyring: |
auth | text | PostgreSQL, MySQL, Aurora DSQL, Amazon Keyspaces, Amazon Neptune, SQL Server | password, or the cloud's own sign-in: aws_iam (rds-iam) for a token the cloud signs, cloudsql_iam for the cloud's access token, azure_managed_identity for the managed identity's token |
authSource | text | MongoDB | the database the user is defined in |
change_stream | text | Google Cloud Spanner | the change stream the tail reads, where not one that watches every table in scope |
changes | a mapping | TiDB, CockroachDB, Aurora DSQL, Couchbase | where the source publishes its changes, where a client cannot read its log: a Kafka topic (servers, topic or topics, format, and how to sign in), a Kinesis stream (stream, region, cdc_stream, order_window), or a changefeed streamed to migkit (via: changefeed) - keys under it: via, servers, hosts, topic, topics, format, security_protocol, sasl_mechanism, user, ssl_cafile, stream, region, endpoint_url, cdc_stream, order_window, password |
change_feed | text | Cosmos DB for NoSQL | latest: follow by the latest-version change feed, which carries no delete - where the account has no all-versions-and-deletes feed |
collection_groups | a list or text | Firestore (native mode) | the collection groups read, each with every collection of its name |
data_boost | true or false | Google Cloud Spanner | true: reads go through Spanner's independent compute, away from the application's |
decoding | text | GaussDB (openGauss) | the logical decoding slot or plugin the changes are read through |
dialect | text | Google Cloud Spanner | the SQL dialect of the Spanner database |
emulator | text | Google Cloud Spanner, Google Cloud Bigtable, Firestore (native mode), Firestore in Datastore mode, Google Pub/Sub | the address of a local emulator the service is reached through instead of the cloud |
graph_api | text | Amazon Neptune | the query language the graph is read in: gremlin or opencypher |
instance | text | Google Cloud Spanner, Google Cloud Bigtable | the Spanner or Bigtable instance |
key_property | text | Neo4j | the property that holds a node's key |
labels | a list | Neo4j | the node labels read |
namespace | text | Firestore (native mode), Firestore in Datastore mode | the namespace of the documents |
priority | text | Cosmos DB for NoSQL, Google Cloud Spanner | low: reads yield to the application where the account runs priority-based execution |
network | text | Couchbase | external: reach the cluster's nodes at their alternate addresses |
mgmt_port | a whole number | Couchbase | the cluster manager's port, where not 8091 (18091 with TLS) |
aws_region | text | PostgreSQL, MySQL, Kafka | the region an aws_iam token is signed for |
aws_role_arn | text | PostgreSQL, MySQL, Kafka | the role an aws_iam token is signed as |
rdf_default | text | Amazon Neptune | the graph a triple with none is put in |
retention | a mapping | Amazon Timestream | how long Timestream keeps what is written: memory_hours and magnetic_days - keys under it: memory_hours, magnetic_days |
sets | a list or a mapping | PolarDB-X, TDSQL (distributed) | the sets of a distributed cluster to read, each its own server |
shardkey | text or a mapping or a list | PolarDB-X, TDSQL (distributed) | the columns each table is spread by, or none for a table that is not sharded: a name, or {table: columns | none} |
sparql | text | Amazon Neptune | the query that reads the RDF side |
sparql_update | text | Amazon Neptune | the update that writes the RDF side |
sslmode | text | PostgreSQL, Amazon Redshift, Teradata | TLS: disable ... verify-full |
sslrootcert | text | PostgreSQL, Amazon Redshift, Teradata | the authority's certificate file |
logmech | text | Teradata | how a Teradata side signs in, where not by its own password (LDAP, KRB5) |
client | text | SAP application data (ODP) | the SAP client the services are read in |
language | text | SAP application data (ODP) | the SAP logon language |
service_path | text | SAP application data (ODP) | where the SAP system publishes its OData services, where not /sap/opu/odata/sap |
kind | text | SaaS applications, read by a connector program | how a program source is spoken to - the kind of connector program it runs, its address's scheme |
program | text | SaaS applications, read by a connector program | what a program source runs: a tap's command, a connector's image or command, a dlt source's module:function, a Salesforce org's sign-in host |
config | text | SaaS applications, read by a connector program | the file of a program's own settings, credentials included |
streams | text or a list | SaaS applications, read by a connector program | the streams (or objects) of a program source to read, all of them when left out |
install | text | SaaS applications, read by a connector program | what installs a program source's program where it is not on this machine: a pip requirement, installed into an environment of its own |
container | true or false | SaaS applications, read by a connector program | run a connector as the container its image is, or as a program on this machine |
api_version | text | SaaS applications, read by a connector program | the Salesforce API version the objects are read through |
pubsub_endpoint | text | SaaS applications, read by a connector program | where Salesforce's change events are read from (host:port) |
pubsub_tls | true or false | SaaS applications, read by a connector program | TLS to the change events' endpoint: off only for a local stand-in |
sslcert | text | PostgreSQL, Amazon Redshift | a client certificate file |
sslkey | text | PostgreSQL, Amazon Redshift | a client key file |
sslcrl | text | PostgreSQL, Amazon Redshift | a revocation list file |
ssl | true or false | MySQL | TLS, nothing checked |
ssl_ca | text | MySQL | the authority's certificate file |
ssl_cert | text | MySQL | a client certificate file |
ssl_key | text | MySQL | a client key file |
ssl_verify_identity | true or false | MySQL | check the name on the certificate |
hosts | text or a list | MongoDB, Kafka | more than one server |
timeout | a number | Neo4j, Qdrant | seconds a request may take before it is given up |
tunnel_by | text | every engine | the mechanism establishing the tunnel |
types | a list | Neo4j | the relationship types read |
uri_options | text | MongoDB | the driver's own options |
path | text | SQLite, DuckDB, Parquet files, Files described by COBOL copybooks, Delta tables | the file or directory |
tables | a mapping | Files described by COBOL copybooks | each table of a directory of files described by COBOL copybooks: its file, copybook, record, recfm, lrecl, codepage, key, segment, redefines, odo, bytes and unreadable |
codepage | text | Files described by COBOL copybooks | the EBCDIC code page the files' text is in (cp037, cp838, cp1047 ...) |
recfm | text | Files described by COBOL copybooks | the files' record format: F, FB, V, VB or ZOSMF |
unreadable | text | Files described by COBOL copybooks | stop (the default) or null: a value that is not one stops the read, or lands as NULL and is listed |
odo | text | Files described by COBOL copybooks | actual (the default) or max: whether a table OCCURS DEPENDING ON its count takes the room of its count or of its most |
url | text | Any other SQL engine, OpenSearch, Parquet files, Delta tables, Snowflake, Couchbase, Cosmos DB for NoSQL | the whole connection address (Snowflake's account URL a streaming channel signs in at, a Cosmos DB account's endpoint, a Couchbase connection string) |
secure | true or false | ClickHouse | TLS |
address_from_target | text | ClickHouse | host:port the target reaches the source at, where it knows it by another name |
service | text | Oracle Database | the service to connect to |
service_name | text | Oracle Database | the service to connect to |
mine_service | text | Oracle Database | the container's root service, where the redo is mined from there (a database before 21c) |
mine_user | text | Oracle Database | the user the redo is mined as, where not the side's own |
mine_password | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | Oracle Database | that user's password reference |
mine_standby | text | Oracle Database | a physical standby of the source the redo is mined on instead (host:port/service) |
mine_off_source | true or false | Oracle Database | the source mines nothing: its redo is mined on the standby or the mining database named |
mine_instance | text | Oracle Database | a database migkit mines the source's shipped archived redo on (host:port/service) |
mine_instance_user | text | Oracle Database | the user that database is mined as, where not the side's own |
mine_instance_password | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | Oracle Database | that user's password reference |
archive_from | text | Oracle Database | where the source's archived redo is read (a directory or an object store) |
archive_to | text | Oracle Database | where the mining database reads the shipped archived redo |
archive_seen_as | text | Oracle Database | that place's path as the mining database sees it, where not the same |
redo_reader | text | Oracle Database | where a redo-file reader run beside the redo listens (host:port) |
redo_reader_dsn | text | Oracle Database | how that reader reaches the database, where not as migkit does |
redo_reader_mb | a whole number | Oracle Database | the memory that reader may take, in MB - a number migkit otherwise decides; leave it out unless its own choice failed you |
link_dsn | text | Oracle Database | how the target reaches the source over a database link, where not as migkit does |
database | text | Db2 (Linux, UNIX, Windows), Db2 for i, Db2 for z/OS, Amazon Redshift, Snowflake, BigQuery | the database to connect to (a z/OS subsystem's location name, an IBM i system's relational database) |
account | text | Snowflake | the account identifier |
warehouse | text | Snowflake, Iceberg tables | the warehouse queries run in (Snowflake), where new tables' files go (Iceberg) |
role | text | Snowflake | the role queries run as |
authenticator | text | Snowflake | how the side signs in, where not by password |
private_key_file | text | Snowflake | a key pair's private key file, which a streaming channel signs in with |
private_key_passphrase | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | Snowflake | the private key's passphrase |
location | text | BigQuery | the datasets' region |
credentials_file | text | BigQuery, Google Pub/Sub | a service account's key file |
anonymous | true or false | BigQuery | sign in as nobody, which only an emulator takes |
api_endpoint | text | BigQuery | the API's address, a private one or an emulator's |
write_endpoint | text | BigQuery | the Storage Write API's host:port |
stage | text | Amazon Redshift, CockroachDB | an S3 prefix the cluster reads staged files from |
iam_role | text | Amazon Redshift, Amazon Neptune | the role the cluster reads the stage as |
stage_region | text | Amazon Redshift | the stage bucket's region |
stage_endpoint_url | text | Amazon Redshift | the stage's S3-compatible endpoint |
iam | true or false | Amazon Redshift | sign in by IAM rather than a password |
cluster_identifier | text | Amazon Redshift | the provisioned cluster an IAM sign-in is for |
serverless_work_group | text | Amazon Redshift | the Serverless workgroup an IAM sign-in is for |
profile | text | Amazon Redshift | the AWS profile an IAM sign-in uses |
db_user | text | Amazon Redshift | the database user an IAM sign-in becomes |
catalog | text | Iceberg tables | the Iceberg catalog: sqlite:///... or another SQL database's URL, or a REST catalog's http(s) address |
catalog_name | text | Iceberg tables | the name the catalog keeps its tables under |
catalog_properties | a mapping | Iceberg tables | anything else the catalog takes |
project | text | Google Pub/Sub, Google Cloud Bigtable, Firestore (native mode), Firestore in Datastore mode, Google Cloud Spanner | the project |
region | text | DynamoDB, Kinesis Data Streams, Parquet files, Amazon Redshift, Delta tables, Aurora DSQL, Amazon Keyspaces, Amazon Neptune, Amazon Timestream | the region |
endpoint_url | text | DynamoDB, Kinesis Data Streams, Parquet files, Delta tables, Amazon Keyspaces, Amazon Timestream | an endpoint of its own (a local one, a compatible store) |
table_prefix | text | DynamoDB | the table names' template |
index_prefix | text | OpenSearch | the index names' template |
tls | true or false | OpenSearch, Db2 for i, Couchbase, Cosmos DB for NoSQL, SAP application data (ODP), Oracle Database, Amazon Neptune, MongoDB, Redis, Cassandra | TLS, the certificate checked against the system's authorities (https on OpenSearch, Cosmos DB and SAP) |
tls_ca_file | text | Db2 for i, Couchbase, SAP application data (ODP), Oracle Database, MongoDB, Redis, Cassandra | the authorities' certificates file |
tls_cert_file | text | MongoDB, Redis, Cassandra | a client certificate file |
tls_key_file | text | Redis, Cassandra | a client key file |
tls_crl_file | text | MongoDB | a revocation list file |
tls_insecure | true or false | Db2 for i, Couchbase, Cosmos DB for NoSQL, SAP application data (ODP), Oracle Database, MongoDB, Redis, Cassandra | TLS with nothing checked (an emulator's own certificate) |
encrypt | text or true or false | SQL Server | require, request or off |
redis_product | text | Redis | community, cloud or software: the Redis product the target is, where its name cannot say |
rdb_file | text | Redis | a backup file of the source's keyspace, read in its place so the server is left alone |
aof_file | text | Redis | the source's append-only file, read in its place |
aof_timestamp | a whole number | Redis | the moment, in seconds since the epoch, the append-only file is read up to |
snapshot | a mapping | OpenSearch | a snapshot of the source an index may be copied from: its name, its repository on the source, and where its files are - keys under it: name, repository, local_dir, s3_uri, s3_region |
verify | true or false | OpenSearch | check the certificate |
odbc_driver | text | SAP ASE | the ODBC driver's file |
replication | text or a mapping | Cassandra | a created keyspace's replication |
security_protocol | text | Kafka | PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL |
sasl_mechanism | text | Kafka | how SASL signs in |
ssl_cafile | text | Kafka | the authority's certificate file |
schema_registry | text | Kafka | the schema registry's address |
schema_registry_user | text | Kafka | the schema registry's user |
schema_registry_password | a reference to a secret (env:NAME, file:/path, vault:path#key, keyring:name) | Kafka | the schema registry's password |
managed | a mapping | every engine | the managed service this side is and how its provider's API reaches it: service (its name in the managed-service catalogue, where neither its address nor its server says), id (its instance at the provider, where its address does not find it), region, profile (the provider CLI's profile its credentials come from), role (one assumed), and what else the provider asks for - keys under it: service, id, region, profile, role, project, subscription, resource_group, compartment, project_id, zone, cluster, vpc, subnet, spec, storage |
tunnel | text or a mapping | every engine | reach the server through a tunnel |
tunnel_to | text | every engine | what carries the connection, for the report |
bastion | a mapping or text | every engine | bastion jump host configuration for SSH/SSM port forwarding |
admin | text or a list | Neo4j | the neo4j-admin command or path |
azure_client_id | text | every engine | the managed identity client ID on Azure |
dump_dir | text | Neo4j | a directory for neo4j database dumps |
log_standby | text | SQL Server | a SQL Server log standby directory or secondary database name |
recall_k | a whole number | Qdrant | the k nearest neighbours evaluated for vector recall |
stop_database | true or false | Neo4j | whether neo4j-admin may stop a database for dump |
transactions | true or false | DynamoDB | whether DynamoDB uses TransactWriteItems or writes without |
_original_host | text | every engine | internal recording of original endpoint host before bastion tunnel rebinding |
_original_port | a whole number | every engine | internal recording of original endpoint port before bastion tunnel rebinding |
6 more keys turn one named way of migkit's on or off; migkit doctor says what each does on a hop that sets one.