fix: Respect varchar and char when using describe extended as json (#1220)

### Description

Respect varchar/char, rather than casting to string, when information is
available.

### Checklist

- [x] I have run this code in development and it appears to resolve the
stated issue
- [x] This PR includes tests, or tests are not required/relevant for
this PR
- [x] I have updated the `CHANGELOG.md` and added information about my
change to the "dbt-databricks next" section.

---------

Co-authored-by: Claude <[email protected]>

Author: benc-db

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Fix issue causing MV/STs to always trigger as having their config changed ([1181](http://github.com/databricks/dbt-databricks/pull/1181))
 - Fix pydantic v2 deprecation warning "Valid config keys have changed in V2" (thanks @Korijn!) ([1194](https://github.com/databricks/dbt-databricks/pull/1194))
 - Fix snapshots not applying databricks_tags config ([1192](https://github.com/databricks/dbt-databricks/pull/1192))
+- Fix to respect varchar and char when using describe extended as json ([1220](https://github.com/databricks/dbt-databricks/pull/1220))
 
 ## dbt-databricks 1.10.12 (September 8, 2025)
 

dbt/adapters/databricks/column.py

@@ -64,10 +64,8 @@ def _parse_type_from_json(cls, type_info: Any) -> str:
           - map: nested types handled
           - decimal: precision, scale handled
           - string: collation handled
-          - varchar: Handled just in case, but the JSON should never contain a varchar type as
-                     these are just STRING types under the hood in Databricks.
-          - char: Handled just in case, but the JSON should never contain a char type as these are
-                  just STRING types under the hood in Databricks.
+          - varchar: length handled - preserves varchar(n) in DDL
+          - char: length handled - preserves char(n) in DDL
 
         Complex types can have other properties in the JSON schema such as nullable, defaults, etc.
         but those are ignored as they are not part of data type DDL
@@ -122,10 +120,16 @@ def _parse_type_from_json(cls, type_info: Any) -> str:
             return "timestamp"
 
         elif type_name == "varchar":
-            return "string"
+            length = type_info.get("length")
+            if length is not None:
+                return f"varchar({length})"
+            return "varchar"
 
         elif type_name == "char":
-            return "string"
+            length = type_info.get("length")
+            if length is not None:
+                return f"char({length})"
+            return "char"
 
         else:
             # Handle primitive types and any other types

tests/functional/adapter/columns/fixtures.py

@@ -23,3 +23,32 @@
       - name: struct_col
       - name: str_col
 """
+
+varchar_char_model = """
+{{
+  config(
+    materialized='table'
+  )
+}}
+select
+  'hello' as varchar_col,
+  'world' as char_col,
+  'regular string' as string_col
+"""
+
+varchar_char_schema = """
+version: 2
+models:
+  - name: varchar_char_model
+    config:
+        materialized: table
+        contract:
+          enforced: true
+    columns:
+      - name: varchar_col
+        data_type: varchar(50)
+      - name: char_col
+        data_type: char(10)
+      - name: string_col
+        data_type: string
+"""

tests/functional/adapter/columns/test_get_columns.py

@@ -4,6 +4,7 @@
 from dbt.adapters.databricks.relation import DatabricksRelation
 from dbt.tests import util
 from tests.functional.adapter.columns import fixtures
+from tests.functional.adapter.fixtures import MaterializationV2Mixin
 
 
 class ColumnsInRelation:
@@ -76,3 +77,39 @@ def test_columns_in_relation(self, project, expected_columns):
         with project.adapter.connection_named("_test"):
             actual_columns = project.adapter.get_columns_in_relation(my_relation)
         assert actual_columns == expected_columns
+
+
+class TestVarcharCharTypePreservation(MaterializationV2Mixin):
+    """Test that varchar and char types preserve their length constraints with mat v2."""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "varchar_char_model.sql": fixtures.varchar_char_model,
+            "schema.yml": fixtures.varchar_char_schema,
+        }
+
+    @pytest.fixture(scope="class", autouse=True)
+    def setup(self, project):
+        util.run_dbt(["debug", "--connection"])
+        util.run_dbt(["run"])
+
+    @pytest.fixture(scope="class")
+    def expected_columns(self):
+        return [
+            DatabricksColumn(column="varchar_col", dtype="varchar(50)"),
+            DatabricksColumn(column="char_col", dtype="char(10)"),
+            DatabricksColumn(column="string_col", dtype="string"),
+        ]
+
+    def test_varchar_char_columns(self, project, expected_columns):
+        my_relation = DatabricksRelation.create(
+            database=project.database,
+            schema=project.test_schema,
+            identifier="varchar_char_model",
+            type=DatabricksRelation.Table,
+        )
+
+        with project.adapter.connection_named("_test"):
+            actual_columns = project.adapter.get_columns_in_relation(my_relation)
+        assert actual_columns == expected_columns

tests/unit/test_column.py

@@ -130,6 +130,40 @@ def test_from_json_metadata_happy_path(self):
         assert result[2].dtype == "struct<field1:string,field2:int>"
         assert result[2].comment is None
 
+    def test_from_json_metadata_with_varchar_and_char(self):
+        """Test from_json_metadata properly handles varchar and char with length"""
+        json_metadata = json.dumps(
+            {
+                "columns": [
+                    {"name": "id", "type": {"name": "bigint"}, "comment": "Primary key"},
+                    {
+                        "name": "code",
+                        "type": {"name": "char", "length": 5},
+                        "comment": "Fixed code",
+                    },
+                    {
+                        "name": "description",
+                        "type": {"name": "varchar", "length": 100},
+                        "comment": "Variable description",
+                    },
+                ]
+            }
+        )
+
+        result = DatabricksColumn.from_json_metadata(json_metadata)
+
+        assert len(result) == 3
+        assert result[0].column == "id"
+        assert result[0].dtype == "bigint"
+
+        assert result[1].column == "code"
+        assert result[1].dtype == "char(5)"
+        assert result[1].comment == "Fixed code"
+
+        assert result[2].column == "description"
+        assert result[2].dtype == "varchar(100)"
+        assert result[2].comment == "Variable description"
+
     def test_from_json_metadata_empty_columns(self):
         """Test from_json_metadata with empty columns list"""
         json_metadata = json.dumps({"columns": []})
@@ -221,19 +255,29 @@ def test_parse_type_from_json_string_without_collation(self):
         result = DatabricksColumn._parse_type_from_json(type_info)
         assert result == "string"
 
-    def test_parse_type_from_json_varchar(self):
+    def test_parse_type_from_json_varchar_with_length(self):
         type_info = {"name": "varchar", "length": 10}
 
         result = DatabricksColumn._parse_type_from_json(type_info)
-        # varchar is just a string in Databricks
-        assert result == "string"
+        assert result == "varchar(10)"
 
-    def test_parse_type_from_json_char(self):
+    def test_parse_type_from_json_varchar_without_length(self):
+        type_info = {"name": "varchar"}
+
+        result = DatabricksColumn._parse_type_from_json(type_info)
+        assert result == "varchar"
+
+    def test_parse_type_from_json_char_with_length(self):
         type_info = {"name": "char", "length": 10}
 
         result = DatabricksColumn._parse_type_from_json(type_info)
-        # char is just a string in Databricks
-        assert result == "string"
+        assert result == "char(10)"
+
+    def test_parse_type_from_json_char_without_length(self):
+        type_info = {"name": "char"}
+
+        result = DatabricksColumn._parse_type_from_json(type_info)
+        assert result == "char"
 
     def test_parse_type_from_json_primitive_types(self):
         """Test _parse_type_from_json with various primitive types"""