dbt-labs/dbt-core · error · minijinja::Error::InvalidOperation

describe_relation is not supported for relation type {other:

Error message

describe_relation is not supported for relation type {other:?} on Snowflake

What it means

Snowflake's `describe_relation` only supports describing tables of specific types (e.g. Table, View, DynamicTable, InteractiveTable). When the relation's type falls through the match arms, the adapter returns this InvalidOperation error formatting the unsupported relation type. The library throws it because there is no DESCRIBE strategy defined for that relation type on Snowflake.

Source

Thrown at crates/dbt-adapter/src/adapter/adapter_impl.rs:4894

    /// Return shapes deliberately differ: BigQuery returns a typed `RelationConfig`, Snowflake
    /// returns a raw `SHOW`-query readback.
    pub fn describe_relation(
        &self,
        state: &State,
        conn: &'_ mut dyn Connection,
        relation: &Arc<dyn BaseRelation>,
        include_transient: bool,
        token: CancellationToken,
    ) -> Result<Value, minijinja::Error> {
        if self.adapter_type() == Snowflake {
            match relation.relation_type() {
                Some(RelationType::DynamicTable) => {
                    self.describe_dynamic_table(state, conn, relation, include_transient, token)
                }
                Some(RelationType::InteractiveTable) => {
                    self.describe_interactive_table(state, conn, relation, token)
                }
                other => Err(minijinja::Error::new(
                    minijinja::ErrorKind::InvalidOperation,
                    format!(
                        "describe_relation is not supported for relation type {other:?} on Snowflake"
                    ),
                )),
            }
        } else {
            Ok(self
                .describe_relation_bigquery(conn, relation, Some(state))?
                .map(Value::from_object)
                .unwrap_or_else(none_value))
        }
    }

    /// BigQueryAdapter https://github.com/dbt-labs/dbt-adapters/blob/4a00354a497214d9043bf4122810fe2d04de17bb/dbt-bigquery/src/dbt/adapters/bigquery/impl.py#L818
    fn describe_relation_bigquery(
        &self,
        conn: &'_ mut dyn Connection,

View on GitHub (pinned to 0267ce9170)

Solutions

1. Log or print the relation type in the error message (`{other:?}`) to see exactly which type is unsupported
2. Restrict describe_relation calls to supported types (Table/View/DynamicTable/InteractiveTable) or filter such relations before caching
3. Upgrade the adapter if the relation is a newly supported Snowflake type (e.g. dynamic/interactive tables) that an older adapter lacks an arm for
4. Implement/extend the match in describe_relation to route the missing RelationType to the appropriate DESCRIBE path

Example fix

// before
Some(RelationType::InteractiveTable) => self.describe_interactive_table(state, conn, relation, token),
other => Err(...)
// after
Some(RelationType::InteractiveTable) => self.describe_interactive_table(state, conn, relation, token),
Some(RelationType::ExternalTable) => self.describe_standard_table(state, conn, relation, token),
other => Err(...)

// guard before calling describe_relation
match relation.relation_type {
    Some(RelationType::Table) | Some(RelationType::View) | Some(RelationType::DynamicTable) | Some(RelationType::InteractiveTable) => describe_relation(...),
    other => println!("skipping describe for unsupported relation type {other:?}"),
}

fn is_describable(rt: Option<RelationType>) -> bool {
    matches!(rt, Some(RelationType::Table) | Some(RelationType::View) | Some(RelationType::DynamicTable) | Some(RelationType::InteractiveTable))
}

match adapter.describe_relation(state, conn, relation, token) {
    Ok(cols) => cols,
    Err(e) if e.to_string().contains("describe_relation is not supported") => {
        eprintln!("skipping non-describable relation {:?}", relation);
        Vec::new()
    }
    Err(e) => return Err(e),
}

When it happens

Trigger: Calling `describe_relation` on a Snowflake relation whose RelationType matches the catch-all `other` arm — e.g. an external table, stage, stream, materialized view variant, or a relation with no/unknown type.

Common situations: Caching or introspection runs against a Snowflake object the adapter does not classify as a describable table (external/hybrid tables, iceberg tables), or a custom/older adapter version lacks the match arm for a newer Snowflake table kind.

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

• from_config: Only available for Snowflake and Redshift
• unknown table type: {type_string}
• parse_constraints: {e}
• valid regex
• column name normalization preserves schema compatibility

AI-assisted analysis of dbt-labs/dbt-core@0267ce9170 (2026-09-07). Data as JSON: /api/errors/51a3797555d1b7aa. Report an issue: GitHub.