migration: Add CASCADE option to DROP command (#298)

Author: mpotra

lib/ecto/adapter/migration.ex

@@ -16,12 +16,12 @@ defmodule Ecto.Adapter.Migration do
           | {:create, Table.t(), [table_subcommand]}
           | {:create_if_not_exists, Table.t(), [table_subcommand]}
           | {:alter, Table.t(), [table_subcommand]}
-          | {:drop, Table.t()}
-          | {:drop_if_exists, Table.t()}
+          | {:drop, Table.t(), :restrict | :cascade | nil}
+          | {:drop_if_exists, Table.t(), :restrict | :cascade | nil}
           | {:create, Index.t()}
           | {:create_if_not_exists, Index.t()}
-          | {:drop, Index.t()}
-          | {:drop_if_exists, Index.t()}
+          | {:drop, Index.t(), :restrict | :cascade | nil}
+          | {:drop_if_exists, Index.t(), :restrict | :cascade | nil}
 
   @typedoc "All commands allowed within the block passed to `table/2`"
   @type table_subcommand ::

lib/ecto/adapters/myxql/connection.ex

@@ -730,7 +730,12 @@ if Code.ensure_loaded?(MyXQL) do
         engine_expr(table.engine), options_expr(table.options)]]
     end
 
-    def execute_ddl({command, %Table{} = table}) when command in [:drop, :drop_if_exists] do
+    def execute_ddl({command, %Table{} = table, :cascade}) when command in [:drop, :drop_if_exists] do
+      [cmd | _] = execute_ddl({command, %Table{} = table, nil})
+      [cmd ++ [" CASCADE"]]
+    end
+
+    def execute_ddl({command, %Table{} = table, _}) when command in [:drop, :drop_if_exists] do
       [["DROP TABLE ", if_do(command == :drop_if_exists, "IF EXISTS "),
         quote_table(table.prefix, table.name)]]
     end
@@ -762,20 +767,23 @@ if Code.ensure_loaded?(MyXQL) do
     def execute_ddl({:create, %Constraint{exclude: exclude}}) when is_binary(exclude),
       do: error!(nil, "MySQL adapter does not support exclusion constraints")
 
-    def execute_ddl({:drop, %Index{} = index}) do
+    def execute_ddl({:drop, %Index{}, :cascade}),
+      do: error!(nil, "MySQL adapter does not support cascade in drop index")
+
+    def execute_ddl({:drop, %Index{} = index, _}) do
       [["DROP INDEX ",
         quote_name(index.name),
         " ON ", quote_table(index.prefix, index.table),
         if_do(index.concurrently, " LOCK=NONE")]]
     end
 
-    def execute_ddl({:drop, %Constraint{}}),
+    def execute_ddl({:drop, %Constraint{}, _}),
       do: error!(nil, "MySQL adapter does not support constraints")
 
-    def execute_ddl({:drop_if_exists, %Constraint{}}),
+    def execute_ddl({:drop_if_exists, %Constraint{}, _}),
       do: error!(nil, "MySQL adapter does not support constraints")
 
-    def execute_ddl({:drop_if_exists, %Index{}}),
+    def execute_ddl({:drop_if_exists, %Index{}, _}),
       do: error!(nil, "MySQL adapter does not support drop if exists for index")
 
     def execute_ddl({:rename, %Table{} = current_table, %Table{} = new_table}) do

lib/ecto/adapters/postgres/connection.ex

@@ -845,7 +845,12 @@ if Code.ensure_loaded?(Postgrex) do
         comments_for_columns(table_name, columns)
     end
 
-    def execute_ddl({command, %Table{} = table}) when command in @drops do
+    def execute_ddl({command, %Table{} = table, :cascade}) when command in @drops do
+      [cmd | _] = execute_ddl({command, table, nil})
+      [cmd ++ [" CASCADE"]]
+    end
+
+    def execute_ddl({command, %Table{} = table, _}) when command in @drops do
       [["DROP TABLE ", if_do(command == :drop_if_exists, "IF EXISTS "),
         quote_table(table.prefix, table.name)]]
     end
@@ -880,7 +885,12 @@ if Code.ensure_loaded?(Postgrex) do
       queries ++ comments_on("INDEX", quote_table(index.prefix, index.name), index.comment)
     end
 
-    def execute_ddl({command, %Index{} = index}) when command in @drops do
+    def execute_ddl({command, %Index{} = index, :cascade}) when command in @drops do
+      [cmd | _] = execute_ddl({command, index, nil})
+      [cmd ++ [" CASCADE"]]
+    end
+
+    def execute_ddl({command, %Index{} = index, _}) when command in @drops do
       [["DROP INDEX ",
         if_do(index.concurrently, "CONCURRENTLY "),
         if_do(command == :drop_if_exists, "IF EXISTS "),
@@ -905,12 +915,12 @@ if Code.ensure_loaded?(Postgrex) do
       queries ++ comments_on("CONSTRAINT", constraint.name, constraint.comment, table_name)
     end
 
-    def execute_ddl({:drop, %Constraint{} = constraint}) do
+    def execute_ddl({:drop, %Constraint{} = constraint, _}) do
       [["ALTER TABLE ", quote_table(constraint.prefix, constraint.table),
         " DROP CONSTRAINT ", quote_name(constraint.name)]]
     end
 
-    def execute_ddl({:drop_if_exists, %Constraint{} = constraint}) do
+    def execute_ddl({:drop_if_exists, %Constraint{} = constraint, _}) do
       [["ALTER TABLE ", quote_table(constraint.prefix, constraint.table),
         " DROP CONSTRAINT IF EXISTS ", quote_name(constraint.name)]]
     end

lib/ecto/adapters/tds/connection.ex

@@ -1009,7 +1009,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Table{} = table}) when command in [:drop, :drop_if_exists] do
+    def execute_ddl({command, %Table{}, :cascade}) when command in [:drop, :drop_if_exists],
+      do: error!(nil, "MSSQL does not support `CASCADE` in DROP TABLE commands")
+
+    def execute_ddl({command, %Table{} = table, _}) when command in [:drop, :drop_if_exists] do
       prefix = table.prefix
 
       [
@@ -1124,7 +1127,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Index{} = index}) when command in [:drop, :drop_if_exists] do
+    def execute_ddl({command, %Index{}, :cascade}) when command in [:drop, :drop_if_exists],
+      do: error!(nil, "MSSQL does not support `CASCADE` in DROP INDEX commands")
+
+    def execute_ddl({command, %Index{} = index, _}) when command in [:drop, :drop_if_exists] do
       prefix = index.prefix
 
       [
@@ -1144,7 +1150,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Constraint{} = constraint})
+    def execute_ddl({command, %Constraint{}, :cascade}) when command in [:drop, :drop_if_exists],
+      do: error!(nil, "MSSQL does not support `CASCADE` in DROP CONSTRAINT commands")
+
+    def execute_ddl({command, %Constraint{} = constraint, _})
         when command in [:drop, :drop_if_exists] do
       table_name = quote_table(constraint.prefix, constraint.table)
 

lib/ecto/migration.ex

@@ -575,10 +575,20 @@ defmodule Ecto.Migration do
       drop index("posts", [:name])
       drop table("posts")
       drop constraint("products", "price_must_be_positive")
+      drop index("posts", [:name]), cascade: true
+      drop table("posts"), cascade: true
+
+  ## Options
+
+    * `:cascade` - when `true`, automatically drop objects that depend
+      - on the index, and in turn all objects that depend on those objects
+      - on the table
+      Default is `false`
 
   """
-  def drop(%{} = index_or_table_or_constraint) do
-    Runner.execute {:drop, __prefix__(index_or_table_or_constraint)}
+  def drop(%{} = index_or_table_or_constraint, opts \\ []) when is_list(opts) do
+    Runner.execute {:drop, __prefix__(index_or_table_or_constraint), Keyword.get(opts, :mode)}
+
     index_or_table_or_constraint
   end
 
@@ -591,10 +601,19 @@ defmodule Ecto.Migration do
 
       drop_if_exists index("posts", [:name])
       drop_if_exists table("posts")
+      drop_if_exists index("posts, [:name]), mode: :cascade
+      drop_if_exists table("posts"), mode: :cascade
 
+  ## Options
+
+    * `:mode` - when set to `:cascade`, automatically drop objects that depend
+      - on the index, and in turn all objects that depend on those objects
+      - on the table
+      Default is `:restrict`
   """
-  def drop_if_exists(%{} = index_or_table) do
-    Runner.execute {:drop_if_exists, __prefix__(index_or_table)}
+  def drop_if_exists(%{} = index_or_table, opts \\ []) when is_list(opts) do
+    Runner.execute {:drop_if_exists, __prefix__(index_or_table), Keyword.get(opts, :mode)}
+
     index_or_table
   end
 

lib/ecto/migration/runner.ex

@@ -217,18 +217,18 @@ defmodule Ecto.Migration.Runner do
   end
 
   defp reverse({:create, %Index{} = index}),
-    do: {:drop, index}
+    do: {:drop, index, nil}
   defp reverse({:create_if_not_exists, %Index{} = index}),
-    do: {:drop_if_exists, index}
-  defp reverse({:drop, %Index{} = index}),
+    do: {:drop_if_exists, index, nil}
+  defp reverse({:drop, %Index{} = index, _}),
     do: {:create, index}
-  defp reverse({:drop_if_exists, %Index{} = index}),
+  defp reverse({:drop_if_exists, %Index{} = index, _}),
     do: {:create_if_not_exists, index}
 
   defp reverse({:create, %Table{} = table, _columns}),
-    do: {:drop, table}
+    do: {:drop, table, nil}
   defp reverse({:create_if_not_exists, %Table{} = table, _columns}),
-    do: {:drop_if_exists, table}
+    do: {:drop_if_exists, table, nil}
   defp reverse({:rename, %Table{} = table_current, %Table{} = table_new}),
     do: {:rename, table_new, table_current}
   defp reverse({:rename, %Table{} = table, current_column, new_column}),
@@ -242,9 +242,9 @@ defmodule Ecto.Migration.Runner do
   # It is not a good idea to reverse constraints because
   # we can't guarantee data integrity when applying them back.
   defp reverse({:create_if_not_exists, %Constraint{} = constraint}),
-    do: {:drop_if_exists, constraint}
+    do: {:drop_if_exists, constraint, nil}
   defp reverse({:create, %Constraint{} = constraint}),
-    do: {:drop, constraint}
+    do: {:drop, constraint, nil}
 
   defp reverse(_command), do: false
 
@@ -361,18 +361,26 @@ defmodule Ecto.Migration.Runner do
     do: "create table if not exists #{quote_name(table.prefix, table.name)}"
   defp command({:alter, %Table{} = table, _}),
     do: "alter table #{quote_name(table.prefix, table.name)}"
-  defp command({:drop, %Table{} = table}),
+  defp command({:drop, %Table{} = table, :cascade}),
+    do: command({:drop, table, nil}) <> " cascade"
+  defp command({:drop, %Table{} = table, _}),
     do: "drop table #{quote_name(table.prefix, table.name)}"
-  defp command({:drop_if_exists, %Table{} = table}),
+  defp command({:drop_if_exists, %Table{} = table, :cascade}),
+    do: command({:drop_if_exists, table, nil}) <> " cascade"
+  defp command({:drop_if_exists, %Table{} = table, _}),
     do: "drop table if exists #{quote_name(table.prefix, table.name)}"
 
   defp command({:create, %Index{} = index}),
     do: "create index #{quote_name(index.prefix, index.name)}"
   defp command({:create_if_not_exists, %Index{} = index}),
     do: "create index if not exists #{quote_name(index.prefix, index.name)}"
-  defp command({:drop, %Index{} = index}),
+  defp command({:drop, %Index{} = index, :cascade}),
+    do: command({:drop, index, nil}) <> " cascade"
+  defp command({:drop, %Index{} = index, _}),
     do: "drop index #{quote_name(index.prefix, index.name)}"
-  defp command({:drop_if_exists, %Index{} = index}),
+  defp command({:drop_if_exists, %Index{} = index, :cascade}),
+    do: command({:drop_if_exists, index, nil}) <> " cascade"
+  defp command({:drop_if_exists, %Index{} = index, _}),
     do: "drop index if exists #{quote_name(index.prefix, index.name)}"
   defp command({:rename, %Table{} = current_table, %Table{} = new_table}),
     do: "rename table #{quote_name(current_table.prefix, current_table.name)} to #{quote_name(new_table.prefix, new_table.name)}"
@@ -387,9 +395,9 @@ defmodule Ecto.Migration.Runner do
     do: "create check constraint #{constraint.name} on table #{quote_name(constraint.prefix, constraint.table)}"
   defp command({:create, %Constraint{exclude: exclude} = constraint}) when is_binary(exclude),
     do: "create exclude constraint #{constraint.name} on table #{quote_name(constraint.prefix, constraint.table)}"
-  defp command({:drop, %Constraint{} = constraint}),
+  defp command({:drop, %Constraint{} = constraint, _}),
     do: "drop constraint #{constraint.name} from table #{quote_name(constraint.prefix, constraint.table)}"
-  defp command({:drop_if_exists, %Constraint{} = constraint}),
+  defp command({:drop_if_exists, %Constraint{} = constraint, _}),
     do: "drop constraint if exists #{constraint.name} from table #{quote_name(constraint.prefix, constraint.table)}"
 
   defp quote_name(nil, name), do: quote_name(name)

test/ecto/adapters/myxql_test.exs

@@ -1270,24 +1270,24 @@ defmodule Ecto.Adapters.MyXQLTest do
   end
 
   test "drop table" do
-    drop = {:drop, table(:posts)}
+    drop = {:drop, table(:posts), nil}
     assert execute_ddl(drop) == [~s|DROP TABLE `posts`|]
   end
 
   test "drop table with prefixes" do
-    drop = {:drop, table(:posts, prefix: :foo)}
+    drop = {:drop, table(:posts, prefix: :foo), nil}
     assert execute_ddl(drop) == [~s|DROP TABLE `foo`.`posts`|]
   end
 
   test "drop constraint" do
     assert_raise ArgumentError, ~r/MySQL adapter does not support constraints/, fn ->
-      execute_ddl({:drop, constraint(:products, "price_must_be_positive", prefix: :foo)})
+      execute_ddl({:drop, constraint(:products, "price_must_be_positive", prefix: :foo), nil})
     end
   end
 
   test "drop_if_exists constraint" do
     assert_raise ArgumentError, ~r/MySQL adapter does not support constraints/, fn ->
-      execute_ddl({:drop_if_exists, constraint(:products, "price_must_be_positive", prefix: :foo)})
+      execute_ddl({:drop_if_exists, constraint(:products, "price_must_be_positive", prefix: :foo), nil})
     end
   end
 
@@ -1425,12 +1425,12 @@ defmodule Ecto.Adapters.MyXQLTest do
   end
 
   test "drop index" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main")}
+    drop = {:drop, index(:posts, [:id], name: "posts$main"), nil}
     assert execute_ddl(drop) == [~s|DROP INDEX `posts$main` ON `posts`|]
   end
 
   test "drop index with prefix" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo)}
+    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo), nil}
     assert execute_ddl(drop) == [~s|DROP INDEX `posts$main` ON `foo`.`posts`|]
   end
 

test/ecto/adapters/postgres_test.exs

@@ -1532,15 +1532,23 @@ defmodule Ecto.Adapters.PostgresTest do
   end
 
   test "drop table" do
-    drop = {:drop, table(:posts)}
+    drop = {:drop, table(:posts), nil}
     assert execute_ddl(drop) == [~s|DROP TABLE "posts"|]
   end
 
   test "drop table with prefix" do
-    drop = {:drop, table(:posts, prefix: :foo)}
+    drop = {:drop, table(:posts, prefix: :foo), nil}
     assert execute_ddl(drop) == [~s|DROP TABLE "foo"."posts"|]
   end
 
+  test "drop table with cascade" do
+    drop = {:drop, table(:posts), :cascade}
+    assert execute_ddl(drop) == [~s|DROP TABLE "posts" CASCADE|]
+
+    drop = {:drop, table(:posts, prefix: :foo), :cascade}
+    assert execute_ddl(drop) == [~s|DROP TABLE "foo"."posts" CASCADE|]
+  end
+
   test "alter table" do
     alter = {:alter, table(:posts),
              [{:add, :title, :string, [default: "Untitled", size: 100, null: false]},
@@ -1728,21 +1736,29 @@ defmodule Ecto.Adapters.PostgresTest do
   end
 
   test "drop index" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main")}
+    drop = {:drop, index(:posts, [:id], name: "posts$main"), nil}
     assert execute_ddl(drop) == [~s|DROP INDEX "posts$main"|]
   end
 
   test "drop index with prefix" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo)}
+    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo), nil}
     assert execute_ddl(drop) == [~s|DROP INDEX "foo"."posts$main"|]
   end
 
   test "drop index concurrently" do
     index = index(:posts, [:id], name: "posts$main")
-    drop = {:drop, %{index | concurrently: true}}
+    drop = {:drop, %{index | concurrently: true}, nil}
     assert execute_ddl(drop) == [~s|DROP INDEX CONCURRENTLY "posts$main"|]
   end
 
+  test "drop index with cascade" do
+    drop = {:drop, index(:posts, [:id], name: "posts$main"), :cascade}
+    assert execute_ddl(drop) == [~s|DROP INDEX "posts$main" CASCADE|]
+
+    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo), :cascade}
+    assert execute_ddl(drop) == [~s|DROP INDEX "foo"."posts$main" CASCADE|]
+  end
+
   test "create check constraint" do
     create = {:create, constraint(:products, "price_must_be_positive", check: "price > 0")}
     assert execute_ddl(create) ==
@@ -1773,21 +1789,21 @@ defmodule Ecto.Adapters.PostgresTest do
   end
 
   test "drop constraint" do
-    drop = {:drop, constraint(:products, "price_must_be_positive")}
+    drop = {:drop, constraint(:products, "price_must_be_positive"), nil}
     assert execute_ddl(drop) ==
       [~s|ALTER TABLE "products" DROP CONSTRAINT "price_must_be_positive"|]
 
-    drop = {:drop, constraint(:products, "price_must_be_positive", prefix: "foo")}
+    drop = {:drop, constraint(:products, "price_must_be_positive", prefix: "foo"), nil}
     assert execute_ddl(drop) ==
       [~s|ALTER TABLE "foo"."products" DROP CONSTRAINT "price_must_be_positive"|]
   end
 
   test "drop_if_exists constraint" do
-    drop = {:drop_if_exists, constraint(:products, "price_must_be_positive")}
+    drop = {:drop_if_exists, constraint(:products, "price_must_be_positive"), nil}
     assert execute_ddl(drop) ==
       [~s|ALTER TABLE "products" DROP CONSTRAINT IF EXISTS "price_must_be_positive"|]
 
-    drop = {:drop_if_exists, constraint(:products, "price_must_be_positive", prefix: "foo")}
+    drop = {:drop_if_exists, constraint(:products, "price_must_be_positive", prefix: "foo"), nil}
     assert execute_ddl(drop) ==
       [~s|ALTER TABLE "foo"."products" DROP CONSTRAINT IF EXISTS "price_must_be_positive"|]
   end