Support table-level check constraints

Author: mochaaP

CHANGELOG.md

@@ -7,6 +7,7 @@ project adheres to [Semantic Versioning][semver].
 
 ## Unreleased
 
+- added: Support check constraints via `Ecto.Migration.constraint/3`.
 - changed: Reimplement querying prefix names.
 - added: Raise on cross-database foreign keys.
 - changed: Made `quote_name/1` private.

lib/ecto/adapters/sqlite3.ex

@@ -160,22 +160,21 @@ defmodule Ecto.Adapters.SQLite3 do
   ### Check constraints
 
   SQLite3 supports specifying check constraints on the table or on the column definition.
-  We currently only support adding a check constraint via a column definition, since the
-  table definition approach only works at table-creation time and cannot be added at
-  table-alter time. You can see more information in the SQLite3
-  [CREATE TABLE documentation](https://sqlite.org/lang_createtable.html).
+  Table-alter time check constraints are supported since SQLite 3.53.0.
 
-  Because of this, you cannot add a constraint via the normal `Ecto.Migration.constraint/3`
-  method, as that operates via `ALTER TABLE ADD CONSTRAINT`, and this type of `ALTER TABLE`
-  operation SQLite3 does not support. You can however get the full functionality by
-  adding a constraint at the column level, specifying the name and expression. Per the
-  SQLite3 documentation, there is no _functional_ difference between a column or table
-  constraint.
+  Adding a constraint via `Ecto.Migration.constraint/3` is recommended for new projects.
+  Note that SQLite's `ADD CONSTRAINTS` verifies existing rows with `WHERE (check) IS NOT TRUE`,
+  so make sure your check is NULL-safe.
 
-  Thus, adding a check constraint for a new column is as simple as:
+  As an adapter-specific extension, the old way of adding column-level constraints is still
+  available:
 
       add :email, :string, check: %{name: "test_constraint", expr: "email != 'test@example.com'"}
 
+  Note that column-level constraints are slightly different than table-level constraints,
+  since `DROP COLUMN` can drop column-level constraints but not table-level constraints.
+  Drop the constraint first before dropping the column in those cases.
+
   ### Handling foreign key constraints in changesets
 
   Unfortunately, unlike other databases, SQLite3 does not provide the precise name of

lib/ecto/adapters/sqlite3/connection.ex

@@ -584,16 +584,40 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     raise ArgumentError, "SQLite3 adapter does not support keyword lists in execute"
   end
 
-  def execute_ddl({:create, %Constraint{}}) do
-    raise ArgumentError, "SQLite3 does not support ALTER TABLE ADD CONSTRAINT."
+  def execute_ddl({:create, %Constraint{check: check} = constraint})
+      when is_binary(check) do
+    [
+      [
+        "ALTER TABLE ",
+        quote_name(constraint.prefix, constraint.table),
+        " ADD",
+        new_constraint_expr(constraint)
+      ]
+    ]
+  end
+
+  def execute_ddl({:create, %Constraint{exclude: exclude}}) when is_binary(exclude) do
+    raise ArgumentError, "SQLite3 does not support exclusion constraints"
+  end
+
+  def execute_ddl({:drop, %Constraint{}, :cascade}) do
+    raise ArgumentError,
+          "SQLite3 does not support `CASCADE` in `DROP CONSTRAINT` commands"
   end
 
-  def execute_ddl({:drop, %Constraint{}, _mode}) do
-    raise ArgumentError, "SQLite3 does not support ALTER TABLE DROP CONSTRAINT."
+  def execute_ddl({:drop, %Constraint{} = constraint, _mode}) do
+    [
+      [
+        "ALTER TABLE ",
+        quote_name(constraint.prefix, constraint.table),
+        " DROP CONSTRAINT ",
+        quote_name(constraint.name)
+      ]
+    ]
   end
 
   def execute_ddl({:drop_if_exists, %Constraint{}, _mode}) do
-    raise ArgumentError, "SQLite3 does not support ALTER TABLE DROP CONSTRAINT."
+    raise ArgumentError, "SQLite3 does not support `drop_if_exists` for constraints"
   end
 
   def execute_ddl({:rename, %Index{} = index, new_index}) do
@@ -1671,6 +1695,13 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   defp null_expr(true), do: " NULL"
   defp null_expr(_), do: []
 
+  defp new_constraint_expr(%Constraint{validate: validate}) when validate == false do
+    raise ArgumentError, "SQLite3 does not support `validate: false` in constraints"
+  end
+
+  defp new_constraint_expr(%Constraint{check: check} = constraint)
+       when is_binary(check), do: check_expr(%{name: constraint.name, expr: check})
+
   defp default_expr({:ok, nil}) do
     " DEFAULT NULL"
   end

test/ecto/adapters/sqlite3/connection/migration_test.exs

@@ -2,7 +2,9 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
   use ExUnit.Case, async: true
 
   import Ecto.Adapters.SQLite3.TestHelpers
-  import Ecto.Migration, only: [table: 1, table: 2, index: 2, index: 3, constraint: 3]
+
+  import Ecto.Migration,
+    only: [table: 1, table: 2, index: 2, index: 3, constraint: 2, constraint: 3]
 
   alias Ecto.Migration.Reference
 
@@ -512,21 +514,95 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
     end
   end
 
-  test "drop constraint" do
+  test "create check constraint" do
+    create =
+      {:create, constraint(:products, "price_must_be_positive", check: "price > 0")}
+
+    assert execute_ddl(create) ==
+             [
+               ~s|ALTER TABLE "products" ADD CONSTRAINT "price_must_be_positive" CHECK (price > 0)|
+             ]
+
+    create =
+      {:create,
+       constraint(:products, "price_must_be_positive",
+         check: "price > 0",
+         prefix: "foo"
+       )}
+
+    assert execute_ddl(create) ==
+             [
+               ~s|ALTER TABLE "foo"."products" ADD CONSTRAINT "price_must_be_positive" CHECK (price > 0)|
+             ]
+  end
+
+  test "create exclusion constraint" do
+    assert_raise ArgumentError, "SQLite3 does not support exclusion constraints", fn ->
+      execute_ddl(
+        {:create,
+         constraint(:products, "price_must_be_positive",
+           exclude: ~s|gist (int4range("from", "to", '[]') WITH &&)|
+         )}
+      )
+    end
+  end
+
+  test "create constraint with comment" do
+    create =
+      {:create,
+       constraint(:products, "price_must_be_positive",
+         check: "price > 0",
+         prefix: "foo",
+         comment: "comment"
+       )}
+
+    assert execute_ddl(create) == [
+             ~s|ALTER TABLE "foo"."products" ADD CONSTRAINT "price_must_be_positive" CHECK (price > 0)|
+           ]
+
+    # NOTE: Comments are not supported by SQLite. DDL query generator will ignore them.
+  end
+
+  test "create invalid constraint" do
     assert_raise ArgumentError,
-                 ~r/SQLite3 does not support ALTER TABLE DROP CONSTRAINT./,
+                 "SQLite3 does not support `validate: false` in constraints",
                  fn ->
                    execute_ddl(
-                     {:drop,
-                      constraint(:products, "price_must_be_positive", prefix: :foo),
-                      :restrict}
+                     {:create,
+                      constraint(:products, "price_must_be_positive",
+                        check: "price > 0",
+                        prefix: "foo",
+                        validate: false
+                      )}
                    )
                  end
   end
 
+  test "drop constraint" do
+    drop =
+      {:drop, constraint(:products, "price_must_be_positive"), :restrict}
+
+    assert execute_ddl(drop) == [
+             ~s|ALTER TABLE "products" DROP CONSTRAINT "price_must_be_positive"|
+           ]
+
+    drop = {:drop, constraint(:products, "price_must_be_positive"), :cascade}
+
+    assert_raise ArgumentError,
+                 "SQLite3 does not support `CASCADE` in `DROP CONSTRAINT` commands",
+                 fn -> execute_ddl(drop) end
+
+    drop =
+      {:drop, constraint(:products, "price_must_be_positive", prefix: :foo), :restrict}
+
+    assert execute_ddl(drop) == [
+             ~s|ALTER TABLE "foo"."products" DROP CONSTRAINT "price_must_be_positive"|
+           ]
+  end
+
   test "drop_if_exists constraint" do
     assert_raise ArgumentError,
-                 ~r/SQLite3 does not support ALTER TABLE DROP CONSTRAINT./,
+                 "SQLite3 does not support `drop_if_exists` for constraints",
                  fn ->
                    execute_ddl(
                      {:drop_if_exists,