Merge pull request #72 from jongleb/prepare-not-prepare

Add exec for queries without prepared statements

Author: paurkedal

bindings/ffi_bindings.ml

@@ -230,6 +230,18 @@ module Functions (F : Ctypes.FOREIGN) = struct
   let mysql_num_fields = foreign "mysql_num_fields"
     (res @-> returning int)
 
+  let mysql_affected_rows = foreign "mysql_affected_rows"
+    (mysql @-> returning ullong)
+
+  let mysql_insert_id = foreign "mysql_insert_id"
+    (mysql @-> returning ullong)
+
+  let mysql_field_count = foreign "mysql_field_count"
+    (mysql @-> returning uint)
+
+  let mysql_use_result = foreign "mysql_use_result"
+    (mysql @-> returning res_opt)
+
   let mysql_errno = foreign "mysql_errno"
     (mysql @-> returning int)
 

lib/binding_wrappers.ml

@@ -51,6 +51,15 @@ let mysql_stmt_affected_rows stmt =
 let mysql_stmt_insert_id stmt =
   Unsigned.ULLong.to_int @@ B.mysql_stmt_insert_id stmt
 
+let mysql_affected_rows mysql =
+  Unsigned.ULLong.to_int @@ B.mysql_affected_rows mysql
+
+let mysql_insert_id mysql =
+  Unsigned.ULLong.to_int @@ B.mysql_insert_id mysql
+
+let mysql_field_count mysql =
+  Unsigned.UInt.to_int @@ B.mysql_field_count mysql
+
 (* Blocking API *)
 
 let mysql_real_connect mysql host user pass db port socket flags =
@@ -229,9 +238,8 @@ let mysql_stmt_next_result_start stmt =
 let mysql_stmt_next_result_cont stmt status =
   handle_int (fun err -> B.mysql_stmt_next_result_cont err stmt status)
 
-let mysql_real_query_start mysql query =
-  let len = Unsigned.ULong.of_int (String.length query) in
-  let query = char_ptr_buffer_of_string query in
+let mysql_real_query_start mysql query len =
+  let len = Unsigned.ULong.of_int len in
   handle_int (fun err -> B.mysql_real_query_start err mysql query len)
 
 let mysql_real_query_cont mysql status =

lib/blocking.ml

@@ -71,6 +71,11 @@ type client_option = Common.client_option =
 type server_option = Common.server_option =
   | Multi_statements of bool
 
+type exec_result = Common.exec_result =
+  { affected_rows : int
+  ; insert_id     : int
+  }
+
 let close mariadb =
   B.mysql_close mariadb.Common.raw
 
@@ -158,6 +163,18 @@ let prepare mariadb query =
 let start_txn mariadb =
   wrap_unit mariadb (B.mysql_real_query mariadb.Common.raw "START TRANSACTION")
 
+let exec mariadb query =
+  match wrap_unit mariadb (B.mysql_real_query mariadb.Common.raw query) with
+  | Error e -> Error e
+  | Ok () ->
+      match Common.query_result mariadb with
+      | Ok result -> Ok result
+      | Error (Some res) ->
+          B.mysql_free_result res;
+          Error (0, "exec: statement returned a result set, use prepare")
+      | Error None ->
+          Error (Common.error mariadb)
+
 module Res = struct
   type t = [`Blocking] Common.Res.t
 

lib/common.ml

@@ -82,9 +82,22 @@ type server_option =
 
 type error = int * string
 
+type exec_result =
+  { affected_rows : int
+  ; insert_id     : int
+  }
+
 let error mariadb =
   (B.mysql_errno mariadb.raw, B.mysql_error mariadb.raw)
 
+let query_result mariadb =
+  if B.mysql_field_count mariadb.raw = 0 then
+    Ok { affected_rows = B.mysql_affected_rows mariadb.raw
+       ; insert_id     = B.mysql_insert_id mariadb.raw
+       }
+  else
+    Error (B.mysql_use_result mariadb.raw)
+
 let int_of_server_option = function
   | Multi_statements true -> T.Server_options.multi_statements_on
   | Multi_statements false -> T.Server_options.multi_statements_off

lib/mariadb.ml

@@ -174,6 +174,10 @@ module type S = sig
   val commit : t -> unit result
   val rollback : t -> unit result
   val prepare : t -> string -> Stmt.t result
+
+  type exec_result = { affected_rows : int; insert_id : int }
+
+  val exec : t -> string -> exec_result result
 end
 
 module B = Binding_wrappers

lib/mariadb.mli

@@ -300,6 +300,15 @@ module type S = sig
     (** [prepare mariadb query] creates a prepared statement for [query].  The
         query may contain [?] as placeholders for parameters that can be bound
         by calling [Stmt.execute]. *)
+
+  type exec_result = { affected_rows : int; insert_id : int }
+    (** The result of a statement executed by {!exec}.  The fields have the
+        same meaning as {!Res.affected_rows} and {!Res.insert_id}. *)
+
+  val exec : t -> string -> exec_result result
+    (** [exec mariadb query] executes [query] using the text protocol, without
+        creating a prepared statement on the server.  [query] must be a single
+        statement without [?] placeholders and must not return a result set. *)
 end
 
 (** The module for blocking MariaDB API calls. It should be possible to call
@@ -550,6 +559,10 @@ module Nonblocking : sig
     val commit : t -> unit result future
     val rollback : t -> unit result future
     val prepare : t -> string -> Stmt.t result future
+
+    type exec_result = { affected_rows : int; insert_id : int }
+
+    val exec : t -> string -> exec_result result future
   end
 
   (** Functor that generates a nonblocking database interface, given a

lib/nonblocking.ml

@@ -177,14 +177,28 @@ let rollback_cont mariadb status =
 let rollback mariadb =
   (rollback_start mariadb, rollback_cont mariadb)
 
-let start_txn_start mariadb =
-  handle_int mariadb (B.mysql_real_query_start mariadb.Common.raw "START TRANSACTION")
+type text_query =
+  { query : char Ctypes.ptr
+  ; len   : int
+  }
+
+let text_query query =
+  { query = char_ptr_buffer_of_string query
+  ; len   = String.length query
+  }
+
+let real_query_start mariadb q =
+  handle_int mariadb (B.mysql_real_query_start mariadb.Common.raw q.query q.len)
 
-let start_txn_cont mariadb status =
+let real_query_cont mariadb _q status =
   handle_int mariadb (B.mysql_real_query_cont mariadb.Common.raw status)
 
+let real_query mariadb query =
+  let q = text_query query in
+  (real_query_start mariadb q, real_query_cont mariadb q)
+
 let start_txn mariadb =
-  (start_txn_start mariadb, start_txn_cont mariadb)
+  real_query mariadb "START TRANSACTION"
 
 let build_stmt mariadb raw =
   `Ok (Common.Stmt.init mariadb raw)
@@ -554,6 +568,10 @@ module type S = sig
   val commit : t -> unit result future
   val rollback : t -> unit result future
   val prepare : t -> string -> Stmt.t result future
+
+  type exec_result = { affected_rows : int; insert_id : int }
+
+  val exec : t -> string -> exec_result result future
 end
 
 module Make (W : Wait) : S with type 'a future = 'a W.IO.future = struct
@@ -764,4 +782,25 @@ module Make (W : Wait) : S with type 'a future = 'a W.IO.future = struct
     match prepare m q with
     | `Ok nb -> nonblocking m nb
     | `Error e -> return (Error e)
+
+  type exec_result = Common.exec_result =
+    { affected_rows : int
+    ; insert_id     : int
+    }
+
+  let handle_exec m =
+    match Common.query_result m with
+    | Ok result ->
+        return (Ok result)
+    | Error (Some res) ->
+        nonblocking' m (Res.free res) >>= fun () ->
+        return (Error (0, "exec: statement returned a result set, use prepare"))
+    | Error None ->
+        return (Error (Common.error m))
+
+  let exec m q =
+    nonblocking m (real_query m q)
+    >>= function
+    | Ok () -> handle_exec m
+    | Error _ as e -> return e
 end

tests/nonblocking/nonblocking_testsuite.ml

@@ -219,6 +219,110 @@ struct
 
     M.close dbh
 
+  let test_exec () =
+    connect () >>= or_die "connect" >>= fun dbh ->
+
+    M.exec dbh
+      "CREATE TEMPORARY TABLE ocaml_mariadb_test \
+        (id integer PRIMARY KEY AUTO_INCREMENT, v integer, s text)"
+      >>= or_die "exec create" >>= fun res ->
+    assert (res.M.affected_rows = 0);
+    assert (res.M.insert_id = 0);
+
+    M.exec dbh "INSERT INTO ocaml_mariadb_test (v) VALUES (10), (20), (30)"
+      >>= or_die "exec multi-row insert" >>= fun res ->
+    assert (res.M.affected_rows = 3);
+    assert (res.M.insert_id = 1);
+
+    M.exec dbh "INSERT INTO ocaml_mariadb_test (v) VALUES (40)"
+      >>= or_die "exec single-row insert" >>= fun res ->
+    assert (res.M.affected_rows = 1);
+    assert (res.M.insert_id = 4);
+
+    M.exec dbh "UPDATE ocaml_mariadb_test SET v = v + 1 WHERE v >= 30"
+      >>= or_die "exec update" >>= fun res ->
+    assert (res.M.affected_rows = 2);
+    assert (res.M.insert_id = 0);
+
+    M.exec dbh
+      "INSERT INTO ocaml_mariadb_test (id, v) VALUES (2, 25) \
+        ON DUPLICATE KEY UPDATE v = 25"
+      >>= or_die "exec insert on duplicate key update" >>= fun res ->
+    assert (res.M.affected_rows = 2);
+
+    M.exec dbh "DELETE FROM ocaml_mariadb_test WHERE v = 10"
+      >>= or_die "exec delete" >>= fun res ->
+    assert (res.M.affected_rows = 1);
+
+    M.exec dbh "SELECT v FROM ocaml_mariadb_test"
+      >>= (function
+       | Ok _ -> die_f "exec of a SELECT unexpectedly succeeded"
+       | Error _ -> return ()) >>= fun () ->
+
+    M.prepare dbh "SELECT v FROM ocaml_mariadb_test WHERE id = 3"
+      >>= or_die "prepare after rejected exec"
+      >>= fun stmt ->
+    M.Stmt.execute stmt [||] >>= or_die "execute" >>= fun res ->
+    fetch_single_row res >>= fun row ->
+    assert (Array.length row = 1 && M.Field.int row.(0) = 31);
+    M.Stmt.close stmt >>= or_die "Stmt.close" >>= fun () ->
+
+    M.exec dbh "MALFORMED STATEMENT"
+      >>= (function
+       | Ok _ -> die_f "exec of a malformed statement unexpectedly succeeded"
+       | Error (errno, _) ->
+          assert (errno = 1064);
+          return ()) >>= fun () ->
+
+    let n = 16 * 1024 in
+    let pad = String.make 256 'x' in
+    let buf = Buffer.create (n * 280) in
+    Buffer.add_string buf "INSERT INTO ocaml_mariadb_test (v, s) VALUES ";
+    for i = 0 to n - 1 do
+      if i > 0 then Buffer.add_char buf ',';
+      bprintf buf "(%d, '%s')" i pad
+    done;
+    M.exec dbh (Buffer.contents buf)
+      >>= or_die "exec bulk insert" >>= fun res ->
+    assert (res.M.affected_rows = n);
+    assert (res.M.insert_id = 5);
+
+    M.close dbh
+
+  let test_exec_no_stmt_prepare () =
+    connect () >>= or_die "connect" >>= fun dbh ->
+    M.prepare dbh
+      "SELECT VARIABLE_VALUE FROM information_schema.SESSION_STATUS \
+        WHERE VARIABLE_NAME = 'Com_stmt_prepare'"
+      >>= or_die "prepare status" >>= fun status_stmt ->
+    let stmt_prepare_count () =
+      M.Stmt.execute status_stmt [||] >>= or_die "execute status" >>= fun res ->
+      if M.Res.num_rows res = 0 then return None else
+      fetch_single_row res >|= fun row ->
+      Some (int_of_string (M.Field.string row.(0)))
+    in
+    stmt_prepare_count () >>= (function
+     | None -> return ()
+     | Some count ->
+        M.exec dbh "CREATE TEMPORARY TABLE ocaml_mariadb_test (v integer)"
+          >>= or_die "exec create" >>= fun _ ->
+        repeat 10
+          (fun () ->
+            M.exec dbh "INSERT INTO ocaml_mariadb_test (v) VALUES (1), (2)"
+              >>= or_die "exec insert" >>= fun res ->
+            assert (res.M.affected_rows = 2);
+            return ()) >>= fun () ->
+        stmt_prepare_count () >>= fun count' ->
+        assert (count' = Some count);
+        M.prepare dbh "SELECT v FROM ocaml_mariadb_test WHERE v = ?"
+          >>= or_die "prepare control" >>= fun control_stmt ->
+        stmt_prepare_count () >>= fun count'' ->
+        assert (count'' = Some (count + 1));
+        M.Stmt.close control_stmt >>= or_die "Stmt.close control")
+    >>= fun () ->
+    M.Stmt.close status_stmt >>= or_die "Stmt.close status" >>= fun () ->
+    M.close dbh
+
   (* Make sure the conversion between timestamps and strings are consistent
    * between MariaDB and OCaml. By sending timestamps to be compared as binary
    * and as string, this also verifies the MYSQL_TIME encoding. *)
@@ -449,6 +553,8 @@ struct
     test_server_properties () >>= fun () ->
     test_insert_id () >>= fun () ->
     test_txn () >>= fun () ->
+    test_exec () >>= fun () ->
+    test_exec_no_stmt_prepare () >>= fun () ->
     test_json () >>= fun () ->
     test_many_select () >>= fun () ->
     test_integer () >>= fun () -> test_bigint ()