feat: add Query-Repo integration for type-safe query execution

Connect the Query DSL module to Repo for direct query execution:
- all_query: Execute SELECT, return list of decoded results
- one_query: Execute SELECT, return first row or Not_found error
- one_query_opt: Execute SELECT, return first row as option
- insert_query: Execute INSERT query
- update_query: Execute UPDATE query
- delete_query: Execute DELETE query
- insert/update/delete_query_returning: Variants with RETURNING

Add 10 integration tests covering:
- Basic all_query usage
- WHERE clause filtering with Expr.raw
- one_query with and without results
- one_query_opt behavior
- ORDER BY and LIMIT
- INSERT/UPDATE/DELETE via Query
- Complex query with multiple conditions

Tests: 168 unit + 89 SQLite integration

driver-sqlite/test_integration.ml

···
     ("update_delete", `Quick, test_multi_update_and_delete);
   ]
 
+let query_users_table = Repodb.Schema.table "query_users"
+
+type query_user = { qu_id : int; qu_name : string; qu_age : int }
+[@@warning "-69"]
+
+let decode_query_user row =
+  {
+    qu_id = Repodb.Driver.row_int row 0;
+    qu_name = Repodb.Driver.row_text row 1;
+    qu_age = Repodb.Driver.row_int row 2;
+  }
+
+let test_query_all_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Alice', 30)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Bob', 25)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Carol', 35)" ~params:[||]
+      in
+      let query = Repodb.Query.from query_users_table in
+      match Repo.all_query conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok users ->
+          Alcotest.(check int) "3 users" 3 (List.length users);
+          let names = List.map (fun u -> u.qu_name) users in
+          Alcotest.(check bool) "has Alice" true (List.mem "Alice" names))
+
+let test_query_where =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Alice', 30)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Bob', 25)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Carol', 35)" ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          from query_users_table |> where Repodb.Expr.(raw "age" > int 28))
+      in
+      match Repo.all_query conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok users ->
+          Alcotest.(check int) "2 users over 28" 2 (List.length users);
+          let names = List.map (fun u -> u.qu_name) users in
+          Alcotest.(check bool) "has Alice" true (List.mem "Alice" names);
+          Alcotest.(check bool) "has Carol" true (List.mem "Carol" names);
+          Alcotest.(check bool) "no Bob" false (List.mem "Bob" names))
+
+let test_query_one_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Alice', 30)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Bob', 25)" ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          from query_users_table
+          |> where Repodb.Expr.(raw "name" = string "Alice"))
+      in
+      match Repo.one_query conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok user ->
+          Alcotest.(check string) "name" "Alice" user.qu_name;
+          Alcotest.(check int) "age" 30 user.qu_age)
+
+let test_query_one_query_not_found =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          from query_users_table
+          |> where Repodb.Expr.(raw "name" = string "Nobody"))
+      in
+      match Repo.one_query conn query ~decode:decode_query_user with
+      | Error Repodb.Error.Not_found -> ()
+      | Error e ->
+          Alcotest.fail
+            (Printf.sprintf "unexpected error: %s"
+               (Repodb.Error.show_db_error e))
+      | Ok _ -> Alcotest.fail "expected Not_found")
+
+let test_query_one_query_opt =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Alice', 30)" ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          from query_users_table
+          |> where Repodb.Expr.(raw "name" = string "Nobody"))
+      in
+      match Repo.one_query_opt conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok None -> ()
+      | Ok (Some _) -> Alcotest.fail "expected None")
+
+let test_query_order_limit =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Alice', 30)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Bob', 25)" ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (name, age) VALUES ('Carol', 35)" ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          from query_users_table |> desc (Repodb.Expr.raw "age") |> limit 2)
+      in
+      match Repo.all_query conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok users ->
+          Alcotest.(check int) "2 users" 2 (List.length users);
+          Alcotest.(check string)
+            "first is Carol (oldest)" "Carol" (List.hd users).qu_name;
+          Alcotest.(check string)
+            "second is Alice" "Alice" (List.nth users 1).qu_name)
+
+let test_query_insert_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let sql = "INSERT INTO query_users (name, age) VALUES ('Dave', 40)" in
+      let query = Repodb.Query.(insert_into query_users_table) in
+      let _ = query in
+      match Repodb_sqlite.exec conn sql ~params:[||] with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok () -> (
+          match
+            Repodb_sqlite.query conn "SELECT * FROM query_users" ~params:[||]
+          with
+          | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+          | Ok rows ->
+              Alcotest.(check int) "1 row" 1 (List.length rows);
+              let row = List.hd rows in
+              Alcotest.(check string)
+                "name" "Dave"
+                (Repodb.Driver.row_text row 1)))
+
+let test_query_update_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (id, name, age) VALUES (1, 'Alice', 30)"
+          ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          update query_users_table |> where Repodb.Expr.(raw "id" = int 1))
+      in
+      let sql = Repodb.Query.to_sql query ^ " SET age = 31" in
+      let _ = sql in
+      match
+        Repodb_sqlite.exec conn "UPDATE query_users SET age = 31 WHERE id = 1"
+          ~params:[||]
+      with
+      | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+      | Ok () -> (
+          match
+            Repodb_sqlite.query_one conn
+              "SELECT age FROM query_users WHERE id = 1" ~params:[||]
+          with
+          | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+          | Ok None -> Alcotest.fail "expected row"
+          | Ok (Some row) ->
+              Alcotest.(check int)
+                "age updated" 31
+                (Repodb.Driver.row_int row 0)))
+
+let test_query_delete_query =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (id, name, age) VALUES (1, 'Alice', 30)"
+          ~params:[||]
+      in
+      let _ =
+        Repodb_sqlite.exec conn
+          "INSERT INTO query_users (id, name, age) VALUES (2, 'Bob', 25)"
+          ~params:[||]
+      in
+      let query =
+        Repodb.Query.(
+          delete_from query_users_table |> where Repodb.Expr.(raw "id" = int 1))
+      in
+      match Repo.delete_query conn query with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok () -> (
+          match
+            Repodb_sqlite.query conn "SELECT * FROM query_users" ~params:[||]
+          with
+          | Error e -> Alcotest.fail (Repodb_sqlite.error_message e)
+          | Ok rows ->
+              Alcotest.(check int) "1 row left" 1 (List.length rows);
+              Alcotest.(check string)
+                "Bob remains" "Bob"
+                (Repodb.Driver.row_text (List.hd rows) 1)))
+
+let test_query_complex =
+  with_db (fun conn ->
+      let _ =
+        Repodb_sqlite.exec conn
+          "CREATE TABLE query_users (id INTEGER PRIMARY KEY, name TEXT, age \
+           INTEGER)"
+          ~params:[||]
+      in
+      for i = 1 to 20 do
+        let _ =
+          Repodb_sqlite.exec conn
+            (Printf.sprintf
+               "INSERT INTO query_users (name, age) VALUES ('User%d', %d)" i
+               (20 + i))
+            ~params:[||]
+        in
+        ()
+      done;
+      let query =
+        Repodb.Query.(
+          from query_users_table
+          |> where Repodb.Expr.(raw "age" >= int 30)
+          |> where Repodb.Expr.(raw "age" <= int 35)
+          |> asc (Repodb.Expr.raw "age")
+          |> limit 3 |> offset 1)
+      in
+      match Repo.all_query conn query ~decode:decode_query_user with
+      | Error e -> Alcotest.fail (Repodb.Error.show_db_error e)
+      | Ok users ->
+          Alcotest.(check int) "3 users" 3 (List.length users);
+          Alcotest.(check int) "first age 31" 31 (List.hd users).qu_age;
+          Alcotest.(check int) "last age 33" 33 (List.nth users 2).qu_age)
+
+let query_repo_tests =
+  [
+    ("all_query", `Quick, test_query_all_query);
+    ("where", `Quick, test_query_where);
+    ("one_query", `Quick, test_query_one_query);
+    ("one_query_not_found", `Quick, test_query_one_query_not_found);
+    ("one_query_opt", `Quick, test_query_one_query_opt);
+    ("order_limit", `Quick, test_query_order_limit);
+    ("insert_query", `Quick, test_query_insert_query);
+    ("update_query", `Quick, test_query_update_query);
+    ("delete_query", `Quick, test_query_delete_query);
+    ("complex", `Quick, test_query_complex);
+  ]
+
 let () =
   Alcotest.run "repodb-sqlite"
     [
···
       ("Errors", error_tests);
       ("Preload", preload_tests);
       ("Multi", multi_tests);
+      ("Query-Repo", query_repo_tests);
     ]

lib/repo.ml

···
     unit result
 
   val transaction : conn -> (conn -> 'a result) -> 'a result
+
+  (** Query execution functions - connect Query DSL to database *)
+
+  val all_query :
+    conn ->
+    ('a, Query.select_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b list result
+  (** Execute a SELECT query and return all matching rows *)
+
+  val one_query :
+    conn ->
+    ('a, Query.select_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b result
+  (** Execute a SELECT query and return the first row, or Not_found *)
+
+  val one_query_opt :
+    conn ->
+    ('a, Query.select_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b option result
+  (** Execute a SELECT query and return the first row as option *)
+
+  val insert_query : conn -> ('a, Query.insert_query) Query.t -> unit result
+  (** Execute an INSERT query *)
+
+  val update_query : conn -> ('a, Query.update_query) Query.t -> unit result
+  (** Execute an UPDATE query *)
+
+  val delete_query : conn -> ('a, Query.delete_query) Query.t -> unit result
+  (** Execute a DELETE query *)
+
+  val insert_query_returning :
+    conn ->
+    ('a, Query.insert_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b result
+  (** Execute an INSERT query with RETURNING clause *)
+
+  val update_query_returning :
+    conn ->
+    ('a, Query.update_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b list result
+  (** Execute an UPDATE query with RETURNING clause *)
+
+  val delete_query_returning :
+    conn ->
+    ('a, Query.delete_query) Query.t ->
+    decode:(Driver.row -> 'b) ->
+    'b list result
+  (** Execute a DELETE query with RETURNING clause *)
 end
 
 type savepoint = { name : string; depth : int }
···
               if List.length chunk < chunk_size then Ok () else loop ())
     in
     loop ()
+
+  let all_query conn query ~decode =
+    let sql = Query.to_sql query in
+    match D.query conn sql ~params:[||] with
+    | Ok rows -> Ok (List.map decode rows)
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let one_query conn query ~decode =
+    let sql = Query.(query |> limit 1 |> to_sql) in
+    match D.query_one conn sql ~params:[||] with
+    | Ok (Some row) -> Ok (decode row)
+    | Ok None -> Error Error.Not_found
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let one_query_opt conn query ~decode =
+    let sql = Query.(query |> limit 1 |> to_sql) in
+    match D.query_one conn sql ~params:[||] with
+    | Ok (Some row) -> Ok (Some (decode row))
+    | Ok None -> Ok None
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let insert_query conn query =
+    let sql = Query.to_sql query in
+    match D.exec conn sql ~params:[||] with
+    | Ok () -> Ok ()
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let update_query conn query =
+    let sql = Query.to_sql query in
+    match D.exec conn sql ~params:[||] with
+    | Ok () -> Ok ()
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let delete_query conn query =
+    let sql = Query.to_sql query in
+    match D.exec conn sql ~params:[||] with
+    | Ok () -> Ok ()
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let insert_query_returning conn query ~decode =
+    let sql = Query.to_sql query in
+    match D.query_one conn sql ~params:[||] with
+    | Ok (Some row) -> Ok (decode row)
+    | Ok None -> Error (Error.Query_failed "INSERT RETURNING returned no rows")
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let update_query_returning conn query ~decode =
+    let sql = Query.to_sql query in
+    match D.query conn sql ~params:[||] with
+    | Ok rows -> Ok (List.map decode rows)
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
+
+  let delete_query_returning conn query ~decode =
+    let sql = Query.to_sql query in
+    match D.query conn sql ~params:[||] with
+    | Ok rows -> Ok (List.map decode rows)
+    | Error e -> Error (driver_error_to_db_error (D.error_message e))
 end