dbt-labs/dbt-core · error

{msg}

Error message

{msg}

What it means

ColumnStatic.from_description(name, raw_data_type) parses a raw Snowflake-style data type string into a Column. When the raw_data_type string cannot be parsed by try_from_snowflake_raw_data_type, the resulting message is wrapped as a minijinja InvalidArgument error. The message text comes directly from the parser, e.g. an unrecognized or malformed type such as an empty string or an unparseable compound type.

Solutions

1. Log/inspect the wrapped message (it is the raw parser msg) to see exactly which part of the type string failed.
2. Normalize the raw data type to a Snowflake-style form the parser understands (e.g. VARCHAR(10), NUMBER(38,0), TIMESTAMP_NTZ) before calling from_description.
3. Guard the call: validate raw_data_type is non-empty and matches a known type pattern before invoking.
4. Fall back to Column.create(name, dtype) with a generic type when the raw type cannot be represented.

Example fix

// before
{% set col = Column.from_description(name=col_name, raw_data_type='') %}
// after
{% set raw = col_type if col_type else 'VARCHAR' %}
{% set col = Column.from_description(name=col_name, raw_data_type=raw) %}

// Jinja: validate raw type before parsing
{% if not raw_data_type or raw_data_type is not string %}
  {{ exceptions.raise_compiler_error("from_description requires a non-empty raw_data_type string") }}
{% endif %}

fn looks_like_snowflake_type(s: &str) -> bool {
    !s.trim().is_empty() && s.chars().next().map(|c| c.is_ascii_alphabetic()).unwrap_or(false)
}

When it happens

Trigger: Calling `Column.from_description(name, raw_data_type)` with a raw_data_type that try_from_snowflake_raw_data_type rejects — e.g. empty string, a type string with unsupported syntax, or a struct/map/array type the Snowflake-style parser cannot decompose.

Common situations: Materializations that introspect warehouse catalogs and pass back a native type string in a dialect the parser does not handle (e.g. BigQuery GEOGRAPHY, Databricks complex types); custom SQL producing exotic types; passing None/empty because the source column metadata was missing.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

• {}
• Failed to downcast jinja value to Column; expected Column…
• Unknown method on ColumnStatic
• adapter not found in context
• adapter should be configured for the parse phase

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

Appendix: source

Thrown at crates/dbt-adapter/src/column/types.rs:302

            AdapterType::ClickHouse => "String".to_string(),
            _ => match size {
                Some(size) => format!("character varying({size})"),
                _ => "character varying".to_string(),
            },
        }
    }

    /// https://github.com/dbt-labs/dbt-adapters/blob/main/dbt-adapters/src/dbt/adapters/base/column.py#L127-L128
    #[expect(clippy::wrong_self_convention)]
    fn from_description(
        &self,
        name: &str,
        raw_data_type: &str,
    ) -> Result<Column, minijinja::Error> {
        // TODO(serramatutu): why is this Snowflake specific in non-Snowflake specific trait?
        // It seems like it is used by other adapters as well... (tested with BigQuery)
        let mut col = Column::try_from_snowflake_raw_data_type(name, raw_data_type)
            .map_err(|msg| minijinja::Error::new(minijinja::ErrorKind::InvalidArgument, msg))?;
        col._adapter_type = self.0;
        Ok(col)
    }

    /// https://github.com/databricks/dbt-databricks/blob/822b105b15e644676d9e1f47cbfd765cd4c1541f/dbt/adapters/databricks/column.py#L66
    fn dbx_format_add_column_list(
        self: &Arc<Self>,
        columns: &[Column],
    ) -> Result<String, minijinja::Error> {
        if self.0 != AdapterType::Databricks {
            unimplemented!("Only available for Databricks")
        };

        Ok(columns
            .iter()
            .map(|c| format!("{} {}", c.quoted(), c.core_dtype))
            .collect::<Vec<String>>()
            .join(", "))

View on GitHub (pinned to 0267ce9170)