risingwavelabs/risingwave · error · SinkError::SqlServer

{data_type_name} is not supported in SQL Server

Error message

{data_type_name} is not supported in SQL Server

What it means

This helper constructs a `SinkError::SqlServer` for RisingWave data types that have no SQL Server equivalent in the sink's parameter binding/compatibility checks. `check_data_type_compatibility` (at sink creation) and `bind_params` (at runtime) call it when they encounter an unsupported `DataType`. The sink deliberately refuses unsupported types rather than corrupting data.

Source

Thrown at src/connector/src/sink/sqlserver.rs:904

                    query.bind(None as Option<Vec<u8>>);
                }
                DataType::Interval => return Err(data_type_not_supported("Interval")),
                DataType::Struct(_) => return Err(data_type_not_supported("Struct")),
                DataType::List(_) => return Err(data_type_not_supported("List")),
                DataType::Jsonb => return Err(data_type_not_supported("Jsonb")),
                DataType::Variant => return Err(data_type_not_supported("Variant")),
                DataType::Serial => return Err(data_type_not_supported("Serial")),
                DataType::Int256 => return Err(data_type_not_supported("Int256")),
                DataType::Map(_) => return Err(data_type_not_supported("Map")),
                DataType::Vector(_) => return Err(data_type_not_supported("Vector")),
            },
        };
    }
    Ok(())
}

fn data_type_not_supported(data_type_name: &str) -> SinkError {
    SinkError::SqlServer(anyhow!(format!(
        "{data_type_name} is not supported in SQL Server"
    )))
}

fn unexpected_downstream_timestamptz_type(sql_server_data_type: &str) -> SinkError {
    SinkError::SqlServer(anyhow!(format!(
        "unexpected downstream SQL Server type {sql_server_data_type} for Timestamptz"
    )))
}

fn check_data_type_compatibility(data_type: &DataType) -> Result<()> {
    match data_type {
        DataType::Boolean
        | DataType::Int16
        | DataType::Int32
        | DataType::Int64
        | DataType::Float32
        | DataType::Float64

View on GitHub (pinned to 6469eb736d)

Solutions

  1. Flatten or drop unsupported columns in the materialized view before sinking (e.g. cast structs to JSON strings if supported, or exclude the column).
  2. Cast unsupported types to supported SQL Server-compatible types in the sink's schema (e.g. `CAST(col AS VARCHAR)`).
  3. Check the function's match list in src/connector/src/sink/sqlserver.rs to see exactly which RW types are supported.
  4. If the type should be supported, file/track an upstream feature request; upgrading RisingWave may add support.

Example fix

// before: sinking a struct column directly
CREATE SINK s FROM mv WITH (connector='sqlserver', ...); // mv has col struct<a INT>
// after: cast to string in mv
CREATE MATERIALIZED VIEW mv2 AS SELECT col::VARCHAR AS col_str FROM mv;
CREATE SINK s FROM mv2 WITH (connector='sqlserver', ...);
Defensive patterns

Strategy: validation

Validate before calling

// Rust: reject unsupported types before creating the sink
fn has_unsupported_type(cols: &[Column]) -> bool {
    cols.iter().any(|c| matches!(c.data_type(),
        DataType::Struct(_) | DataType::List(_) | DataType::Bytea | DataType::Interval))
}

Type guard

fn is_supported(dt: &DataType) -> bool {
    !matches!(dt, DataType::Struct(_) | DataType::List(_) | DataType::Bytea | DataType::Interval)
}

Try / catch

if let Err(e) = create_sink(cfg).await {
    if e.to_string().contains("is not supported in SQL Server") {
        flatten_or_cast_offending_columns();
    } else { return Err(e); }
}

Prevention

When it happens

Trigger: Creating a SQL Server sink whose source table/materialized view contains a data type rejected by `check_data_type_compatibility` (e.g. Struct, List, Bytea, Interval, or similar complex types), or binding a row value of such a type during `bind_params`.

Common situations: Sinking a materialized view with nested struct/array columns to SQL Server; ingestion pipelines introduced a new RW type after the sink was set up; users expecting automatic JSON serialization of complex types.

Related errors

AI-assisted analysis of risingwavelabs/risingwave@6469eb736d (2026-09-11). Data as JSON: /api/errors/df734b7f1d8b3bb3. Report an issue: GitHub.