{"record":{"id":"fd8f327ef8364e27","repo":"dbt-labs/dbt-core","slug":"unknown-method-on-column-name","errorCode":null,"errorMessage":"Unknown method on Column: '{name}'","messagePattern":"Unknown method on Column: '(.+?)'","errorType":"exception","errorClass":null,"httpStatus":null,"severity":"error","filePath":"crates/dbt-adapter/src/column/types.rs","lineNumber":1189,"sourceCode":"            })?)),\n            \"is_number\" => Ok(Value::from(self.is_number())),\n            \"is_float\" => Ok(Value::from(self.is_float())),\n            \"is_integer\" => Ok(Value::from(self.is_integer())),\n            \"is_numeric\" => Ok(Value::from(self.is_numeric())),\n            \"can_expand_to\" => {\n                // TODO(serramatutu): use ArgsIter\n                let mut parser = ArgParser::new(args, None);\n                check_num_args(current_function_name!(), &parser, 1, 1)?;\n                let other_raw = parser.get::<Value>(\"other_column\")?;\n                let other = Column::from_jinja_value(self._adapter_type, other_raw)?;\n                Ok(Value::from(self.can_expand_to(&other)?))\n            }\n            // Bigquery only\n            \"flatten\" => Ok(Value::from(self.flatten())),\n            // Databricks/Spark only - render column DDL for CREATE TABLE\n            \"render_for_create\" => Ok(Value::from(self.render_for_create())),\n\n            _ => Err(minijinja::Error::new(\n                minijinja::ErrorKind::UnknownMethod,\n                format!(\"Unknown method on Column: '{name}'\"),\n            )),\n        }\n    }\n\n    fn get_value(self: &Arc<Self>, key: &Value) -> Option<Value> {\n        match key.as_str() {\n            // @property methods\n            Some(\"name\") | Some(\"column\") => Some(Value::from(&self.name)),\n            Some(\"quoted\") => Some(Value::from(self.quoted())),\n            Some(\"data_type\") => Some(Value::from(self.data_type())),\n            // direct fields\n            Some(\"dtype\") => Some(Value::from(&self.core_dtype)),\n            Some(\"char_size\") => Some(Value::from(self.char_size)),\n            Some(\"numeric_precision\") => Some(Value::from(self.numeric_precision)),\n            Some(\"numeric_scale\") => Some(Value::from(self.numeric_scale)),\n            Some(\"collation\") => Some(Value::from(self.collation.as_deref())),","sourceCodeStart":1171,"sourceCodeEnd":1207,"githubUrl":"https://github.com/dbt-labs/dbt-core/blob/0267ce9170576975b76b64ce856b2e5848e96617/crates/dbt-adapter/src/column/types.rs#L1171-L1207","documentation":"Column implements minijinja's call_method with a fixed whitelist of method names (is_string, string_size, is_number, is_float, is_integer, is_numeric, can_expand_to, flatten, render_for_create, etc.). Calling any other method on a Column object from a template raises UnknownMethod with the message \"Unknown method on Column: '<name>'\".","triggerScenarios":"A Jinja template calls a method that does not exist on Column (typo like col.strings_size(), col.is_string_type(), or a Python dbt Column method that has not been ported to this Rust adapter).","commonSituations":"Migrating macros from Python dbt-core/adapters to the Rust engine: the Python Column class has more methods (e.g. is_string_with_limit, datatype, etc.) that are not implemented here, so established macros break with UnknownMethod.","solutions":["Check the exact method name against the whitelist in Column::call_method and fix the typo/name in the template.","Replace unported Python Column methods with supported equivalents (e.g. is_string/is_numeric) or inline the logic in the macro.","If the method is genuinely needed, implement it in Column::call_method in crates/dbt-adapter/src/column/types.rs.","Wrap dynamic method calls in Jinja with a check or default: use attribute inspection / try blocks where supported."],"exampleFix":"// before\n{% set dt = col.datatype() %}\n// after\n{% set dt = col.dtype() %} {# or a whitelisted method such as col.is_string() #}","handlingStrategy":"validation","validationCode":"{% set supported = ['is_string','string_size','is_number','is_float','is_integer','is_numeric','can_expand_to','flatten','render_for_create'] %}\n{% if not (method_name in supported) %}\n  {{ exceptions.raise_compiler_error('Column method not supported: ' ~ method_name) }}\n{% endif %}","typeGuard":null,"tryCatchPattern":"// call-site guard\nmatch column.call(name, args, &[]) {\n    Ok(v) => v,\n    Err(e) if e.kind() == minijinja::ErrorKind::UnknownMethod => fallback_value(),\n    Err(e) => return Err(e),\n}","preventionTips":["Audit macros migrated from Python dbt for Column methods not ported to the Rust adapter","Keep a reference list of supported Column methods during migration","Prefer whitelisted predicates (is_string, is_numeric, etc.) over Python-only helpers"],"tags":["jinja","minijinja","typo","adapter-api"],"backgroundTag":"unsupported-operation","analyzedSha":"0267ce9170576975b76b64ce856b2e5848e96617","analyzedAt":"2026-09-07T21:53:39.732Z","contentChangedAt":"2026-09-07T21:53:39.732Z","schemaVersion":2},"datasetVersion":"2026-09-17T15:17:12.973Z"}