Support modifiers and drop mode

Author: mochaaP

CHANGELOG.md

@@ -7,6 +7,8 @@ project adheres to [Semantic Versioning][semver].
 
 ## Unreleased
 
+- changed: Raise on incorrect use of drop mode.
+- added: Support rendering `:modifiers` in `CREATE TABLE` commands.
 - added: Support check constraints via [`Ecto.Migration.constraint/3`](https://hexdocs.pm/ecto_sql/Ecto.Migration.html#constraint/3).
 - changed: Reimplement querying prefix names.
 - added: Raise on cross-database foreign keys.

lib/ecto/adapters/sqlite3/connection.ex

@@ -390,38 +390,30 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   ## DDL
   ##
 
+  @creates [:create, :create_if_not_exists]
+  @drops [:drop, :drop_if_exists]
+
   @impl true
   def execute_ddl({_command, %Table{options: options}, _}) when is_list(options) do
     raise ArgumentError, "SQLite3 adapter does not support keyword lists in :options"
   end
 
-  def execute_ddl({:create, %Table{} = table, columns}) do
+  def execute_ddl({command, %Table{} = table, columns}) when command in @creates do
     {table, composite_pk_def} = composite_pk_definition(table, columns)
     composite_fk_defs = composite_fk_definitions(table, columns)
 
-    [
-      [
-        "CREATE TABLE ",
-        quote_name(table.prefix, table.name),
-        ?\s,
-        ?(,
-        column_definitions(table, columns),
-        composite_pk_def,
-        composite_fk_defs,
-        ?),
-        options_expr(table.options)
-      ]
-    ]
-  end
+    table_name = quote_name(table.prefix, table.name)
 
-  def execute_ddl({:create_if_not_exists, %Table{} = table, columns}) do
-    {table, composite_pk_def} = composite_pk_definition(table, columns)
-    composite_fk_defs = composite_fk_definitions(table, columns)
+    modifiers = modifiers_expr(table.modifiers)
+    assert_unqual_name(modifiers, table.prefix)
 
     [
       [
-        "CREATE TABLE IF NOT EXISTS ",
-        quote_name(table.prefix, table.name),
+        "CREATE ",
+        modifiers,
+        "TABLE ",
+        if_do(command == :create_if_not_exists, "IF NOT EXISTS "),
+        table_name,
         ?\s,
         ?(,
         column_definitions(table, columns),
@@ -433,32 +425,17 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     ]
   end
 
-  def execute_ddl({:drop, %Table{} = table}) do
+  def execute_ddl({command, %Table{} = table, mode}) when command in @drops do
     [
       [
         "DROP TABLE ",
-        quote_name(table.prefix, table.name)
-      ]
-    ]
-  end
-
-  def execute_ddl({:drop, %Table{} = table, _mode}) do
-    execute_ddl({:drop, table})
-  end
-
-  def execute_ddl({:drop_if_exists, %Table{} = table}) do
-    [
-      [
-        "DROP TABLE IF EXISTS ",
-        quote_name(table.prefix, table.name)
+        if_do(command == :drop_if_exists, "IF EXISTS "),
+        quote_name(table.prefix, table.name),
+        drop_mode(mode)
       ]
     ]
   end
 
-  def execute_ddl({:drop_if_exists, %Table{} = table, _mode}) do
-    execute_ddl({:drop_if_exists, table})
-  end
-
   def execute_ddl({:alter, %Table{} = table, changes}) do
     Enum.map(changes, fn change ->
       [
@@ -490,14 +467,15 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     raise ArgumentError, "`nulls_distinct` is not supported with SQLite3"
   end
 
-  def execute_ddl({:create, %Index{} = index}) do
+  def execute_ddl({command, %Index{} = index}) when command in @creates do
     fields = Enum.map_intersperse(index.columns, ", ", &index_expr/1)
 
     [
       [
         "CREATE ",
         if_do(index.unique, "UNIQUE "),
         "INDEX ",
+        if_do(command == :create_if_not_exists, "IF NOT EXISTS "),
         quote_name(index.prefix, index.name),
         " ON ",
         quote_name(index.table),
@@ -509,51 +487,17 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     ]
   end
 
-  def execute_ddl({:create_if_not_exists, %Index{} = index}) do
-    fields = Enum.map_intersperse(index.columns, ", ", &index_expr/1)
-
-    [
-      [
-        "CREATE ",
-        if_do(index.unique, "UNIQUE "),
-        "INDEX IF NOT EXISTS ",
-        quote_name(index.prefix, index.name),
-        " ON ",
-        quote_name(index.table),
-        " (",
-        fields,
-        ?),
-        if_do(index.where, [" WHERE ", to_string(index.where)])
-      ]
-    ]
-  end
-
-  def execute_ddl({:drop, %Index{} = index}) do
+  def execute_ddl({command, %Index{} = index, mode}) when command in @drops do
     [
       [
         "DROP INDEX ",
-        quote_name(index.prefix, index.name)
-      ]
-    ]
-  end
-
-  def execute_ddl({:drop, %Index{} = index, _mode}) do
-    execute_ddl({:drop, index})
-  end
-
-  def execute_ddl({:drop_if_exists, %Index{} = index}) do
-    [
-      [
-        "DROP INDEX IF EXISTS ",
-        quote_name(index.prefix, index.name)
+        if_do(command == :drop_if_exists, "IF EXISTS "),
+        quote_name(index.prefix, index.name),
+        drop_mode(mode)
       ]
     ]
   end
 
-  def execute_ddl({:drop_if_exists, %Index{} = index, _mode}) do
-    execute_ddl({:drop_if_exists, index})
-  end
-
   def execute_ddl({:rename, %Table{} = current_table, %Table{} = new_table}) do
     [
       [
@@ -600,18 +544,14 @@ defmodule Ecto.Adapters.SQLite3.Connection 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{} = constraint, _mode}) do
+  def execute_ddl({:drop, %Constraint{} = constraint, mode}) do
     [
       [
         "ALTER TABLE ",
         quote_name(constraint.prefix, constraint.table),
         " DROP CONSTRAINT ",
-        quote_name(constraint.name)
+        quote_name(constraint.name),
+        drop_mode(mode)
       ]
     ]
   end
@@ -622,7 +562,7 @@ defmodule Ecto.Adapters.SQLite3.Connection do
 
   def execute_ddl({:rename, %Index{} = index, new_index}) do
     [
-      execute_ddl({:drop, index}),
+      execute_ddl({:drop, index, :restrict}),
       execute_ddl({:create, %Index{index | name: new_index}})
     ]
   end
@@ -635,6 +575,12 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     {"SELECT name FROM sqlite_master WHERE type='table' AND name=? LIMIT 1", [table]}
   end
 
+  defp drop_mode(:cascade) do
+    raise ArgumentError, "SQLite3 does not support `CASCADE` in this command"
+  end
+
+  defp drop_mode(:restrict), do: []
+
   ##
   ## Query generation
   ##
@@ -1736,6 +1682,22 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   defp pk_expr(true, _), do: " PRIMARY KEY"
   defp pk_expr(_, _), do: []
 
+  defp modifiers_expr(nil), do: []
+
+  defp modifiers_expr(modifiers) when is_binary(modifiers) do
+    if temporary?(modifiers) do
+      [modifiers, ?\s]
+    else
+      raise ArgumentError,
+            ~s|SQLite3 adapter expects :modifiers to be one of [nil, "TEMP", "TEMPORARY"], got #{inspect(modifiers)}|
+    end
+  end
+
+  defp modifiers_expr(other) do
+    raise ArgumentError,
+          "SQLite3 adapter expects :modifiers to be a string or nil, got #{inspect(other)}"
+  end
+
   defp options_expr(nil), do: []
 
   defp options_expr(options) when is_list(options) do
@@ -1748,7 +1710,7 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   defp reference_expr(%Reference{with: [_]}, _table, _name), do: []
 
   defp reference_expr(%Reference{} = ref, table, name) do
-    assert_same_database(table.prefix, ref.prefix)
+    assert_same_database(table, ref)
 
     [
       " CONSTRAINT ",
@@ -1859,7 +1821,7 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   end
 
   defp composite_fk_definition(table, {_op, name, ref, _opts}) do
-    assert_same_database(table.prefix, ref.prefix)
+    assert_same_database(table, ref)
 
     {current_columns, reference_columns} = Enum.unzip([{name, ref.column} | ref.with])
 
@@ -1950,8 +1912,6 @@ defmodule Ecto.Adapters.SQLite3.Connection do
   # We know this holds since exqlite does not export sqlite3_db_config from Sqlite3NIF,
   # thus nobody can call sqlite3_db_config(db, SQLITE_DBCONFIG_MAINDBNAME, ...)
   defp normalize_database_name(nil) do
-    # TODO: handle modifier-selected temp database somehow?
-    # src/parse.y: `temp(A) ::= TEMP.  {A = pParse->db->init.busy==0;}`
     "main"
   end
 
@@ -1963,10 +1923,34 @@ defmodule Ecto.Adapters.SQLite3.Connection do
     String.downcase(name, :ascii)
   end
 
-  defp assert_same_database(table_prefix, ref_prefix) do
-    if normalize_database_name(ref_prefix || table_prefix) !=
-         normalize_database_name(table_prefix) do
+  defp temporary?(nil), do: false
+
+  defp temporary?(modifiers) when is_binary(modifiers),
+    do:
+      (modifiers
+       |> String.trim()
+       |> String.upcase(:ascii)) in ["TEMP", "TEMPORARY"]
+
+  defp temporary?(_), do: false
+
+  defp table_database(%Table{} = table) do
+    if temporary?(table.modifiers),
+      do: "temp",
+      else: normalize_database_name(table.prefix)
+  end
+
+  defp assert_same_database(%Table{} = table, %Reference{} = ref) do
+    table_db = table_database(table)
+    ref_db = if ref.prefix, do: normalize_database_name(ref.prefix), else: table_db
+
+    if ref_db != table_db do
       raise ArgumentError, "SQLite3 does not support cross-database foreign keys"
     end
   end
+
+  defp assert_unqual_name(modifiers, prefix) do
+    if modifiers != [] and prefix != nil do
+      raise ArgumentError, "SQLite3 does not support a prefix on a temporary table"
+    end
+  end
 end

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

@@ -130,6 +130,42 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
              ]
   end
 
+  test "create table with modifiers" do
+    create =
+      {:create, table(:posts, modifiers: "TEMPORARY"),
+       [
+         {:add, :id, :serial, [primary_key: true]},
+         {:add, :created_at, :naive_datetime, []}
+       ]}
+
+    assert execute_ddl(create) ==
+             [
+               ~s|CREATE TEMPORARY TABLE "posts" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "created_at" TEXT)|
+             ]
+
+    create =
+      {:create, table(:posts, modifiers: "TEMPORARY"),
+       [
+         {:add, :id, :serial, [primary_key: true]},
+         {:add, :category_0, %Reference{table: :categories, prefix: :foo}, []}
+       ]}
+
+    assert_raise ArgumentError,
+                 "SQLite3 does not support cross-database foreign keys",
+                 fn -> execute_ddl(create) end
+
+    create =
+      {:create, table(:posts, modifiers: "UNLOGGED"),
+       [
+         {:add, :id, :serial, [primary_key: true]},
+         {:add, :created_at, :naive_datetime, []}
+       ]}
+
+    assert_raise ArgumentError,
+                 ~s|SQLite3 adapter expects :modifiers to be one of [nil, "TEMP", "TEMPORARY"], got "UNLOGGED"|,
+                 fn -> execute_ddl(create) end
+  end
+
   test "create table with composite key" do
     create =
       {:create, table(:posts),
@@ -310,12 +346,12 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
   end
 
   test "drop table" do
-    drop = {:drop, table(:posts)}
+    drop = {:drop, table(:posts), :restrict}
     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), :restrict}
 
     assert execute_ddl(drop) == [~s|DROP TABLE "foo"."posts"|]
   end
@@ -496,7 +532,7 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
   end
 
   test "drop index" do
-    drop = {:drop, index(:posts, [:id], name: "posts$main")}
+    drop = {:drop, index(:posts, [:id], name: "posts$main"), :restrict}
     assert execute_ddl(drop) == [~s|DROP INDEX "posts$main"|]
   end
 
@@ -589,7 +625,7 @@ defmodule Ecto.Adapters.SQLite3.Connection.MigrationTest do
     drop = {:drop, constraint(:products, "price_must_be_positive"), :cascade}
 
     assert_raise ArgumentError,
-                 "SQLite3 does not support `CASCADE` in `DROP CONSTRAINT` commands",
+                 "SQLite3 does not support `CASCADE` in this command",
                  fn -> execute_ddl(drop) end
 
     drop =