Default to :restrict

Author: josevalim

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(), :restrict | :cascade | nil}
-          | {:drop_if_exists, Table.t(), :restrict | :cascade | nil}
+          | {:drop, Table.t(), :restrict | :cascade}
+          | {:drop_if_exists, Table.t(), :restrict | :cascade}
           | {:create, Index.t()}
           | {:create_if_not_exists, Index.t()}
-          | {:drop, Index.t(), :restrict | :cascade | nil}
-          | {:drop_if_exists, Index.t(), :restrict | :cascade | nil}
+          | {:drop, Index.t(), :restrict | :cascade}
+          | {:drop_if_exists, Index.t(), :restrict | :cascade}
 
   @typedoc "All commands allowed within the block passed to `table/2`"
   @type table_subcommand ::

lib/ecto/adapters/myxql/connection.ex

@@ -730,14 +730,10 @@ if Code.ensure_loaded?(MyXQL) do
         engine_expr(table.engine), options_expr(table.options)]]
     end
 
-    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
+    def execute_ddl({command, %Table{} = table, mode}) when command in [:drop, :drop_if_exists] do
       [["DROP TABLE ", if_do(command == :drop_if_exists, "IF EXISTS "),
-        quote_table(table.prefix, table.name)]]
+        quote_table(table.prefix, table.name), drop_mode(mode)]]
     end
 
     def execute_ddl({:alter, %Table{} = table, changes}) do
@@ -770,7 +766,7 @@ if Code.ensure_loaded?(MyXQL) 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
+    def execute_ddl({:drop, %Index{} = index, :restrict}) do
       [["DROP INDEX ",
         quote_name(index.name),
         " ON ", quote_table(index.prefix, index.table),
@@ -809,6 +805,9 @@ if Code.ensure_loaded?(MyXQL) do
       {"SELECT true FROM information_schema.tables WHERE table_name = ? AND table_schema = DATABASE() LIMIT 1", [table]}
     end
 
+    defp drop_mode(:cascade), do: " CASCADE"
+    defp drop_mode(:restrict), do: []
+
     defp pk_definitions(columns, prefix) do
       pks =
         for {_, name, _, opts} <- columns,

lib/ecto/adapters/postgres/connection.ex

@@ -845,14 +845,9 @@ if Code.ensure_loaded?(Postgrex) do
         comments_for_columns(table_name, columns)
     end
 
-    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
+    def execute_ddl({command, %Table{} = table, mode}) when command in @drops do
       [["DROP TABLE ", if_do(command == :drop_if_exists, "IF EXISTS "),
-        quote_table(table.prefix, table.name)]]
+        quote_table(table.prefix, table.name), drop_mode(mode)]]
     end
 
     def execute_ddl({:alter, %Table{} = table, changes}) do
@@ -885,16 +880,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, :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
+    def execute_ddl({command, %Index{} = index, mode}) when command in @drops do
       [["DROP INDEX ",
         if_do(index.concurrently, "CONCURRENTLY "),
         if_do(command == :drop_if_exists, "IF EXISTS "),
-        quote_table(index.prefix, index.name)]]
+        quote_table(index.prefix, index.name),
+        drop_mode(mode)]]
     end
 
     def execute_ddl({:rename, %Table{} = current_table, %Table{} = new_table}) do
@@ -915,14 +906,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
-      [["ALTER TABLE ", quote_table(constraint.prefix, constraint.table),
-        " DROP CONSTRAINT ", quote_name(constraint.name)]]
-    end
+    def execute_ddl({command, %Constraint{}, :cascade}) when command in @drops,
+      do: error!(nil, "PostgreSQL does not support `CASCADE` in DROP CONSTRAINT commands")
 
-    def execute_ddl({:drop_if_exists, %Constraint{} = constraint, _}) do
+    def execute_ddl({command, %Constraint{} = constraint, :restrict}) when command in @drops do
       [["ALTER TABLE ", quote_table(constraint.prefix, constraint.table),
-        " DROP CONSTRAINT IF EXISTS ", quote_name(constraint.name)]]
+        " DROP CONSTRAINT ", if_do(command == :drop_if_exists, "IF EXISTS "), quote_name(constraint.name)]]
     end
 
     def execute_ddl(string) when is_binary(string), do: [string]
@@ -946,6 +935,9 @@ if Code.ensure_loaded?(Postgrex) do
       {"SELECT true FROM information_schema.tables WHERE table_name = $1 AND table_schema = current_schema() LIMIT 1", [table]}
     end
 
+    defp drop_mode(:cascade), do: " CASCADE"
+    defp drop_mode(:restrict), do: []
+
     # From https://www.postgresql.org/docs/current/protocol-error-fields.html.
     defp ddl_log_level("DEBUG"), do: :debug
     defp ddl_log_level("LOG"), do: :info

lib/ecto/adapters/tds/connection.ex

@@ -974,9 +974,11 @@ if Code.ensure_loaded?(Tds) do
     # DDL
     alias Ecto.Migration.{Table, Index, Reference, Constraint}
 
+    @creates [:create, :create_if_not_exists]
+    @drops [:drop, :drop_if_exists]
+
     @impl true
-    def execute_ddl({command, %Table{} = table, columns})
-        when command in [:create, :create_if_not_exists] do
+    def execute_ddl({command, %Table{} = table, columns}) when command in @creates do
       prefix = table.prefix
 
       pk_name =
@@ -1009,10 +1011,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Table{}, :cascade}) when command in [:drop, :drop_if_exists],
+    def execute_ddl({command, %Table{}, :cascade}) when command in @drops,
       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
+    def execute_ddl({command, %Table{} = table, :restrict}) when command in @drops do
       prefix = table.prefix
 
       [
@@ -1047,8 +1049,7 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Index{} = index})
-        when command in [:create, :create_if_not_exists] do
+    def execute_ddl({command, %Index{} = index}) when command in @creates do
       prefix = index.prefix
 
       if index.using do
@@ -1127,10 +1128,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Index{}, :cascade}) when command in [:drop, :drop_if_exists],
+    def execute_ddl({command, %Index{}, :cascade}) when command in @drops,
       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
+    def execute_ddl({command, %Index{} = index, :restrict}) when command in @drops do
       prefix = index.prefix
 
       [
@@ -1150,11 +1151,10 @@ if Code.ensure_loaded?(Tds) do
       ]
     end
 
-    def execute_ddl({command, %Constraint{}, :cascade}) when command in [:drop, :drop_if_exists],
+    def execute_ddl({command, %Constraint{}, :cascade}) when command in @drops,
       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
+    def execute_ddl({command, %Constraint{} = constraint, _}) when command in @drops do
       table_name = quote_table(constraint.prefix, constraint.table)
 
       [

lib/ecto/migration.ex

@@ -575,20 +575,18 @@ 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
+      drop index("posts", [:name]), mode: :cascade
+      drop table("posts"), mode: :cascade
 
   ## 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`
+    * `: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(%{} = index_or_table_or_constraint, opts \\ []) when is_list(opts) do
-    Runner.execute {:drop, __prefix__(index_or_table_or_constraint), Keyword.get(opts, :mode)}
-
+    Runner.execute {:drop, __prefix__(index_or_table_or_constraint), Keyword.get(opts, :mode, :restrict)}
     index_or_table_or_constraint
   end
 
@@ -607,12 +605,12 @@ defmodule Ecto.Migration do
   ## 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`
+      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, opts \\ []) when is_list(opts) do
-    Runner.execute {:drop_if_exists, __prefix__(index_or_table), Keyword.get(opts, :mode)}
+    Runner.execute {:drop_if_exists, __prefix__(index_or_table), Keyword.get(opts, :mode, :restrict)}
 
     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, nil}
+    do: {:drop, index, :restrict}
   defp reverse({:create_if_not_exists, %Index{} = index}),
-    do: {:drop_if_exists, index, nil}
+    do: {:drop_if_exists, index, :restrict}
   defp reverse({:drop, %Index{} = index, _}),
     do: {:create, index}
   defp reverse({:drop_if_exists, %Index{} = index, _}),
     do: {:create_if_not_exists, index}
 
   defp reverse({:create, %Table{} = table, _columns}),
-    do: {:drop, table, nil}
+    do: {:drop, table, :restrict}
   defp reverse({:create_if_not_exists, %Table{} = table, _columns}),
-    do: {:drop_if_exists, table, nil}
+    do: {:drop_if_exists, table, :restrict}
   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, nil}
+    do: {:drop_if_exists, constraint, :restrict}
   defp reverse({:create, %Constraint{} = constraint}),
-    do: {:drop, constraint, nil}
+    do: {:drop, constraint, :restrict}
 
   defp reverse(_command), do: false
 
@@ -361,27 +361,19 @@ 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, :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, :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({:drop, %Table{} = table, mode}),
+    do: "drop table #{quote_name(table.prefix, table.name)}#{drop_mode(mode)}"
+  defp command({:drop_if_exists, %Table{} = table, mode}),
+    do: "drop table if exists #{quote_name(table.prefix, table.name)}#{drop_mode(mode)}"
 
   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, :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, :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({:drop, %Index{} = index, mode}),
+    do: "drop index #{quote_name(index.prefix, index.name)}#{drop_mode(mode)}"
+  defp command({:drop_if_exists, %Index{} = index, mode}),
+    do: "drop index if exists #{quote_name(index.prefix, index.name)}#{drop_mode(mode)}"
   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)}"
   defp command({:rename, %Table{} = table, current_column, new_column}),
@@ -400,6 +392,9 @@ defmodule Ecto.Migration.Runner do
   defp command({:drop_if_exists, %Constraint{} = constraint, _}),
     do: "drop constraint if exists #{constraint.name} from table #{quote_name(constraint.prefix, constraint.table)}"
 
+  defp drop_mode(:restrict), do: ""
+  defp drop_mode(:cascade), do: " cascade"
+
   defp quote_name(nil, name), do: quote_name(name)
   defp quote_name(prefix, name), do: quote_name(prefix) <> "." <> quote_name(name)
   defp quote_name(name) when is_atom(name), do: quote_name(Atom.to_string(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), nil}
+    drop = {:drop, table(:posts), :restrict}
     assert execute_ddl(drop) == [~s|DROP TABLE `posts`|]
   end
 
   test "drop table with prefixes" do
-    drop = {:drop, table(:posts, prefix: :foo), nil}
+    drop = {:drop, table(:posts, prefix: :foo), :restrict}
     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), nil})
+      execute_ddl({:drop, constraint(:products, "price_must_be_positive", prefix: :foo), :restrict})
     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), nil})
+      execute_ddl({:drop_if_exists, constraint(:products, "price_must_be_positive", prefix: :foo), :restrict})
     end
   end
 
@@ -1425,12 +1425,12 @@ defmodule Ecto.Adapters.MyXQLTest do
   end
 
   test "drop index" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main"), nil}
+    drop = {:drop, index(:posts, [:id], name: "posts$main"), :restrict}
     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), nil}
+    drop = {:drop, index(:posts, [:id], name: "posts$main", prefix: :foo), :restrict}
     assert execute_ddl(drop) == [~s|DROP INDEX `posts$main` ON `foo`.`posts`|]
   end