Data type support by engine

Check which column types SQL Flow captures from each source engine and capture mode, and which types it refuses.

This page lists, per source engine and capture mode, the column types SQL Flow captures and the ones it refuses or handles with a caveat. For the type each target gets, see Data type mapping.

When SQL Flow can't carry a type exactly, it refuses the table by name at the start, or stops the pipeline with a message that names the column, rather than truncating or rounding the value. "Not tested" means the type's behavior isn't verified; test such a table before you rely on it.

SQL Server and Azure SQL

Azure SQL captures with Native CDC, so its column is the Native CDC column below.

Notes for SQL Server

• Large values. DirectLog takes varchar(max), nvarchar(max) and varbinary(max) values from the log on SQL Server 2022 and 2025, and xml on every supported version. Elsewhere, and in Polling and Reconstruction, an off-row value is read from the table by key, so it carries the row's current value. See Large values and LOBs.
• Large values under DirectLog. When every target of the pipeline is Fabric Open Mirroring, a table whose large-value column (such as varchar(max), varbinary(max), xml, json, text or image) already holds a value larger than 1 MiB is refused at the start, and a larger value written later stops the pipeline. With any other target, DirectLog has no such limit. Once DirectLog marks a table with text, ntext or image columns for capture, SQL Server rejects UPDATETEXT (error 7137) and WRITETEXT (error 7138) from your application, so replace those statements with ordinary UPDATE statements first. See DirectLog: Limitations.
• text, ntext and image under Reconstruction. Refused when the table stores them in row (text in row), or when its other columns let a row grow past 8,060 bytes. UPDATETEXT and WRITETEXT stop the pipeline. See Reconstruction: Limitations.
• CLR user-defined types. DirectLog refuses a table with a CLR user-defined type column when the table also has a large-value column, or when its declared column widths let a row grow past 8,060 bytes, because it reads such rows back by key and can't read a CLR value that way. In other tables, DirectLog and Polling capture the value as its bytes. Under Native CDC, the capture stops by name when it first reads a table with such a column.
• sql_variant. Under DirectLog and Reconstruction, SQL Server and Azure SQL targets get each value with its own base type, through ordered apply. The column can't be a key column, sparse, computed, in a column set or of an alias type, and the table can't have Always Encrypted columns; the Prepare step refuses such a column by name. Polling and Native CDC read the value without its base type, so SQL Server-family and PostgreSQL targets refuse the column: capture the table with DirectLog or Reconstruction, or deselect it on the Tables step. SQL database in Fabric targets refuse sql_variant from every mode.
• Sparse columns and column sets. Under DirectLog and Polling, a table with sparse columns and a dropped column that no rebuild has removed yet is refused: on SQL Server 2025 only when the table is partitioned, on earlier versions always. Run ALTER TABLE <table> REBUILD, then start again. SQL Server can't mark a table with a column set for DirectLog or enable it for Native CDC (error 22854): drop the column set, whose sparse columns stay and are captured, or capture the table with Polling. A SQL Server table that Prepare target schema creates for a Polling source gets the same sparse columns and column set.
• Added columns. An untyped xml column added to a tracked table while the pipeline runs is captured under DirectLog and Reconstruction, and the target gets an xml column. Adding a column of typed xml or of a CLR user-defined type stops DirectLog, Reconstruction and Polling with the schema history gap message below. Every restart, and Pause then Start, stops at the same change, even after you undo it on the source; only Reload from source continues. See Changes that stop the pipeline.
• Non-persisted computed columns. A SQL Server-family table that Prepare target schema creates gets the same computed column, so the target computes it again.
• Key columns. On a SQL Server-family target, a key column can't be hierarchyid, rowversion, xml, json, vector, geography, geometry, sql_variant or a MAX type. The Prepare step refuses such a table by name.
• geography and geometry are carried as SQL Server's serialized bytes, and a PostgreSQL target refuses them. See Data type mapping.
• Masked columns and ANSI_PADDING OFF. DirectLog, Reconstruction and Polling refuse a column with a dynamic data mask that the login can't UNMASK, and a nullable char or binary column created with ANSI_PADDING OFF.
• Always Encrypted. See Encrypted data support.

Messages you can see:

A column of xml typed by an XML schema collection, at the start:

typed_xml_schema_collection: selected column <table>.<column> is XML(<DOCUMENT|CONTENT> <collection>); typed XML schema-collection identity and definitions are not supported by this capture/provisioning route. Refusing to flatten it to untyped xml.

A sql_variant column from Polling or Native CDC into a SQL Server or Azure SQL target, on the Prepare step. Under DirectLog and Reconstruction, the reason instead names a key column, or a sparse, computed, column-set or alias-typed declaration:

Table '<table>', column '<column>' (sql_variant): sql_variant remains deferred for this capture: only DirectLog and Reconstruction into a SQL Server or Azure SQL target carry each value's own base type exactly; Built-in CDC and Polling read it as a plain value, which would lose that type. To continue: ...

A DirectLog table with a column set:

a decodable storage kind for tracked table <table> (the table is with a sparse COLUMN_SET: SQL Server refuses to mark it for capture (sys.sp_cdc_enable_table raises error 22854: CDC does not support a COLUMN_SET), ...

A DirectLog table with large values or wide rows and a column that can't be read back by key, such as a CLR user-defined type:

complete-row LOB fetch projection for table <table> (column '<column>' with SQL type '<type>' cannot be fetched: its value encoding is unsupported. ...

A table with sparse columns and a dropped column that no rebuild has removed, under DirectLog or Polling:

Tables with SPARSE columns and a dropped-but-not-rebuilt column are not supported in <mode> mode: <tables>. ...

An added column of typed xml or of a CLR user-defined type, while the pipeline runs. The reason names the column, for example column '<column>' is typed xml (xml_collection_id <n>); ... Refusing to flatten it to untyped xml:

SQL Server log-native schema history gap for '<table>': <reason>. No successor plan, row output, or checkpoint was published. A restart, or Pause → Start, reads this change from the log again and stops here, also after the change is undone at the source; Reload from source starts the pipeline over from a fresh copy.

A Native CDC column of a CLR user-defined type, the only column type that raises it:

NativeCdcUnsupportedProviderType: column '<column>' of '<table>' has type '<type>'; its retained provider bytes cannot be bounded before materialization. No checkpoint was advanced.

A Native CDC computed column:

native_cdc_computed_column: Native capture refuses selected column <table>.<column>: CDC records computed cells as NULL and the original captured column/dependency identity or supported historical expression is unproved.

A table shape Reconstruction can't capture, such as a CLR user-defined type column:

Reconstruction refuses table <table>: it <reason>; remove the table from the pipeline's scope, or capture it with Polling or Native CDC.

Oracle

Notes for Oracle

• Encryption. DirectLog can't decrypt, so it refuses a table in an encrypted tablespace, or with encrypted columns or LOBs, by name before the initial load. LogMiner captures them while the TDE keystore is open, and stops by name when it can't show a value, for example while the keystore is closed. See Encrypted data support.
• Numbers. A NUMBER value too large or too precise for a decimal is carried as exact text, never rounded.
• Character sets. DirectLog decodes text itself, so the database character set (NLS_CHARACTERSET) must be AL32UTF8, UTF8, US7ASCII, WE8ISO8859P1, WE8MSWIN1252, WE8ISO8859P15 or WE8PC850. Any other is refused at the start. A stored value with bytes that the character set doesn't define stops capture rather than being written with replacement characters. LogMiner works with every character set.
• Large values. DirectLog reads some BLOB, CLOB and NCLOB values from the table as of the commit, so it needs SecureFile retention and guaranteed undo. RETENTION MIN keeps old LOB versions only while Flashback Database is on, so RETENTION MIN with Flashback Database off is refused: turn Flashback Database on, or use RETENTION MAX with a MAXSIZE. See Oracle DirectLog requirements and Large values and LOBs.
• LONG and LONG RAW. Under DirectLog, an update that re-chains a row's value across blocks, for example by growing it, stops capture by name; capture such tables with LogMiner. Under LogMiner, a value LogMiner doesn't return is read from the table as of the commit, which needs FLASHBACK on the table and enough undo. The initial load in both modes, and LogMiner's reads as of the commit, refuse a value larger than 16 MiB.
• LogMiner refusals. A table with a native BOOLEAN, JSON or VECTOR column is refused at the start, because LogMiner returns no usable changes for it. Capture it with DirectLog, or store JSON in a CLOB or BLOB with an IS JSON constraint. A table with an extended-width VARCHAR2 or NVARCHAR2 column over 4,000 bytes, or RAW column over 2,000 bytes (MAX_STRING_SIZE=EXTENDED), is refused too, because LogMiner can report a placeholder instead of the value.
• Types neither mode captures. A table with a BFILE, REF, nested-table, ANYDATA, ANYTYPE, ANYDATASET or URI-type column is refused by name in both modes. Remove the table from the pipeline, or change the column's type.

Messages you can see:

Table <schema>.<table> has a native JSON column "<column>", which DBMS_LOGMNR reports as OPERATION=UNSUPPORTED and cannot capture: ...

Table <schema>.<table> has an extended-width <type>(<length>) column "<column>" (MAX_STRING_SIZE=EXTENDED). Oracle LogMiner can report a placeholder instead of values wider than the standard limit, so SqlFlow refuses LogMiner capture of this table; exclude it from LogMiner capture.

Table <schema>.<table> has a <type> column "<column>", which Oracle lists as unsupported by DBMS_LOGMNR: the table would silently produce no usable DML records. No SqlFlow capture mode supports this column type (DirectLog refuses it too); exclude this table from capture.

<schema>.<table>: virtual/generated column(s) <columns> are not stored as ordinary redo fields. DirectLog refuses this table rather than risk shifting the physical column layout.

<schema>.<table>: XMLTYPE column(s) <columns> are not proven CLOB-backed. DirectLog currently supports only XMLTYPE stored as CLOB; binary, transportable-binary, and object-relational XML must fail closed.

Oracle XMLTYPE text projection requires catalog-proven CLOB storage; binary and object-relational XML representations are refused.

Oracle database character set '<name>' is not supported for raw value decoding.

DirectLog does not yet reconstruct a re-chained LONG/LONG RAW row update (its last-piece marker is carried by an OP 11.8 forwarding change); capture this table with LogMiner.

oracle_long_prefetch_value_exceeds_allowance: complete bounded original-result LONG acquisition is required.

PostgreSQL

SQL Flow doesn't refuse any column type at the start; a value it can't decode stops the pipeline.

See Logical replication: Column types.

MySQL

A column type SQL Flow can't decode from the binlog stops the pipeline at the first change to the table, usually with Unsupported column type: <type> (0x<code>). Remove the table from the pipeline. See Binlog: Unsupported column type.

Partial JSON updates (binlog_row_value_options set to PARTIAL_JSON) are refused at the start. If the setting changes later, capture stops with a message that starts Encountered a PARTIAL_UPDATE_ROWS_EVENT (binlog event type 39). Set binlog_row_value_options to an empty string, then reload the pipeline. See Binlog: Partial JSON update in the binlog.

Sybase ASE

An alias type is captured as its base type.

Notes for Sybase ASE

• Large values. Both modes capture text, unitext and image columns in full. A value whose page chain is longer than 4,096 pages is refused.
• Lock schemes. Both modes capture all-pages, data-pages and data-rows locked tables.
• Character sets. A table with char, varchar, nchar, nvarchar or text columns needs a server character set SQL Flow can decode. See Supported character sets.

Messages you can see:

LOB chain exceeded 4096 pages; refusing to walk a runaway/corrupt chain.

Invalid ASE schema metadata for column '<column>' (colid=<n>, declared='<type>', physical=0x<code>): unsupported physical type 0x<code>.

ASE server character set '<name>' is unsupported; refusing a replacement encoding.

See also

• Data type mapping
• Large values and LOBs
• Supported sources and targets
• Choosing a capture mode