Support matrix and known limitations

Check supported source versions, capture modes, targets and features in one place, with the known limitations of each engine and target.

Check a combination here before you build a pipeline. Each row links to the page with the requirements, the setup and the exact messages.

Sources and capture modes

The wizard selects the first mode listed for each engine.

• Oracle: releases other than the tested ones, including later release updates, are expected to work. Validate a pipeline in a test environment before you rely on an untested release.
• SQL Server: releases before 2016 SP2 are refused by name. On 2016 SP2 and 2017, Reconstruction, and DirectLog for tables with LOB columns or long rows, need the signed helper procedure dbo.sqlflow_page_header, which a sysadmin installs once.
• Azure SQL Managed Instance allows no log broker on its hosts, so DirectLog and Reconstruction aren't possible there.
• Sybase ASE: any other build or page size is refused by name at start.
• Managed PostgreSQL and MySQL services, such as Amazon RDS and Aurora, are sources when they pass the same checks as any other server. See PostgreSQL: Managed services and MySQL: Managed services.
• SQL database in Microsoft Fabric has no change data capture, so it is a target only.

To pick a mode, see Choosing a capture mode.

Targets

• Set-based apply is what Collapse row versions (faster) turns on. Tables where collapsing isn't safe, such as tables with triggers, are applied in order anyway.
• Encryption. SQL Server, PostgreSQL, MySQL, Oracle and Sybase ASE targets have an Encryption setting, Require (default) or Prefer. Azure SQL and SQL database in Fabric always validate the server certificate. See Encrypted data support.
• Reload isn't available for Kafka, Google Pub/Sub and Fabric Open Mirroring, because published events and files can't be withdrawn.

DirectLog pipeline rules

DirectLog pipelines write to every target, and to several targets in one pipeline, like every other capture mode, with two exceptions:

• Source monitor isn't available for SQL Server, Oracle or Sybase ASE DirectLog.
• One capture agent per database. All SQL Server DirectLog pipelines of one database use the same capture agent and standby. A Sybase ASE database takes one pipeline, in either Sybase mode.

Features

High availability, table and column names, in-flight processing, compare and repair, schema-change propagation and relay work with every source, capture mode and target.

Known limitations

The main limits of each engine and target. Each page has the full list, the exact messages and the fixes.

SQL Server and Azure SQL sources

Every mode

• Always Encrypted columns are refused. Only DirectLog can copy the ciphertext unchanged into SQL Server or Azure SQL targets that use the same column encryption keys: set by the CLI, not over relay, and for bounded scalar types only.
• Encryption at Prefer doesn't check the server certificate, except for host names under .database.windows.net.

DirectLog

• Needs FULL recovery with a full backup, exactly one log file, READ_COMMITTED_SNAPSHOT or ALLOW_SNAPSHOT_ISOLATION on, delayed durability off, CDC enabled on the database, every selected table marked, and max text repl size at -1 for tables with LOB columns. See DirectLog: Requirements.
• Refuses TDE databases. Adding a second log file, or turning TDE on, stops the pipeline.
• Refuses some table shapes, such as memory-optimized, system-versioned temporal, clustered columnstore and ROW or PAGE compressed tables, and articles of a replication publication. See DirectLog: Limitations.
• Refuses tables with a column set, which SQL Server can't mark for capture; capture them with Polling, or drop the column set. A table with a CLR user-defined type column is refused when it also has a large-value column or rows that can grow past 8,060 bytes.
• When every target is Fabric Open Mirroring, a table whose large-value column already holds a value larger than 1 MiB is refused, and a larger value written later stops the pipeline. With any other target, large values have no such limit.
• A table with sparse columns and a dropped column that no rebuild has removed is refused, on SQL Server 2025 only when the table is partitioned. Run ALTER TABLE <table> REBUILD first.
• Once a table with text, ntext or image columns is marked for capture, SQL Server rejects UPDATETEXT and WRITETEXT from your application.
• Holds the source log until the target commits. A stopped agent lets the log grow; a pause releases the hold.
• Resumes from log backups only when they are on disk in a folder the broker serves, not encrypted or striped, and uncompressed or compressed with MS_XPRESS (SQL Server 2019 and later) or ZSTD (SQL Server 2025).

Reconstruction

• Refuses TDE databases.
• An update to a row not seen since capture started carries the row's current value, so the target converges to the source rather than replaying every intermediate version.
• Refuses some table shapes, such as memory-optimized, clustered columnstore and ROW or PAGE compressed tables, column sets, in-row text, ntext or image, sparse MAX and xml columns, CLR user-defined types and FILESTREAM. See Reconstruction: Limitations.
• Stops on operations it can't follow exactly: a partition TRUNCATE; a resumable, online partitioned or layout-changing rebuild; an index REORGANIZE or DBCC SHRINKFILE that moves rows; partition SWITCH, SPLIT or MERGE; UPDATETEXT or WRITETEXT; and a change of recovery model or delayed durability. Only Reload from source continues past such a halt, so plan index maintenance on tracked tables for a time when a reload is acceptable.

Polling

• Refuses ROW, PAGE and columnstore-compressed tables. A table rebuilt with compression after the start stops the capture.
• A table with sparse columns and a dropped column that no rebuild has removed is refused, on SQL Server 2025 only when the table is partitioned. Tables with a column set are captured.
• sql_variant is read without its base type, so SQL Server-family and PostgreSQL targets refuse it. CLR user-defined types are captured as bytes, which the same targets refuse.
• On SQL Server 2025, a db_owner login also needs a user in master with SELECT on sys.fn_dblog.
• A partition TRUNCATE, a resumable rebuild, an online rebuild of a partitioned table, and a rebuild that changes the row layout stop the capture.
• An open transaction that holds a DDL change or a TRUNCATE makes capture wait until it commits or rolls back.
• Every read costs the server query work, and lag is in seconds.

Native CDC (SQL Server and Azure SQL)

• Every table needs a primary key; a unique index isn't used.
• Refuses computed columns, CLR user-defined types, and char, varchar and text columns whose code page differs from the database's. SQL Server can't enable CDC on a table with a column set.
• sql_variant is read without its base type, so SQL Server-family and PostgreSQL targets refuse it.
• Lag follows the CDC capture job's scan interval. If CDC's cleanup removes change rows before the pipeline reads them, for example during a long pause, the table needs a reload.
• On SQL Server, tables with LOB columns need max text repl size at -1.
• Key repair and resync need permission to run sys.sp_repltrans, which db_owner has.

Azure SQL only

• Native CDC is the only mode, and Windows authentication isn't available.
• SQL Flow doesn't check the service tier: on a tier without CDC, sys.sp_cdc_enable_db fails.

Oracle sources

DirectLog

• Redo and archived logs must be on a file system, not ASM, and the database must have one redo thread, so Oracle RAC isn't supported.
• Needs ARCHIVELOG, minimal supplemental logging, an (ALL) COLUMNS supplemental log group on every table, and DB_BLOCK_CHECKSUM set to TYPICAL or FULL.
• LOB columns must be SecureFile, not partitioned, with RETENTION MIN of at least 3,600 seconds and Flashback Database on, or RETENTION MAX with a MAXSIZE. Undo needs at least 3,600 seconds of retention with RETENTION GUARANTEE.
• The database character set must be AL32UTF8, UTF8, US7ASCII, or one of the single-byte Western European sets WE8ISO8859P1, WE8MSWIN1252, WE8ISO8859P15 and WE8PC850.
• Refuses virtual columns, XMLTYPE not stored as CLOB, and BFILE, REF, nested-table, ANYDATA-family and URI-type columns. Refuses TDE-encrypted tables too, which you capture with LogMiner instead. See Oracle DirectLog: Limitations.
• An update that re-chains a LONG or LONG RAW value across blocks stops capture; capture such tables with LogMiner.
• Table resync, key repair and processing rules force a log switch, which needs ALTER SYSTEM in the root.
• An archived log deleted before DirectLog reads it stops the pipeline.

LogMiner

• Refuses tables with native BOOLEAN, JSON or VECTOR columns, extended-width VARCHAR2, NVARCHAR2 or RAW columns, and BFILE, REF, nested-table, ANYDATA-family and URI-type columns.
• Keep the TDE keystore open: when LogMiner can't show a value, capture stops by name.
• LOB and LONG values that LogMiner doesn't return are read as of the commit SCN, which needs enough undo; if the history is gone, capture stops.
• Archived logs deleted before LogMiner reads them stop the pipeline. Lag is in seconds.

Both modes

• Every table needs a primary key constraint.
• A LONG or LONG RAW value over 16 MiB stops the initial load, and under LogMiner also a read of a value as of its commit.
• A PDB source needs Root service for capture set to the CDB root service, and a common capture user.
• Under Encryption at Prefer, a connection without TLS settings connects over plain TCP.

PostgreSQL

As a source

• Needs wal_level = logical and a positive max_slot_wal_keep_size.
• The replication slot keeps WAL while the pipeline is paused or behind. Past max_slot_wal_keep_size, PostgreSQL invalidates the slot and the pipeline needs a reload.
• An unchanged out-of-line (TOAST) value isn't resent, so the target keeps its value.
• No column type is refused at the start. Arrays, enums, ranges, domains and extension types aren't tested, and a composite-type field of a type other than character, boolean, integer, numeric or uuid arrives as hexadecimal bytes. See Data type support by engine.
• After a failover to another server, or a restore, the slot is missing and the pipeline needs a reload.
• Once a table is in SQL Flow's publication, PostgreSQL rejects UPDATE and DELETE on it unless it has a primary key, a replica identity index or REPLICA IDENTITY FULL.

As a target

• Every target table needs a primary key or unique constraint on the source key.
• An Oracle NUMBER column with a negative scale needs PostgreSQL 15 or later.
• Identifiers longer than 63 bytes are shortened only for Oracle sources.
• A captured TRUNCATE is applied without CASCADE, so a referencing foreign key stops apply.
• A value is limited to about 1 GiB, unless the column is stored as a large object with postgresLargeObjectColumns.
• No privilege check runs: a missing privilege appears as PostgreSQL's own error when the statement that needs it runs.

MySQL

As a source

• Needs binlog_format = ROW, binlog_row_image = FULL, binlog_row_metadata = FULL and an empty binlog_row_value_options.
• The position is a binlog file and offset, not a GTID. After a failover to another server, or when the binlog it needs is purged, the pipeline needs a reload.
• Only caching_sha2_password and mysql_native_password are accepted.
• binlog_row_value_options set to PARTIAL_JSON is refused at the start, and a partial JSON update logged after a later change of that setting stops capture. One binlog event can be at most 1 GiB.
• A column type SQL Flow can't decode from the binlog, such as MySQL 9 VECTOR, isn't refused at the start: the first change to the table stops the pipeline. Decimal and date values stored inside a JSON document in MySQL's own format stream as strings that start with opaque:. See Data type support by engine.

As a target

• Every target table needs a primary key or unique constraint on the source key.
• Tables SQL Flow creates use a general type mapping, so decimals with more than 10 digits after the point and time zone offsets don't survive it.
• Identifiers longer than 64 characters aren't shortened.

Sybase ASE

As a source

• The log must be on a device of its own, and every device the broker serves must be a file on a file system, not a raw device. A database with a RepAgent, or with full database encryption, is refused.
• Every table needs a primary key constraint, and no row, page or LOB compression. Tables with encrypted columns are refused by name.
• DirectLog needs the tables marked for replication with sp_setreptable.
• Both modes capture every lock scheme and text, unitext and image columns.
• Reconstruction needs no marking, but update after-images come from the current data page, so the target converges to the source rather than replaying every intermediate state. Its broker serves the data and LOB devices too.
• SQL Flow holds the log while the pipeline runs, so it can't be truncated and keeps growing. A pause releases the hold.
• For column types, LOB size and character sets, see Data type support by engine.

As a target

• Tables SQL Flow creates use varchar(1024) for text and drop date-time offsets.
• All target tables live in the connection's database. A table with no mapped owner is created as dbo.<table>, which needs the database owner or a login aliased to dbo.

SQL Server, Azure SQL and SQL database in Fabric targets

• Every target table needs a primary key or unique key that matches the source key. Missing columns aren't added to an existing table.
• rowversion, timestamp, hierarchyid, xml, json, geography, geometry, vector, sql_variant and unbounded columns can't be part of a key that Prepare target schema creates.
• CLR user-defined types are refused, and sql_variant is supported only outside the key and only from a SQL Server DirectLog or Reconstruction source, with ordered apply. A source collation the target server lacks is refused; UTF-8 collations need SQL Server 2019 or later.
• Tables with enabled triggers, and temporal, ledger and memory-optimized tables, are applied in order, row by row.
• The bookkeeping schema can't change after the pipeline is created.
• A table that holds rows but has no SQL Flow load record is never emptied: the start is refused with target_initial_load_ownership_unproven until you empty it yourself. This is always the case for a table from a PostgreSQL, MySQL, Oracle or Sybase ASE source.
• Writing into Always Encrypted columns needs ordered apply. The certificate key store works only on Windows agents.
• SQL database in Fabric: no memory-optimized tables or table types, ledger or Always Encrypted tables; column names can't contain a space or any of , ; { } ( ) =, a tab or a newline; a primary key can't be hierarchyid or timestamp, and sql_variant columns are refused; some types aren't mirrored to OneLake.

Oracle target

• Tables SQL Flow creates use varchar2(4000) for key text and raw(2000) for key binary columns.
• Target tables can't be qualified with another database.

Kafka and Google Pub/Sub

• Every captured table needs a primary key on the source.
• An UPDATE that changes a primary-key value, and a captured TRUNCATE, stop the pipeline.
• Reload isn't available. To publish a fresh snapshot, create a new pipeline.
• A message is limited to 1,000,000 bytes on Kafka, which you can't raise, and 10,000,000 bytes on Pub/Sub. To keep a large column out of the events, leave it out with output columns.
• SQL Flow doesn't create topics. Messages are JSON only, and there is no dead-letter topic: an event that can't be published stops the pipeline.
• Delivery is at least once. A pipeline stopped during the initial snapshot publishes the snapshot again when it restarts.
• Kafka: GSSAPI (Kerberos), OAUTHBEARER and client certificates aren't supported.

Fabric Open Mirroring

• Every captured table needs a primary key on the source.
• A captured TRUNCATE stops the pipeline. To reload one table, re-seed it with restartTables and restartEpoch.
• One pipeline owns each table folder, and a target can't be pointed at a different mirrored database.
• Decimals are written as DECIMAL(38,18), and a value outside that range stops the pipeline. A datetimeoffset is written as UTC. A value larger than maxValueBytes stops the pipeline.
• The lag SQL Flow shows ends when a file lands in the landing zone, before Fabric ingests it.

Pipelines and the initial load

• Rows already in the target. A first start empties a target table that holds rows and loads it again, except on SQL Server-family targets without a load record, as described above. See Initial load.
• Changing the table set. Adding a table loads only that table, and removing one loads and empties nothing. Changing the source host, port or database loads every table again. See Changing tables.
• The spool's limit. When the spool is full, a SQL Server DirectLog capture that holds the source log waits. Otherwise the spool drops its oldest changes, and a target that still needed them fails with a retention-gap fault and needs Reload from source. See Lag, spool and log retention.
• An offline agent. The UI doesn't pause a pipeline whose agent is offline. Use sqlflow pipeline pause --force, or revoke an agent that is lost for good. See High availability: Agents.

Relay

• Relay host takes a DNS name or an IPv4 address; IPv6 isn't supported.
• During a link outage, a SQL Server DirectLog source keeps its log from the position the target last committed.

Schema changes

• ADD COLUMN and DROP COLUMN reach every target. An ADD COLUMN whose default isn't a constant, such as NEWID() or GETDATE(), stops the pipeline before the change. Dropping a key column holds the table for review.
• A rename of a non-key column, a length change and a nullability change are applied where the target can make them exactly. Otherwise the table is held for review.
• A change of a column's type, collation, identity, computed definition, sparse or encryption setting, a table rename, DROP TABLE and a partition switch stop the pipeline.
• On a SQL Server source under DirectLog, Reconstruction or Polling, adding a column of typed xml or of a CLR user-defined type stops the pipeline until you select Reload from source. An added untyped xml column is captured.
• A schema change on a table that a processing rule covers holds the covered tables until you reload the pipeline.

See also

• Supported sources and targets
• Choosing a capture mode
• Data type support by engine
• Encrypted data support
• Troubleshooting