Composite constraints

docs/src/piccolo/schema/advanced.rst

@@ -119,6 +119,8 @@ for example with :ref:`table_finder <TableFinder>`.
 
 -------------------------------------------------------------------------------
 
+.. _Mixins:
+
 Mixins
 ------
 
@@ -127,15 +129,37 @@ use mixins to reduce the amount of repetition.
 
 .. code-block:: python
 
-    from piccolo.columns import Varchar, Boolean
+    from piccolo.columns import Date, Varchar
     from piccolo.table import Table
 
 
-    class FavouriteMixin:
-        favourite = Boolean(default=False)
+    class DateOfBirthMixin:
+        date_of_birth = Date()
+
+
+    class Manager(DateOfBirthMixin, Table):
+        name = Varchar()
+
+You can also add :ref:`constraints <AdvancedConstraints>` to your mixin classes.
+
+.. code-block:: python
+
+    import datetime
+
+    from piccolo.columns import Varchar, Date
+    from piccolo.constraints import Check
+    from piccolo.table import Table
+
+
+    class DateOfBirthMixin:
+        date_of_birth = Date()
+
+        min_date_of_birth = Check(
+            date_of_birth >= datetime.date(year=1920, month=1, day=1)
+        )
 
 
-    class Manager(FavouriteMixin, Table):
+    class Manager(DateOfBirthMixin, Table):
         name = Varchar()
 
 -------------------------------------------------------------------------------

docs/src/piccolo/schema/constraints.rst

@@ -0,0 +1,50 @@
+===========
+Constraints
+===========
+
+Simple unique constraints
+=========================
+
+Unique constraints can be added to a single column using the ``unique=True``
+argument of ``Column``:
+
+.. code-block:: python
+
+    class Band(Table):
+        name = Varchar(unique=True)
+
+-------------------------------------------------------------------------------
+
+.. _AdvancedConstraints:
+
+Advanced constraints
+=====================
+
+You can add you can implement powerful ``UNIQUE`` and ``CHECK`` constraints
+on your ``Table``.
+
+``Unique``
+----------
+
+.. currentmodule:: piccolo.constraints
+
+.. autoclass:: Unique
+
+``Check``
+----------
+
+.. autoclass:: Check
+
+How are they created?
+---------------------
+
+If creating a new table using ``await MyTable.create_table()``, then the
+constraints will also be created.
+
+Also, if using auto migrations, they handle the creation and deletion of these
+constraints for you.
+
+Mixins
+------
+
+Constraints can be added to :ref:`mixin classes <Mixins>` for reusability.

docs/src/piccolo/schema/index.rst

@@ -8,6 +8,7 @@ The schema is how you define your database tables, columns and relationships.
 
     ./defining
     ./column_types
+    ./constraints
     ./m2m
     ./one_to_one
     ./advanced

piccolo/apps/migrations/auto/diffable_table.py

@@ -5,14 +5,17 @@
 
 from piccolo.apps.migrations.auto.operations import (
     AddColumn,
+    AddConstraint,
     AlterColumn,
     DropColumn,
+    DropConstraint,
 )
 from piccolo.apps.migrations.auto.serialisation import (
     deserialise_params,
     serialise_params,
 )
 from piccolo.columns.base import Column
+from piccolo.constraints import Constraint
 from piccolo.table import Table, create_table_class
 
 
@@ -62,6 +65,8 @@ class TableDelta:
     add_columns: t.List[AddColumn] = field(default_factory=list)
     drop_columns: t.List[DropColumn] = field(default_factory=list)
     alter_columns: t.List[AlterColumn] = field(default_factory=list)
+    add_constraints: t.List[AddConstraint] = field(default_factory=list)
+    drop_constraints: t.List[DropConstraint] = field(default_factory=list)
 
     def __eq__(self, value: TableDelta) -> bool:  # type: ignore
         """
@@ -92,6 +97,19 @@ def __eq__(self, value) -> bool:
         return False
 
 
+@dataclass
+class ConstraintComparison:
+    constraint: Constraint
+
+    def __hash__(self) -> int:
+        return self.constraint.__hash__()
+
+    def __eq__(self, value) -> bool:
+        if isinstance(value, ConstraintComparison):
+            return self.constraint._meta.name == value.constraint._meta.name
+        return False
+
+
 @dataclass
 class DiffableTable:
     """
@@ -103,6 +121,7 @@ class DiffableTable:
     tablename: str
     schema: t.Optional[str] = None
     columns: t.List[Column] = field(default_factory=list)
+    constraints: t.List[Constraint] = field(default_factory=list)
     previous_class_name: t.Optional[str] = None
 
     def __post_init__(self) -> None:
@@ -196,10 +215,54 @@ def __sub__(self, value: DiffableTable) -> TableDelta:
                     )
                 )
 
+        add_constraints = [
+            AddConstraint(
+                table_class_name=self.class_name,
+                constraint_name=i.constraint._meta.name,
+                constraint_class_name=i.constraint.__class__.__name__,
+                constraint_class=i.constraint.__class__,
+                params=i.constraint._meta.params,
+                schema=self.schema,
+            )
+            for i in sorted(
+                {
+                    ConstraintComparison(constraint=constraint)
+                    for constraint in self.constraints
+                }
+                - {
+                    ConstraintComparison(constraint=constraint)
+                    for constraint in value.constraints
+                },
+                key=lambda x: x.constraint._meta.name,
+            )
+        ]
+
+        drop_constraints = [
+            DropConstraint(
+                table_class_name=self.class_name,
+                constraint_name=i.constraint._meta.name,
+                tablename=value.tablename,
+                schema=self.schema,
+            )
+            for i in sorted(
+                {
+                    ConstraintComparison(constraint=constraint)
+                    for constraint in value.constraints
+                }
+                - {
+                    ConstraintComparison(constraint=constraint)
+                    for constraint in self.constraints
+                },
+                key=lambda x: x.constraint._meta.name,
+            )
+        ]
+
         return TableDelta(
             add_columns=add_columns,
             drop_columns=drop_columns,
             alter_columns=alter_columns,
+            add_constraints=add_constraints,
+            drop_constraints=drop_constraints,
         )
 
     def __hash__(self) -> int:
@@ -225,10 +288,14 @@ def to_table_class(self) -> t.Type[Table]:
         """
         Converts the DiffableTable into a Table subclass.
         """
+        class_members: t.Dict[str, t.Any] = {}
+        for column in self.columns:
+            class_members[column._meta.name] = column
+        for constraint in self.constraints:
+            class_members[constraint._meta.name] = constraint
+
         return create_table_class(
             class_name=self.class_name,
             class_kwargs={"tablename": self.tablename, "schema": self.schema},
-            class_members={
-                column._meta.name: column for column in self.columns
-            },
+            class_members=class_members,
         )