add application supervision tree

Author: Schultzer

benchmarks/bench.exs

@@ -8,26 +8,25 @@ defmodule SQL.Repo do
   use SQL, adapter: SQL.Adapters.Postgres
   import Ecto.Query
   def sql() do
-    # SQL.transaction do
-    #   SQL.transaction do
+    SQL.transaction do
+      SQL.transaction do
         Enum.to_list(~SQL"SELECT 1")
-    #   end
-    # end
+      end
+    end
   end
 
   def ecto() do
-    # SQL.Repo.transaction(fn ->
-    #   SQL.Repo.transaction(fn ->
+    SQL.Repo.transaction(fn ->
+      SQL.Repo.transaction(fn ->
         SQL.Repo.all(select(from("users"), [1]))
-    #   end)
-    # end)
+      end)
+    end)
   end
 end
 Application.put_env(:sql, :ecto_repos, [SQL.Repo])
-Application.put_env(:sql, SQL.Repo, log: false, username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", pool_size: 10, ssl: false)
+Application.put_env(:sql, SQL.Repo, log: false, username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", pool_size: :erlang.system_info(:schedulers_online), ssl: false)
 SQL.Repo.__adapter__().storage_up(SQL.Repo.config())
 SQL.Repo.start_link()
-SQL.Pool.start_link(%{username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", adapter: SQL.Adapters.Postgres, ssl: false})
 # query = "temp" |> recursive_ctes(true) |> with_cte("temp", as: ^union_all(select("temp", [t], %{n: 0, fact: 1}), ^where(select("temp", [t], [t.n+1, t.n+1*t.fact]), [t], t.n < 9))) |> select([t], [t.n])
 # sql = ~SQL[with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)]
 # result = Tuple.to_list(SQL.Lexer.lex("with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)"))
@@ -58,7 +57,7 @@ Benchee.run(
   # "runtime ecto" => fn _ -> SQL.Repo.to_sql(:all, "temp" |> recursive_ctes(true) |> with_cte("temp", as: ^union_all(select("temp", [t], %{n: 0, fact: 1}), ^where(select("temp", [t], [t.n+1, t.n+1*t.fact]), [t], t.n < 9))) |> select([t], [t.n])) end,
   # "comptime ecto" => fn _ -> SQL.Repo.to_sql(:all, query) end
   },
-  parallel: 50,
+  parallel: 1,
   memory_time: 2,
   reduction_time: 2,
   unit_scaling: :smallest,

config/config.exs

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 DBVisor
+
+import Config
+import_config "#{config_env()}.exs"

config/dev.exs

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 DBVisor
+
+import Config
+
+config :sql, pools: [
+  default: %{
+  username: "postgres",
+  password: "postgres",
+  hostname: "localhost",
+  database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}",
+  adapter: SQL.Adapters.Postgres,
+  ssl: false}
+]

config/prod.exs

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 DBVisor
+
+import Config

config/test.exs

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 DBVisor
+
+import Config
+
+config :sql, pools: [
+  default: %{
+  username: "postgres",
+  password: "postgres",
+  hostname: "localhost",
+  database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}",
+  adapter: SQL.Adapters.Postgres,
+  ssl: false}
+]

lib/adapters/postgres.ex

@@ -16,7 +16,7 @@ defmodule SQL.Adapters.Postgres do
   @execute <<?E,9::32,0,0::32-big>>
 
   def start(state) do
-    spawn(fn -> init(state) end)
+    {:ok, spawn(fn -> init(state) end)}
   end
 
   defp to_iodata({:in, m, [{:not, _, left}, {:binding, _, [idx]}]}, format, case, acc) do
@@ -38,7 +38,7 @@ defmodule SQL.Adapters.Postgres do
     :socket.connect(socket, Map.take(state, [:family, :port, :addr]), handle)
     receive do
       {:"$socket", ^socket, :select, ^handle} ->
-        :ok = :socket.connect(socket)
+        :socket.connect(socket)
         :socket.recv(socket, 0, [], handle)
         state
         |> Map.put(:socket, socket)
@@ -95,7 +95,7 @@ defmodule SQL.Adapters.Postgres do
       {:ssl_error, ^socket, reason} ->
         raise reason
       after
-        0 ->
+        5 ->
           case owner do
             nil ->
               case :queue.out(queue) do

lib/application.ex

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 DBVisor
+
+defmodule SQL.Application do
+  @moduledoc false
+
+  def start(_type, _args) do
+    pools = Application.get_env(:sql, :pools, [])
+    children = for {name, opts} <- pools, do: {SQL.Pool, Map.put(opts, :name, name)}
+    result = {:ok, _sup} = Supervisor.start_link(children, strategy: :one_for_all)
+    for {name, _} <- pools do
+      pid = Process.whereis(name)
+      children = Supervisor.which_children(pid)
+      pids = Enum.map(children, fn {_id, pid, _type, _mod} -> pid end)
+      :persistent_term.put(name, List.to_tuple(pids))
+    end
+    result
+  end
+end

lib/pool.ex

@@ -3,16 +3,25 @@
 
 defmodule SQL.Pool do
   @moduledoc false
-  use GenServer
+  use Supervisor
 
   @default %{ssl: false, timeout: 5000, parameter: %{}, name: :default, protocol: :tcp, use_registry: false, debug: false, otp: %{rcvbuf: {64_000, 128_000}}, socket: %{keepalive: true, linger: %{onoff: true, linger: 5}}, family: :inet, port: 5432, addr: {127, 0, 0, 1}}
   def start_link(opts) do
-    GenServer.start_link(__MODULE__, Map.merge(@default, opts), name: __MODULE__)
+    Supervisor.start_link(__MODULE__, Map.merge(@default, opts), name: opts[:name])
   end
 
   @impl true
   def init(state) do
-    :persistent_term.put(state.name, List.to_tuple(for n <- 1..:erlang.system_info(:schedulers_online), do: state.adapter.start(Map.put(state, :scheduler_id, n))))
-    {:ok, state}
+    children =
+      for n <- 1..:erlang.system_info(:schedulers_online) do
+        %{
+          id: {:conn, n},
+          start: {state.adapter, :start, [Map.put(state, :scheduler_id, n)]},
+          restart: :permanent,
+          shutdown: 5000,
+          type: :worker,
+        }
+      end
+    Supervisor.init(children, strategy: :one_for_one)
   end
 end

mix.exs

@@ -11,6 +11,7 @@ defmodule SQL.MixProject do
       app: :sql,
       version: @version,
       elixir: "~> 1.19",
+      start_permanent: Mix.env() == :prod,
       deps: deps(),
       description: "Brings an extensible SQL parser and sigil to Elixir, confidently write SQL with automatic parameterized queries.",
       name: "SQL",
@@ -21,6 +22,12 @@ defmodule SQL.MixProject do
     ]
   end
 
+  def application do
+    [
+      mod: {SQL.Application, []}
+    ]
+  end
+
   defp elixirc_paths(:test), do: ["lib", "test"]
   defp elixirc_paths(_), do: ["lib"]
 
@@ -50,7 +57,7 @@ defmodule SQL.MixProject do
       {:postgrex, ">= 0.0.0", only: :dev},
       {:tds, ">= 0.0.0", only: :dev},
       {:myxql, ">= 0.0.0", only: :dev},
-      {:yamerl, ">= 0.0.0", only: :dev},
+      {:yamerl, ">= 0.0.0", only: [:dev, :test]},
       {:unicode_set, "~> 1.0"}
     ]
   end

test/adapters/postgres_test.exs

@@ -5,11 +5,6 @@ defmodule SQL.Adapters.PostgresTest do
   use SQL.Case, async: true
   use SQL, adapter: SQL.Adapters.Postgres
 
-  setup_all do
-    {:ok, _pid} = SQL.Pool.start_link(%{username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", adapter: SQL.Adapters.Postgres, ssl: false})
-    :ok
-  end
-
   describe "with" do
     test "recursive" do
       assert "with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)" == to_string(~SQL[with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)])