Generalize constraint warnings

.changes/unreleased/Under the Hood-20230331-132119.yaml

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: Generalize constraint compatibility warnings
+time: 2023-03-31T13:21:19.507995-05:00
+custom:
+  Author: emmyoop
+  Issue: "7067"

core/dbt/adapters/base/__init__.py

@@ -1,14 +1,19 @@
 # these are all just exports, #noqa them so flake8 will be happy
 
 # TODO: Should we still include this in the `adapters` namespace?
-from dbt.contracts.connection import Credentials  # noqa
-from dbt.adapters.base.meta import available  # noqa
-from dbt.adapters.base.connections import BaseConnectionManager  # noqa
-from dbt.adapters.base.relation import (  # noqa
+from dbt.contracts.connection import Credentials  # noqa: F401
+from dbt.adapters.base.meta import available  # noqa: F401
+from dbt.adapters.base.connections import BaseConnectionManager  # noqa: F401
+from dbt.adapters.base.relation import (  # noqa: F401
     BaseRelation,
     RelationType,
     SchemaSearchMap,
 )
-from dbt.adapters.base.column import Column  # noqa
-from dbt.adapters.base.impl import AdapterConfig, BaseAdapter, PythonJobHelper  # noqa
-from dbt.adapters.base.plugin import AdapterPlugin  # noqa
+from dbt.adapters.base.column import Column  # noqa: F401
+from dbt.adapters.base.impl import (  # noqa: F401
+    AdapterConfig,
+    BaseAdapter,
+    PythonJobHelper,
+    ConstraintSupport,
+)
+from dbt.adapters.base.plugin import AdapterPlugin  # noqa: F401

core/dbt/adapters/base/impl.py

@@ -2,6 +2,7 @@
 from concurrent.futures import as_completed, Future
 from contextlib import contextmanager
 from datetime import datetime
+from enum import Enum
 import time
 from itertools import chain
 from typing import (
@@ -16,6 +17,7 @@
     Set,
     Tuple,
     Type,
+    Union,
 )
 
 from dbt.contracts.graph.nodes import ColumnLevelConstraint, ConstraintType, ModelLevelConstraint
@@ -53,6 +55,8 @@
     CodeExecution,
     CodeExecutionStatus,
     CatalogGenerationError,
+    ConstraintNotSupported,
+    ConstraintNotEnforced,
 )
 from dbt.utils import filter_null_values, executor, cast_to_str, AttrDict
 
@@ -73,6 +77,12 @@
 FRESHNESS_MACRO_NAME = "collect_freshness"
 
 
+class ConstraintSupport(str, Enum):
+    ENFORCED = "enforced"
+    NOT_ENFORCED = "not_enforced"
+    NOT_SUPPORTED = "not_supported"
+
+
 def _expect_row_value(key: str, row: agate.Row):
     if key not in row.keys():
         raise DbtInternalError(
@@ -204,6 +214,14 @@ class BaseAdapter(metaclass=AdapterMeta):
     # for use in materializations
     AdapterSpecificConfigs: Type[AdapterConfig] = AdapterConfig
 
+    CONSTRAINT_SUPPORT = {
+        ConstraintType.check: ConstraintSupport.NOT_SUPPORTED,
+        ConstraintType.not_null: ConstraintSupport.ENFORCED,
+        ConstraintType.unique: ConstraintSupport.NOT_ENFORCED,
+        ConstraintType.primary_key: ConstraintSupport.NOT_ENFORCED,
+        ConstraintType.foreign_key: ConstraintSupport.ENFORCED,
+    }
+
     def __init__(self, config):
         self.config = config
         self.cache = RelationsCache()
@@ -1273,14 +1291,8 @@ def _parse_column_constraint(cls, raw_constraint: Dict[str, Any]) -> ColumnLevel
         except Exception:
             raise DbtValidationError(f"Could not parse constraint: {raw_constraint}")
 
-    @available
     @classmethod
-    def render_raw_column_constraint(cls, raw_constraint: Dict[str, Any]) -> str:
-        constraint = cls._parse_column_constraint(raw_constraint)
-        return cls.render_column_constraint(constraint)
-
-    @classmethod
-    def render_column_constraint(cls, constraint: ColumnLevelConstraint) -> str:
+    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.check and constraint.expression:
@@ -1296,7 +1308,46 @@ def render_column_constraint(cls, constraint: ColumnLevelConstraint) -> str:
         elif constraint.type == ConstraintType.custom and constraint.expression:
             return constraint.expression
         else:
-            return ""
+            return None
+
+    @available
+    @classmethod
+    def render_raw_columns_constraints(cls, raw_columns: Dict[str, Dict[str, Any]]) -> List:
+        rendered_column_constraints = []
+
+        for v in raw_columns.values():
+            rendered_column_constraint = [f"{v['name']} {v['data_type']}"]
+            for con in v.get("constraints", None):
+                constraint = cls._parse_column_constraint(con)
+                c = cls.process_parsed_constraint(constraint, cls.render_column_constraint)
+                if c is not None:
+                    rendered_column_constraint.append(c)
+            rendered_column_constraints.append(" ".join(rendered_column_constraint))
+
+        return rendered_column_constraints
+
+    @classmethod
+    def process_parsed_constraint(
+        cls, parsed_constraint: Union[ColumnLevelConstraint, ModelLevelConstraint], render_func
+    ) -> Optional[str]:
+        if (
+            parsed_constraint.warn_unsupported
+            and cls.CONSTRAINT_SUPPORT[parsed_constraint.type] == ConstraintSupport.NOT_SUPPORTED
+        ):
+            warn_or_error(
+                ConstraintNotSupported(constraint=parsed_constraint.type.value, adapter=cls.type())
+            )
+        if (
+            parsed_constraint.warn_unenforced
+            and cls.CONSTRAINT_SUPPORT[parsed_constraint.type] == ConstraintSupport.NOT_ENFORCED
+        ):
+            warn_or_error(
+                ConstraintNotEnforced(constraint=parsed_constraint.type.value, adapter=cls.type())
+            )
+        if cls.CONSTRAINT_SUPPORT[parsed_constraint.type] != ConstraintSupport.NOT_SUPPORTED:
+            return render_func(parsed_constraint)
+
+        return None
 
     @classmethod
     def _parse_model_constraint(cls, raw_constraint: Dict[str, Any]) -> ModelLevelConstraint:
@@ -1315,7 +1366,7 @@ def render_raw_model_constraints(cls, raw_constraints: List[Dict[str, Any]]) ->
     @classmethod
     def render_raw_model_constraint(cls, raw_constraint: Dict[str, Any]) -> Optional[str]:
         constraint = cls._parse_model_constraint(raw_constraint)
-        return cls.render_model_constraint(constraint)
+        return cls.process_parsed_constraint(constraint, cls.render_model_constraint)
 
     @classmethod
     def render_model_constraint(cls, constraint: ModelLevelConstraint) -> Optional[str]:

core/dbt/events/types.proto

@@ -796,6 +796,28 @@ message FinishedRunningStatsMsg {
     FinishedRunningStats data = 2;
 }
 
+// E048
+message ConstraintNotEnforced {
+    string constraint = 1;
+    string adapter = 2;
+}
+
+message ConstraintNotEnforcedMsg {
+    EventInfo info = 1;
+    ConstraintNotEnforced data = 2;
+}
+
+// E049
+message ConstraintNotSupported {
+    string constraint = 1;
+    string adapter = 2;
+}
+
+message ConstraintNotSupportedMsg {
+    EventInfo info = 1;
+    ConstraintNotSupported data = 2;
+}
+
 // I - Project parsing
 
 // I001

core/dbt/events/types.py

@@ -749,6 +749,32 @@ def message(self) -> str:
         return f"Finished running {self.stat_line}{self.execution} ({self.execution_time:0.2f}s)."
 
 
+class ConstraintNotEnforced(WarnLevel):
+    def code(self):
+        return "E048"
+
+    def message(self) -> str:
+        msg = (
+            f"The constraint type {self.constraint} is not enforced by {self.adapter}. "
+            "The constraint will be included in this model's DDL statement, but it will not "
+            "guarantee anything about the underlying data. Set 'warn_unenforced: false' on "
+            "this constraint to ignore this warning."
+        )
+        return line_wrap_message(warning_tag(msg))
+
+
+class ConstraintNotSupported(WarnLevel):
+    def code(self):
+        return "E049"
+
+    def message(self) -> str:
+        msg = (
+            f"The constraint type {self.constraint} is not supported by {self.adapter}, and will "
+            "be ignored. Set 'warn_unsupported: false' on this constraint to ignore this warning."
+        )
+        return line_wrap_message(warning_tag(msg))
+
+
 # =======================================================
 # I - Project parsing
 # =======================================================

core/dbt/include/global_project/macros/materializations/models/table/columns_spec_ddl.sql

@@ -8,21 +8,13 @@
 
 {% macro table_columns_and_constraints() %}
   {# loop through user_provided_columns to create DDL with data types and constraints #}
-    {%- set user_provided_columns = model['columns'] -%}
-    {%- set raw_model_constraints = adapter.render_raw_model_constraints(model['constraints']) -%}
+    {%- set raw_column_constraints = adapter.render_raw_columns_constraints(raw_columns=model['columns']) -%}
+    {%- set raw_model_constraints = adapter.render_raw_model_constraints(raw_constraints=model['constraints']) -%}
     (
-    {% for i in user_provided_columns %}
-      {%- set col = user_provided_columns[i] -%}
-      {%- set constraints = col['constraints'] -%}
-      {{ col['name'] }} {{ col['data_type'] }}
-      {%- for c in constraints -%}
-        {%- set constraint_str = adapter.render_raw_column_constraint(c) -%}
-        {%- if constraint_str -%}
-        {{ ' ' ~ constraint_str }}
-        {%- endif -%}
-      {%- endfor -%}{{ "," if not loop.last or raw_model_constraints }}
-    {% endfor -%}
-    {% for c in raw_model_constraints %}
+    {% for c in raw_column_constraints -%}
+      {{ c }}{{ "," if not loop.last or raw_model_constraints }}
+    {% endfor %}
+    {% for c in raw_model_constraints -%}
         {{ c }}{{ "," if not loop.last }}
     {% endfor -%}
     )

plugins/postgres/dbt/adapters/postgres/impl.py

@@ -2,12 +2,13 @@
 from dataclasses import dataclass
 from typing import Optional, Set, List, Any
 from dbt.adapters.base.meta import available
-from dbt.adapters.base.impl import AdapterConfig
+from dbt.adapters.base.impl import AdapterConfig, ConstraintSupport
 from dbt.adapters.sql import SQLAdapter
 from dbt.adapters.postgres import PostgresConnectionManager
 from dbt.adapters.postgres.column import PostgresColumn
 from dbt.adapters.postgres import PostgresRelation
 from dbt.dataclass_schema import dbtClassMixin, ValidationError
+from dbt.contracts.graph.nodes import ConstraintType
 from dbt.exceptions import (
     CrossDbReferenceProhibitedError,
     IndexConfigNotDictError,
@@ -64,6 +65,14 @@ class PostgresAdapter(SQLAdapter):
 
     AdapterSpecificConfigs = PostgresConfig
 
+    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):
         return "now()"

tests/functional/artifacts/expected_manifest.py

@@ -322,8 +322,8 @@ def expected_seeded_manifest(project, model_database=None, quote_model=False):
                         "constraints": [],
                     },
                 },
-                "constraints": [],
                 "contract": {"checksum": None, "enforced": False},
+                "constraints": [],
                 "patch_path": "test://" + model_schema_yml_path,
                 "docs": {"node_color": None, "show": False},
                 "compiled": True,
@@ -412,8 +412,8 @@ def expected_seeded_manifest(project, model_database=None, quote_model=False):
                         "constraints": [],
                     },
                 },
-                "constraints": [],
                 "contract": {"checksum": None, "enforced": False},
+                "constraints": [],
                 "patch_path": "test://" + model_schema_yml_path,
                 "docs": {"node_color": None, "show": False},
                 "compiled": True,

tests/unit/test_events.py

@@ -178,6 +178,8 @@ def test_event_codes(self):
     types.DatabaseErrorRunningHook(hook_type=""),
     types.HooksRunning(num_hooks=0, hook_type=""),
     types.FinishedRunningStats(stat_line="", execution="", execution_time=0),
+    types.ConstraintNotEnforced(constraint="", adapter=""),
+    types.ConstraintNotSupported(constraint="", adapter=""),
     # I - Project parsing ======================
     types.InputFileDiffError(category="testing", file_id="my_file"),
     types.InvalidValueForField(field_name="test", field_value="test"),