Add support for model contracts in v1.5

dbt/adapters/duckdb/impl.py

@@ -8,12 +8,15 @@
 
 from dbt.adapters.base import BaseRelation
 from dbt.adapters.base.column import Column
+from dbt.adapters.base.impl import ConstraintSupport
 from dbt.adapters.base.meta import available
 from dbt.adapters.duckdb.connections import DuckDBConnectionManager
 from dbt.adapters.duckdb.glue import create_or_update_table
 from dbt.adapters.duckdb.relation import DuckDBRelation
 from dbt.adapters.sql import SQLAdapter
 from dbt.contracts.connection import AdapterResponse
+from dbt.contracts.graph.nodes import ColumnLevelConstraint
+from dbt.contracts.graph.nodes import ConstraintType
 from dbt.exceptions import DbtInternalError
 from dbt.exceptions import DbtRuntimeError
 
@@ -22,6 +25,14 @@ class DuckDBAdapter(SQLAdapter):
     ConnectionManager = DuckDBConnectionManager
     Relation = DuckDBRelation
 
+    CONSTRAINT_SUPPORT = {
+        ConstraintType.check: ConstraintSupport.ENFORCED,
+        ConstraintType.not_null: ConstraintSupport.ENFORCED,
+        ConstraintType.unique: ConstraintSupport.ENFORCED,
+        ConstraintType.primary_key: ConstraintSupport.ENFORCED,
+        ConstraintType.foreign_key: ConstraintSupport.ENFORCED,
+    }
+
     @classmethod
     def date_function(cls) -> str:
         return "now()"
@@ -176,6 +187,28 @@ def get_rows_different_sql(
         )
         return sql
 
+    @available.parse(lambda *a, **k: [])
+    def get_column_schema_from_query(self, sql: str) -> List[Column]:
+        """Get a list of the Columns with names and data types from the given sql."""
+        _, cursor = self.connections.add_select_query(sql)
+        columns = [
+            # duckdb returns column_type as a string, rather than int (code)
+            self.Column.create(column_name, column_type_name)
+            # https://peps.python.org/pep-0249/#description
+            for column_name, column_type_name, *_ in cursor.description
+        ]
+        return columns
+
+    @classmethod
+    def render_column_constraint(cls, constraint: ColumnLevelConstraint) -> Optional[str]:
+        """Render the given constraint as DDL text. Should be overriden by adapters which need custom constraint
+        rendering."""
+        if constraint.type == ConstraintType.foreign_key:
+            # DuckDB doesn't support 'foreign key' as an alias
+            return f"references {constraint.expression}"
+        else:
+            return super().render_column_constraint(constraint)
+
 
 # Change `table_a/b` to `table_aaaaa/bbbbb` to avoid duckdb binding issues when relation_a/b
 # is called "table_a" or "table_b" in some of the dbt tests

dbt/include/duckdb/macros/adapters.sql

@@ -28,17 +28,42 @@
   {{ return(run_query(sql)) }}
 {% endmacro %}
 
+{% macro get_column_names() %}
+  {# loop through user_provided_columns to get column names #}
+    {%- set user_provided_columns = model['columns'] -%}
+    (
+    {% for i in user_provided_columns %}
+      {% set col = user_provided_columns[i] %}
+      {{ col['name'] }} {{ "," if not loop.last }}
+    {% endfor %}
+  )
+{% endmacro %}
+
+
 {% macro duckdb__create_table_as(temporary, relation, compiled_code, language='sql') -%}
   {%- if language == 'sql' -%}
+    {% set contract_config = config.get('contract') %}
+    {% if contract_config.enforced %}
+      {{ get_assert_columns_equivalent(compiled_code) }}
+    {% endif %}
     {%- set sql_header = config.get('sql_header', none) -%}
 
     {{ sql_header if sql_header is not none }}
 
     create {% if temporary: -%}temporary{%- endif %} table
       {{ relation.include(database=(not temporary and adapter.use_database()), schema=(not temporary)) }}
+  {% if contract_config.enforced and not temporary %}
+    {#-- DuckDB doesnt support constraints on temp tables --#}
+    {{ get_table_columns_and_constraints() }} ;
+    insert into {{ relation }} {{ get_column_names() }} (
+      {{ compiled_code }}
+    );
+    {%- set compiled_code = get_select_subquery(compiled_code) %}
+  {% else %}
     as (
       {{ compiled_code }}
     );
+  {% endif %}
   {%- elif language == 'python' -%}
     {{ py_write_table(temporary=temporary, relation=relation, compiled_code=compiled_code) }}
   {%- else -%}
@@ -62,6 +87,10 @@ def materialize(df, con):
 {% endmacro %}
 
 {% macro duckdb__create_view_as(relation, sql) -%}
+  {% set contract_config = config.get('contract') %}
+  {% if contract_config.enforced %}
+    {{ get_assert_columns_equivalent(sql) }}
+  {%- endif %}
   {%- set sql_header = config.get('sql_header', none) -%}
 
   {{ sql_header if sql_header is not none }}

tests/functional/adapter/test_constraints.py

@@ -0,0 +1,71 @@
+import pytest
+
+class DuckDBColumnEqualSetup:
+    @pytest.fixture
+    def int_type(self):
+        return "NUMBER"
+
+    @pytest.fixture
+    def schema_int_type(self):
+        return "INT"
+
+    @pytest.fixture
+    def data_types(self, schema_int_type, int_type, string_type):
+        # sql_column_value, schema_data_type, error_data_type
+        return [
+            # DuckDB's cursor doesn't seem to distinguish between:
+            #   INT and NUMERIC/DECIMAL -- both just return as 'NUMBER'
+            #   TIMESTAMP and TIMESTAMPTZ -- both just return as 'DATETIME'
+            #   [1,2,3] and ['a','b','c'] -- both just return as 'list'
+
+            ["1", schema_int_type, int_type],
+            ["'1'", string_type, string_type],
+            ["true", "bool", "bool"],
+            ["'2013-11-03 00:00:00-07'::timestamptz", "timestamptz", "DATETIME"],
+            ["'2013-11-03 00:00:00-07'::timestamp", "timestamp", "DATETIME"],
+            ["ARRAY['a','b','c']", "text[]", "list"],
+            ["ARRAY[1,2,3]", "int[]", "list"],
+            #["'1'::numeric", "numeric", "DECIMAL"],    -- no distinction, noted above
+            ["""{'bar': 'baz', 'balance': 7.77, 'active': false}""", "struct(bar text, balance decimal, active boolean)", "dict"],
+        ]
+
+
+class TestTableConstraintsColumnsEqual(DuckDBColumnEqualSetup, BaseTableConstraintsColumnsEqual):
+    pass
+
+
+class TestViewConstraintsColumnsEqual(DuckDBColumnEqualSetup, BaseViewConstraintsColumnsEqual):
+    pass
+
+
+class TestIncrementalConstraintsColumnsEqual(DuckDBColumnEqualSetup, BaseIncrementalConstraintsColumnsEqual):
+    pass
+
+
+class TestTableConstraintsRuntimeDdlEnforcement(DuckDBColumnEqualSetup, BaseConstraintsRuntimeDdlEnforcement):
+    pass
+
+
+class TestTableConstraintsRollback(BaseConstraintsRollback):
+    @pytest.fixture(scope="class")
+    def expected_error_messages(self):
+        return ["NOT NULL constraint failed"]
+
+
+class TestIncrementalConstraintsRuntimeDdlEnforcement(
+    BaseIncrementalConstraintsRuntimeDdlEnforcement
+):
+    @pytest.fixture(scope="class")
+    def expected_error_messages(self):
+        return ["NOT NULL constraint failed"]
+
+
+class TestIncrementalConstraintsRollback(BaseIncrementalConstraintsRollback):
+    @pytest.fixture(scope="class")
+    def expected_error_messages(self):
+        return ["NOT NULL constraint failed"]
+
+class TestModelConstraintsRuntimeEnforcement(BaseModelConstraintsRuntimeEnforcement):
+    @pytest.fixture(scope="class")
+    def expected_error_messages(self):
+        return ["NOT NULL constraint failed"]