feat(schema-engine): CHECK and EXCLUDE constraints stopgap for Postgres

schema-engine/connectors/sql-schema-connector/src/datamodel_calculator/context/flavour.rs

@@ -57,4 +57,8 @@ pub(crate) trait IntrospectionFlavour {
     ) -> bool {
         false
     }
+
+    fn uses_exclude_constraint(&self, _ctx: &DatamodelCalculatorContext<'_>, _table: TableWalker<'_>) -> bool {
+        false
+    }
 }

schema-engine/connectors/sql-schema-connector/src/datamodel_calculator/context/flavour/postgresql.rs

@@ -14,6 +14,8 @@ impl super::IntrospectionFlavour for PostgresIntrospectionFlavour {
     }
 
     fn generate_warnings(&self, ctx: &DatamodelCalculatorContext<'_>, warnings: &mut Warnings) {
+        let pg_ext: &PostgresSchemaExt = ctx.sql_schema.downcast_connector_data();
+
         for table in ctx.sql_schema.table_walkers() {
             for index in table.indexes() {
                 for column in index.columns().filter(|c| self.uses_non_default_null_position(ctx, *c)) {
@@ -46,6 +48,15 @@ impl super::IntrospectionFlavour for PostgresIntrospectionFlavour {
                     model: ctx.table_prisma_name(table.id).prisma_name().to_string(),
                 });
             }
+
+            for constraint in pg_ext.exclude_constraints(table.id) {
+                let exclusion_constraint = ModelAndConstraint {
+                    model: ctx.table_prisma_name(table.id).prisma_name().to_string(),
+                    constraint: constraint.to_string(),
+                };
+
+                warnings.exclusion_constraints.push(exclusion_constraint);
+            }
         }
     }
 
@@ -80,4 +91,9 @@ impl super::IntrospectionFlavour for PostgresIntrospectionFlavour {
 
         pg_ext.non_default_null_position(column)
     }
+
+    fn uses_exclude_constraint(&self, ctx: &DatamodelCalculatorContext<'_>, table: TableWalker<'_>) -> bool {
+        let pg_ext: &PostgresSchemaExt = ctx.sql_schema.downcast_connector_data();
+        pg_ext.uses_exclude_constraint(table.id)
+    }
 }

schema-engine/connectors/sql-schema-connector/src/introspection_pair/model.rs

@@ -57,6 +57,21 @@ impl<'a> ModelPair<'a> {
         self.next.has_row_level_security()
     }
 
+    /// Whether the model has check constraints.
+    pub(crate) fn adds_check_constraints(self) -> bool {
+        self.previous.is_none() && self.next.has_check_constraints()
+    }
+
+    /// The names of check constraints for this model.
+    pub(crate) fn check_constraints(self) -> impl Iterator<Item = &'a str> {
+        self.next.check_constraints()
+    }
+
+    /// Whether the model has exclusion constraints.
+    pub(crate) fn adds_exclusion_constraints(self) -> bool {
+        self.previous.is_none() && self.context.flavour.uses_exclude_constraint(self.context, self.next)
+    }
+
     /// True, if we add a new model with row level security enabled.
     pub(crate) fn adds_row_level_security(self) -> bool {
         self.previous.is_none() && self.has_row_level_security()

schema-engine/connectors/sql-schema-connector/src/rendering/models.rs

@@ -58,6 +58,18 @@ fn render_model(model: ModelPair<'_>, sql_family: SqlFamily) -> renderer::Model<
         rendered.documentation(docs);
     }
 
+    if model.adds_check_constraints() {
+        let docs = "This table contains check constraints and requires additional setup for migrations. Visit https://pris.ly/d/postgres-check-constraints for more info.";
+
+        rendered.documentation(docs);
+    }
+
+    if model.adds_exclusion_constraints() {
+        let docs = "This table contains exclusion constraints and requires additional setup for migrations. Visit https://pris.ly/d/postgres-exclusion-constraints for more info.";
+
+        rendered.documentation(docs);
+    }
+
     if let Some(namespace) = model.namespace() {
         rendered.schema(namespace);
     }

schema-engine/connectors/sql-schema-connector/src/warnings/generators.rs

@@ -57,6 +57,10 @@ pub(crate) struct Warnings {
     pub(crate) non_default_index_null_sort_order: Vec<IndexedColumn>,
     /// Warn about using row level security, which is currently unsupported.
     pub(crate) row_level_security_tables: Vec<Model>,
+    /// Warn about check constraints.
+    pub(crate) check_constraints: Vec<ModelAndConstraint>,
+    /// Warn about exclusion constraints.
+    pub(crate) exclusion_constraints: Vec<ModelAndConstraint>,
     /// Warn about row level TTL
     pub(crate) row_level_ttl: Vec<Model>,
     /// Warn about non-default unique deferring setup
@@ -218,6 +222,14 @@ impl Warnings {
             &mut self.warnings,
         );
 
+        maybe_warn(&self.check_constraints, check_constraints_found, &mut self.warnings);
+
+        maybe_warn(
+            &self.exclusion_constraints,
+            exclusion_constraints_found,
+            &mut self.warnings,
+        );
+
         maybe_warn(&self.row_level_ttl, row_level_ttl_in_tables, &mut self.warnings);
         maybe_warn(&self.non_default_deferring, non_default_deferring, &mut self.warnings);
         maybe_warn(&self.objects_with_comments, commented_objects, &mut self.warnings);
@@ -600,6 +612,26 @@ pub(crate) fn row_level_ttl_in_tables(affected: &[Model]) -> Warning {
     }
 }
 
+pub(crate) fn check_constraints_found(affected: &[ModelAndConstraint]) -> Warning {
+    let message = "These constraints are not supported by the Prisma Client, because Prisma currently does not fully support check constraints. Read more: https://pris.ly/d/postgres-check-constraints";
+
+    Warning {
+        code: 33,
+        message: message.into(),
+        affected: serde_json::to_value(affected).unwrap(),
+    }
+}
+
+pub(crate) fn exclusion_constraints_found(affected: &[ModelAndConstraint]) -> Warning {
+    let message = "These constraints are not supported by the Prisma Client, because Prisma currently does not fully support exclusion constraints. Read more: https://pris.ly/d/postgres-exclusion-constraints";
+
+    Warning {
+        code: 34,
+        message: message.into(),
+        affected: serde_json::to_value(affected).unwrap(),
+    }
+}
+
 pub(crate) fn non_default_deferring(affected: &[ModelAndConstraint]) -> Warning {
     let message = "These primary key, foreign key or unique constraints are using non-default deferring in the database, which is not yet fully supported. Read more: https://pris.ly/d/constraint-deferring";
 

schema-engine/connectors/sql-schema-connector/src/warnings/model.rs

@@ -58,6 +58,13 @@ pub(super) fn generate_warnings(model: ModelPair<'_>, warnings: &mut Warnings) {
         })
     }
 
+    for constraint in model.check_constraints() {
+        warnings.check_constraints.push(generators::ModelAndConstraint {
+            model: model.name().to_string(),
+            constraint: constraint.to_string(),
+        })
+    }
+
     for field in model.scalar_fields() {
         if let Some(DefaultKind::Prisma1Uuid) = field.default().kind() {
             let warn = generators::ModelAndField {