Merge close and prepare statement packets in unnamed mode

This removes one roundtrip to the database.

Author: hkrutzer

lib/myxql/client.ex

@@ -114,6 +114,16 @@ defmodule MyXQL.Client do
     end
   end
 
+  def com_stmt_close_prepare(client, statement, close_statement_id) do
+    with :ok <-
+           send_com(client, [
+             {:com_stmt_close, close_statement_id},
+             {:com_stmt_prepare, statement}
+           ]) do
+      recv_packets(client, &decode_com_stmt_prepare_response/3, :initial)
+    end
+  end
+
   def com_stmt_execute(client, statement_id, params, cursor_type) do
     with :ok <- send_com(client, {:com_stmt_execute, statement_id, params, cursor_type}) do
       recv_packets(client, &decode_com_stmt_execute_response/3, :initial)
@@ -142,6 +152,19 @@ defmodule MyXQL.Client do
     :ok
   end
 
+  def send_com(client, coms) when is_list(coms) do
+    sequence_num = 0
+
+    payload =
+      Enum.reduce(
+        coms,
+        [],
+        &[&2 | encode_packet(encode_com(&1), sequence_num, @default_max_packet_size)]
+      )
+
+    send_data(client, payload)
+  end
+
   def send_com(client, com) do
     payload = encode_com(com)
     send_packet(client, payload, 0)

lib/myxql/connection.ex

@@ -77,8 +77,6 @@ defmodule MyXQL.Connection do
     if cached_query = queries_get(state, query) do
       {:ok, cached_query, %{state | last_query: cached_query}}
     else
-      state = maybe_close(query, state)
-
       case prepare(query, state) do
         {:ok, query, state} ->
           {:ok, query, state}
@@ -99,8 +97,6 @@ defmodule MyXQL.Connection do
 
   @impl true
   def handle_execute(%Query{} = query, params, _opts, state) do
-    state = maybe_close(query, state)
-
     with {:ok, query, state} <- maybe_reprepare(query, state),
          result =
            Client.com_stmt_execute(
@@ -464,8 +460,8 @@ defmodule MyXQL.Connection do
   defp cache_key(%MyXQL.Query{cache: :reference, ref: ref}), do: ref
   defp cache_key(%MyXQL.Query{cache: :statement, statement: statement}), do: statement
 
-  defp prepare(%Query{ref: ref, statement: statement} = query, state) when is_reference(ref) do
-    case Client.com_stmt_prepare(state.client, statement) do
+  defp prepare(%Query{ref: ref} = query, state) when is_reference(ref) do
+    case prepare_maybe_close(query, state) do
       {:ok, com_stmt_prepare_ok(statement_id: statement_id, num_params: num_params)} ->
         query = %{query | num_params: num_params, statement_id: statement_id}
         queries_put(state, query)
@@ -476,6 +472,19 @@ defmodule MyXQL.Connection do
     end
   end
 
+  def prepare_maybe_close(
+        %{ref: newref} = query,
+        %{prepare: :unnamed, last_query: %{ref: oldref} = last_query} = state
+      )
+      when last_query != nil and oldref != newref do
+    queries_delete(state, state.last_query)
+    Client.com_stmt_close_prepare(state.client, query.statement, last_query.statement_id)
+  end
+
+  def prepare_maybe_close(query, state) do
+    Client.com_stmt_prepare(state.client, query.statement)
+  end
+
   defp maybe_reprepare(%{ref: ref}, %{last_query: %{ref: ref}} = state) do
     {:ok, state.last_query, state}
   end
@@ -494,15 +503,6 @@ defmodule MyXQL.Connection do
     end
   end
 
-  defp maybe_close(%{ref: ref}, %{last_query: %{ref: ref}} = state), do: state
-
-  defp maybe_close(_query, %{prepare: :unnamed, last_query: last_query} = state)
-       when last_query != nil do
-    close(last_query, state)
-  end
-
-  defp maybe_close(_query, state), do: state
-
   defp close(query, state) do
     :ok = Client.com_stmt_close(state.client, query.statement_id)
     queries_delete(state, query)