risingwavelabs/risingwave · error · SinkError

Type {:?} is not supported for DeltaLake sink.

Error message

Type {:?} is not supported for DeltaLake sink.

What it means

`check_field_type` recursively compares RisingWave column types against the DeltaLake table schema. The match is implemented as an exhaustive match on `rw_data_type`, and any RisingWave data type that DeltaLake does not support (no matching arm) produces this DeltaLake error during sink validation.

Source

Thrown at src/connector/src/sink/deltalake.rs:366

                {
                    result = check_field_type(rw_type, dl_field.data_type())?
                        && result
                        && rw_name.eq(dl_field.name());
                }
                result
            } else {
                false
            }
        }
        DataType::List(rw_list) => {
            if let DeltaLakeDataType::Array(dl_list) = dl_data_type {
                check_field_type(rw_list.elem(), dl_list.element_type())?
            } else {
                false
            }
        }
        _ => {
            return Err(SinkError::DeltaLake(anyhow!(
                "Type {:?} is not supported for DeltaLake sink.",
                rw_data_type.to_owned()
            )));
        }
    };
    Ok(result)
}

impl Sink for DeltaLakeSink {
    type LogSinker = CoordinatedLogSinker<DeltaLakeSinkWriter>;

    const SINK_NAME: &'static str = DELTALAKE_SINK;

    crate::impl_validate_sink_unknown_fields!();

    fn is_exactly_once(properties: &BTreeMap<String, String>) -> Result<bool> {
        let Some(value) = properties.get("is_exactly_once") else {
            return Ok(false);

View on GitHub (pinned to 6469eb736d)

Solutions

1. Remove or transform unsupported columns before sinking (e.g. cast to supported types like VARCHAR)
2. Restructure the schema so nested fields only use supported types
3. Check RisingWave DeltaLake sink docs for the supported type list
4. Create a dedicated sink table/materialized view with only supported columns

Example fix

// before
CREATE SINK s FROM mv (INCLUDE map_col)
// after
CREATE SINK s FROM (SELECT map_col::VARCHAR AS map_col_str FROM mv)

fn assert_deltalake_supported(types: &[DataType]) -> Result<(), String> {
    const SUPPORTED: [DataType; 5] = [DataType::Boolean, DataType::Int32, DataType::Int64, DataType::Float64, DataType::Varchar];
    for t in types {
        if !SUPPORTED.contains(t) {
            return Err(format!("type {:?} not supported by DeltaLake sink", t));
        }
    }
    Ok(())
}

When it happens

Trigger: `CREATE SINK ... INTO deltalake` where the sink schema (or a nested struct/list field) contains a type not handled by check_field_type, e.g. map, interval, or other unsupported data types.

Common situations: Sinking a table with Map or Interval columns; nested struct containing an unsupported leaf type; upstream schema evolved to add an unsupported column after the sink was validated.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

• column '{}' type mismatch: deltalake type is {:?}, RisingWav
• Columns mismatch. RisingWave schema has {} fields, DeltaLake
• column {} not found in deltalake table
• Join key types are not aligned: LHS: {outer_type:?}, RHS: {i
• Join key types are not aligned: LHS: {outer_type:?}, RHS: {i

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