dbt Constraints / model contracts

core/dbt/contracts/graph/model_config.py

@@ -446,6 +446,7 @@ class NodeConfig(NodeAndTestConfig):
         default_factory=Docs,
         metadata=MergeBehavior.Update.meta(),
     )
+    constraints_enabled: Optional[bool] = False
 
     # we validate that node_color has a suitable value to prevent dbt-docs from crashing
     def __post_init__(self):

core/dbt/contracts/graph/parsed.py

@@ -17,6 +17,7 @@
 
 from dbt.dataclass_schema import dbtClassMixin, ExtensibleDbtClassMixin
 
+from dbt.exceptions import CompilationException
 from dbt.clients.system import write_file
 from dbt.contracts.files import FileHash
 from dbt.contracts.graph.unparsed import (
@@ -70,6 +71,8 @@ class ColumnInfo(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable
     description: str = ""
     meta: Dict[str, Any] = field(default_factory=dict)
     data_type: Optional[str] = None
+    constraint: Optional[str] = None
+    check: Optional[str] = None
     quote: Optional[bool] = None
     tags: List[str] = field(default_factory=list)
     _extra: Dict[str, Any] = field(default_factory=dict)
@@ -222,7 +225,33 @@ class ParsedNodeDefaults(NodeInfoMixin, ParsedNodeMandatory):
     created_at: float = field(default_factory=lambda: time.time())
     config_call_dict: Dict[str, Any] = field(default_factory=dict)
 
+    def constraints_validator(self):
+        materialization_error = {}
+        language_error = {}
+        data_type_errors = {}
+
+        if self.resource_type == "model" and self.config.constraints_enabled is True:
+            if self.config.materialized != "table":
+                materialization_error = {"materialization": self.config.materialized}
+
+            language = str(self.language)
+            if language != "sql":
+                language_error = {"language": language}
+
+            for column, column_info in self.columns.items():
+                if column_info.data_type is None:
+                    data_type_error = {column: {"data_type": column_info.data_type}}
+                    data_type_errors.update(data_type_error)
+
+        if materialization_error or language_error or data_type_errors:
+            raise CompilationException(
+                f"Only the SQL table materialization is supported for constraints and data_type values must NOT be null or blank.\n  Materialization Error: {materialization_error}\n  Language Error: {language_error}\n  Data Type Errors: {data_type_errors}"
+            )
+
+    # TODO: this is where we see the columninfo object display the data_type and constraint values
     def write_node(self, target_path: str, subdirectory: str, payload: str):
+        self.constraints_validator()
+
         if os.path.basename(self.path) == os.path.basename(self.original_file_path):
             # One-to-one relationship of nodes to files.
             path = self.original_file_path

core/dbt/contracts/graph/unparsed.py

@@ -93,6 +93,8 @@ class HasDocs(AdditionalPropertiesMixin, ExtensibleDbtClassMixin, Replaceable):
     description: str = ""
     meta: Dict[str, Any] = field(default_factory=dict)
     data_type: Optional[str] = None
+    constraint: Optional[str] = None
+    check: Optional[str] = None
     docs: Docs = field(default_factory=Docs)
     _extra: Dict[str, Any] = field(default_factory=dict)
 

core/dbt/exceptions.py

@@ -1000,6 +1000,12 @@ def warn(msg, node=None):
     return ""
 
 
+# TODO: remove this later as Sung created this to avoid errors with running dbt-snowflake==1.3.0
+def warn_or_error(msg, node=None):
+    dbt.events.functions.warn_or_error(GeneralMacroWarning(msg=msg), node=node)
+    return ""
+
+
 # Update this when a new function should be added to the
 # dbt context's `exceptions` key!
 CONTEXT_EXPORTS = {

core/dbt/parser/base.py

@@ -305,6 +305,13 @@ def update_parsed_node_config(
             else:
                 parsed_node.docs = Docs(show=docs_show)
 
+        # TODO: Do I need this here similar to what we did for node_color above?
+        # If we have constraints_enabled in the config, copy to node level, for backwards
+        # compatibility with earlier node-only config.
+        # if "constraints_enabled" in config_dict and config_dict["constraints_enabled"]:
+        #     parsed_node.constraints_enabled = config_dict["constraints_enabled"]
+        #     print("constraints_enabled: {}".format(parsed_node.constraints_enabled))
+
         # unrendered_config is used to compare the original database/schema/alias
         # values and to handle 'same_config' and 'same_contents' calls
         parsed_node.unrendered_config = config.build_config_dict(

core/dbt/parser/generic_test_builders.py

@@ -180,6 +180,7 @@ def from_test_block(
         )
 
 
+# TODO: create a ConstraintsBuilder equivalent
 class TestBuilder(Generic[Testable]):
     """An object to hold assorted test settings and perform basic parsing
 
@@ -194,6 +195,7 @@ class TestBuilder(Generic[Testable]):
         r"((?P<test_namespace>([a-zA-Z_][0-9a-zA-Z_]*))\.)?"
         r"(?P<test_name>([a-zA-Z_][0-9a-zA-Z_]*))"
     )
+    # TODO: add config args like: "default", "data_type", "constraint", "check"
     # args in the test entry representing test configs
     CONFIG_ARGS = (
         "severity",

core/dbt/parser/models.py

@@ -177,6 +177,21 @@ def verify_python_model_code(node):
         raise ParsingException("No jinja in python model code is allowed", node=node)
 
 
+# TODO: Do we need to do this?
+# def verify_model_constraints(node):
+#     try:
+#         rendered_model = get_rendered(
+#             node.raw_code,
+#             {},
+#             node,
+#         )
+#         print(rendered_model)
+#         if rendered_model != node.raw_code:
+#             raise ParsingException("")
+#     except (UndefinedMacroException, ParsingException):
+#         raise ParsingException("No jinja in python model code is allowed", node=node)
+
+
 class ModelParser(SimpleSQLParser[ParsedModelNode]):
     def parse_from_dict(self, dct, validate=True) -> ParsedModelNode:
         if validate:

core/dbt/parser/schemas.py

@@ -132,6 +132,8 @@ def add(
         column: Union[HasDocs, UnparsedColumn],
         description: str,
         data_type: Optional[str],
+        constraint: Optional[str],
+        check: Optional[str],
         meta: Dict[str, Any],
     ):
         tags: List[str] = []
@@ -145,6 +147,8 @@ def add(
             name=column.name,
             description=description,
             data_type=data_type,
+            constraint=constraint,
+            check=check,
             meta=meta,
             tags=tags,
             quote=quote,
@@ -157,8 +161,10 @@ def from_target(cls, target: Union[HasColumnDocs, HasColumnTests]) -> "ParserRef
         for column in target.columns:
             description = column.description
             data_type = column.data_type
+            constraint = column.constraint
+            check = column.check
             meta = column.meta
-            refs.add(column, description, data_type, meta)
+            refs.add(column, description, data_type, constraint, check, meta)
         return refs
 
 
@@ -168,6 +174,7 @@ def _trimmed(inp: str) -> str:
     return inp[:44] + "..." + inp[-3:]
 
 
+# TODO: I'll likely need to add a ConstraintsBuilder class similar to TestBuilder within SchemaParser. Test Comment
 class SchemaParser(SimpleParser[GenericTestBlock, ParsedGenericTestNode]):
     def __init__(
         self,
@@ -310,6 +317,7 @@ def _parse_generic_test(
             raise CompilationException(msg) from exc
 
         original_name = os.path.basename(target.original_file_path)
+        # print(f"original_name: {original_name}")
         compiled_path = get_pseudo_test_path(builder.compiled_name, original_name)
 
         # fqn is the relative path of the yaml file where this generic test is defined,

schemas/dbt/manifest/v8.json

@@ -585,6 +585,10 @@
           "type": "boolean",
           "default": true
         },
+        "constraints_enabled": {
+          "type": "boolean",
+          "default": false
+        },
         "alias": {
           "oneOf": [
             {
@@ -830,6 +834,26 @@
             }
           ]
         },
+        "constraint": {
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "check": {
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "quote": {
           "oneOf": [
             {
@@ -849,7 +873,7 @@
         }
       },
       "additionalProperties": true,
-      "description": "ColumnInfo(name: str, description: str = '', meta: Dict[str, Any] = <factory>, data_type: Optional[str] = None, quote: Optional[bool] = None, tags: List[str] = <factory>, _extra: Dict[str, Any] = <factory>)"
+      "description": "ColumnInfo(name: str, description: str = '', meta: Dict[str, Any] = <factory>, data_type: Optional[str] = None, constraint: Optional[str] = None, check: Optional[str] = None, quote: Optional[bool] = None, tags: List[str] = <factory>, _extra: Dict[str, Any] = <factory>)"
     },
     "InjectedCTE": {
       "type": "object",