···11defmodule EctoSQLite3.Integration.Migration do
22+ @moduledoc false
33+24 use Ecto.Migration
3546 def change do
+2
test/support/repo.ex
···11defmodule Ecto.Integration.TestRepo do
22+ @moduledoc false
33+24 use Ecto.Repo, otp_app: :ecto_sqlite3, adapter: Ecto.Adapters.SQLite3
3546 def create_prefix(_) do
+14-1
test/support/schemas.ex
···11defmodule EctoSQLite3.Integration.Account do
22+ @moduledoc false
33+24 use Ecto.Schema
3546 import Ecto.Changeset
5766- alias EctoSQLite3.Integration.User
78 alias EctoSQLite3.Integration.Product
99+ alias EctoSQLite3.Integration.User
810911 schema "accounts" do
1012 field(:name, :string)
···2426end
25272628defmodule EctoSQLite3.Integration.User do
2929+ @moduledoc false
3030+2731 use Ecto.Schema
28322933 import Ecto.Changeset
···4650end
47514852defmodule EctoSQLite3.Integration.AccountUser do
5353+ @moduledoc false
5454+4955 use Ecto.Schema
50565157 import Ecto.Changeset
···6874end
69757076defmodule EctoSQLite3.Integration.Product do
7777+ @moduledoc false
7878+7179 use Ecto.Schema
72807381 import Ecto.Changeset
···104112end
105113106114defmodule EctoSQLite3.Integration.Vec3f do
115115+ @moduledoc false
116116+107117 use Ecto.Schema
108118109119 schema "vec3f" do
···114124end
115125116126defmodule EctoSQLite3.Integration.Setting do
127127+ @moduledoc false
128128+117129 use Ecto.Schema
130130+118131 import Ecto.Changeset
119132120133 schema "settings" do
+9-7
lib/ecto/adapters/sqlite3.ex
···165165 def storage_down(options) do
166166 db_path = Keyword.fetch!(options, :database)
167167168168- with :ok <- File.rm(db_path) do
169169- File.rm(db_path <> "-shm")
170170- File.rm(db_path <> "-wal")
171171- :ok
172172- else
173173- _ -> {:error, :already_down}
168168+ case File.rm(db_path) do
169169+ :ok ->
170170+ File.rm(db_path <> "-shm")
171171+ File.rm(db_path <> "-wal")
172172+ :ok
173173+174174+ _otherwise ->
175175+ {:error, :already_down}
174176 end
175177 end
176178···194196 end
195197196198 @impl Ecto.Adapter.Migration
197197- def supports_ddl_transaction?(), do: false
199199+ def supports_ddl_transaction?, do: false
198200199201 @impl Ecto.Adapter.Migration
200202 def lock_for_migrations(_meta, _options, fun) do
+1-1
test/ecto/integration/crud_test.exs
···3344 alias Ecto.Integration.TestRepo
55 alias EctoSQLite3.Integration.Account
66- alias EctoSQLite3.Integration.User
76 alias EctoSQLite3.Integration.AccountUser
87 alias EctoSQLite3.Integration.Product
88+ alias EctoSQLite3.Integration.User
991010 import Ecto.Query
1111
+3-2
test/ecto/integration/json_test.exs
···11defmodule Ecto.Integration.JsonTest do
22 use Ecto.Integration.Case
3344- alias EctoSQLite3.Integration.Setting
44+ alias Ecto.Adapters.SQL
55 alias Ecto.Integration.TestRepo
66+ alias EctoSQLite3.Integration.Setting
6778 test "serializes json correctly" do
89 # Insert a record purposefully with atoms as the map key. We are going to
···1718 TestRepo.get(Setting, setting.id)
18191920 assert %{num_rows: 1, rows: [["bar"]]} =
2020- Ecto.Adapters.SQL.query!(
2121+ SQL.query!(
2122 TestRepo,
2223 "select json_extract(properties, '$.foo') from settings where id = ?1",
2324 [setting.id]
+6-10
lib/ecto/adapters/sqlite3/codec.ex
···2626 def decimal_decode(nil), do: {:ok, nil}
27272828 def decimal_decode(x) when is_float(x) do
2929- try do
3030- {:ok, Decimal.from_float(x)}
3131- catch
3232- Decimal.Error -> :error
3333- end
2929+ {:ok, Decimal.from_float(x)}
3030+ catch
3131+ Decimal.Error -> :error
3432 end
35333634 def decimal_decode(x) when is_binary(x) or is_integer(x) do
3737- try do
3838- {:ok, Decimal.new(x)}
3939- catch
4040- Decimal.Error -> :error
4141- end
3535+ {:ok, Decimal.new(x)}
3636+ catch
3737+ Decimal.Error -> :error
4238 end
43394440 def decimal_decode(_), do: :error
+3-2
lib/ecto/adapters/sqlite3/connection.ex
···3344 @behaviour Ecto.Adapters.SQL.Connection
5566+ alias Ecto.Adapters.SQL
67 alias Ecto.Migration.Constraint
78 alias Ecto.Migration.Index
89 alias Ecto.Migration.Reference
···1920 defp default_opts(opts) do
2021 opts
2122 |> Keyword.put_new(:journal_mode, :wal)
2222- |> Keyword.put_new(:cache_size, -64000)
2323+ |> Keyword.put_new(:cache_size, -64_000)
2324 |> Keyword.put_new(:temp_store, :memory)
2425 |> Keyword.put_new(:pool_size, 5)
2526 end
···320321 def explain_query(conn, query, params, opts) do
321322 case query(conn, build_explain_query(query), params, opts) do
322323 {:ok, %Exqlite.Result{} = result} ->
323323- {:ok, Ecto.Adapters.SQL.format_table(result)}
324324+ {:ok, SQL.format_table(result)}
324325325326 error ->
326327 error
+2-32
test/ecto/adapters/sqlite3/connection_test.exs
···11defmodule Ecto.Adapters.SQLite3.ConnectionTest do
22 use ExUnit.Case
3344- alias Ecto.Adapters.SQLite3.Connection
54 alias Ecto.Adapters.SQLite3
66- # alias Ecto.Migration.Table
55+ alias Ecto.Adapters.SQLite3.Connection
66+ alias Ecto.Migration.Reference
7788 import Ecto.Query
99 import Ecto.Migration, only: [table: 1, table: 2, index: 2, index: 3, constraint: 3]
1010- alias Ecto.Migration.Reference
11101211 defmodule Comment do
1312 use Ecto.Schema
···20262025 VALUES (?,?) \
20272026 ON CONFLICT ("x","y") DO NOTHING\
20282027 """
20292029-20302030- # For :update
20312031- # update =
20322032- # from("schema", update: [set: [z: "foo"]])
20332033- # |> plan(:update_all)
20342034- # |> all()
20352035- # query = insert(nil, "schema", [:x, :y], [[:x, :y]], {update, [], [:x, :y]}, [:z])
20362036- # assert query == ~s{INSERT INTO schema (x,y) VALUES (?,?) ON CONFLICT (x,y) DO UPDATE SET z = 'foo'}
20372037-20382038- # update =
20392039- # from("schema", update: [set: [z: ^"foo"]], where: [w: true])
20402040- # |> plan(:update_all)
20412041- # |> all()
20422042- # query = insert(nil, "schema", [:x, :y], [[:x, :y]], {update, [], [:x, :y]}, [:z])
20432043- # assert query = ~s{INSERT INTO schema (x,y) VALUES (?,?) ON CONFLICT (x,y) DO UPDATE SET z = ? WHERE (schema.w = 1)}
20442044-20452045- # update =
20462046- # from("schema", update: [set: [z: "foo"]])
20472047- # |> plan(:update_all)
20482048- # |> all()
20492049- # query = insert(nil, "schema", [:x, :y], [[:x, :y]], {update, [], [:x, :y]}, [:z])
20502050- # assert query = ~s{INSERT INTO schema (x,y) VALUES (?,?) ON CONFLICT (x,y) DO UPDATE SET z = 'foo'}
20512051-20522052- # update =
20532053- # from("schema", update: [set: [z: ^"foo"]], where: [w: true])
20542054- # |> plan(:update_all)
20552055- # |> all()
20562056- # query = insert(nil, "schema", [:x, :y], [[:x, :y]], {update, [], [:x, :y]}, [:z])
20572057- # assert query = ~s{INSERT INTO schema (x,y) VALUES (?,?) ON CONFLICT (x,y) DO UPDATE SET z = ? WHERE (schema.w = 1)}
2058202820592029 # For :replace_all
20602030 assert_raise(