extralite 2.11 → 2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99b4c44cc4b1661709179ecba90e49a459b76167a7aba1bea6eccb41e58305af
-  data.tar.gz: 56e8c49fe7f3f65285a1a89e1f435a1884e9d5a2af84e7caec5a4b635e70e345
+  metadata.gz: 6c7b8e712ebddb0de0f3ba623102fafb596f6396c79ed7d7aff5bb86a6781e60
+  data.tar.gz: e0e204499dd8fad21554f115ba8afeb53995ebf5175dc67eb420a6a1120ac030
 SHA512:
-  metadata.gz: b635937a6454102656f00fcae58c843263c39df38d445026888ec170984e483b08810f4a7418756c629cfff861d3fe35c77032f9dde67ed7f1d8ea4fb95df54b
-  data.tar.gz: b317e0a21b540558c595a129a5086862d3d9729349b27d337b2cfab086395299aec1217eb1a5099cdb65d8653600c4d023b4205e50ea2c4c3fb55f9ca2c02cd6
+  metadata.gz: dc879428575151f1194208b3929f9f7aeea79e843a024eb1688a149b9f298992d3004da24eaa32bfc16f2785ebc8153ef1f7159a0016560c3e27e128dd25ca00
+  data.tar.gz: a3965148daaf04792c5584aba4fd51b7d2e19bd138c677ab91691390182c8d1b0f7f24c2691c3316ba5a765e243a9258684cc4add69acc71a392355ffa1090fa

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.12 2025-03-25
+
+- Reimplement trace, provide trace proc with bound parameters [#80](https://github.com/digital-fabric/extralite/issues/80)
+
 ## 2.11 2025-03-14
 
 - Remove support for Ruby versions older than 3.2.

data/README.md

@@ -37,7 +37,7 @@ latest features and enhancements.
 
 ## Features
 
-- Best-in-class [performance](#performance) (up to 14X the performance of the
+- Best-in-class [performance](#performance) (up to 4.5X the performance of the
   [sqlite3](https://github.com/sparklemotion/sqlite3-ruby) gem).
 - Support for [concurrency](#concurrency) out of the box for multi-threaded
   and multi-fibered apps.
@@ -1216,12 +1216,20 @@ To trace all SQL statements executed on the database, pass a block to
 
 ```ruby
 # enable tracing
-db.trace { |sql| puts sql: sql }
+db.trace { |sql| p sql: sql }
 
 # disable tracing
 db.trace
 ```
 
+Any bound parameters will also be passed to the trace block:
+
+```ruby
+db.trace { |sql, *args| p sql: sql, args: args }
+db.query('select ?, ?', 1, 2)
+# { sql: "select ?, ?", args: [1, 2] }
+```
+
 ## Usage with Sequel
 
 Extralite includes an adapter for
@@ -1240,7 +1248,7 @@ p articles.to_a
 
 A benchmark script is included, creating a table of various row counts, then
 fetching the entire table using either `sqlite3` or `extralite`. This benchmark
-shows Extralite to be up to ~11 times faster than `sqlite3` when fetching a
+shows Extralite to be up to ~4.5 times faster than `sqlite3` when fetching a
 large number of rows.
 
 ### Rows as Hashes
@@ -1248,36 +1256,36 @@ large number of rows.
 [Benchmark source
 code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash.rb)
 
-|Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
+|Row count|sqlite3 2.6.0|Extralite 2.12|Advantage|
 |-:|-:|-:|-:|
-|10|184.9K rows/s|473.2K rows/s|__2.56x__|
-|1K|290.5K rows/s|2320.7K rows/s|__7.98x__|
-|100K|143.0K rows/s|2061.3K rows/s|__14.41x__|
+|10|629.0K rows/s|950.4K rows/s|__1.51x__|
+|1K|1770.5K rows/s|4321.5K rows/s|__2.44x__|
+|100K|1028.8K rows/s|4088.7K rows/s|__3.97x__|
 
 ### Rows as Arrays
 
 [Benchmark source
 code](https://github.com/digital-fabric/extralite/blob/main/test/perf_array.rb)
 
-|Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
+|Row count|sqlite3 2.6.0|Extralite 2.12|Advantage|
 |-:|-:|-:|-:|
-|10|278.0K rows/s|493.6K rows/s|__1.78x__|
-|1K|608.6K rows/s|2692.2K rows/s|__4.42x__|
-|100K|502.9K rows/s|2564.0K rows/s|__5.10x__|
+|10|889.4K rows/s|1000.1K rows/s|__1.13x__|
+|1K|4518.1K rows/s|5381.5K rows/s|__1.19x__|
+|100K|4454.0K rows/s|5083.8K rows/s|__1.14x__|
 
 ### Prepared Queries (Prepared Statements)
 
 [Benchmark source
 code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash_prepared.rb)
 
-|Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
+|Row count|sqlite3 2.6.0|Extralite 2.12|Advantage|
 |-:|-:|-:|-:|
-|10|228.5K rows/s|707.9K rows/s|__3.10x__|
-|1K|296.5K rows/s|2396.2K rows/s|__8.08x__|
-|100K|145.9K rows/s|2107.3K rows/s|__14.45x__|
+|10|783.1K rows/s|1115.1K rows/s|__1.42x__|
+|1K|1782.5K rows/s|4635.5K rows/s|__2.60x__|
+|100K|1018.1K rows/s|4599.4K rows/s|__4.52x__|
 
-As those benchmarks show, Extralite is capabale of reading up to 2.7M rows per
-second, and can be more than 14 times faster than the `sqlite3` gem.
+As those benchmarks show, Extralite is capabale of reading up to 4.5M rows per
+second, and can be more than 4 times faster than the `sqlite3` gem.
 
 Note that the benchmarks above were performed on synthetic data, in a
 single-threaded environment, with the GVL release threshold set to -1, which

data/ext/extralite/common.c

@@ -379,7 +379,7 @@ VALUE safe_query_hash(query_ctx *ctx) {
   while (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
     if (do_transform)
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
     row_count++;
     switch (ctx->row_mode) {
       case ROW_YIELD:
@@ -416,7 +416,7 @@ VALUE safe_query_hash(query_ctx *ctx) {
 #define ARGV_GET_ROW(ctx, column_count, argv_values, row, do_transform, return_rows) \
   row_to_splat_values(ctx->stmt, column_count, argv_values); \
   if (do_transform) \
-    row = rb_funcall2(ctx->transform_proc, ID_call, column_count, argv_values); \
+    row = INVOKE_PROC(ctx->transform_proc, column_count, argv_values); \
   else if (return_rows) \
     row = column_count == 1 ? argv_values[0] : rb_ary_new_from_values(column_count, argv_values);
 
@@ -468,7 +468,7 @@ VALUE safe_query_array(query_ctx *ctx) {
   while (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
     row_count++;
     switch (ctx->row_mode) {
       case ROW_YIELD:
@@ -497,7 +497,7 @@ VALUE safe_query_single_row_hash(query_ctx *ctx) {
   if (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
     if (!NIL_P(ctx->transform_proc))
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
   }
 
   RB_GC_GUARD(row);
@@ -530,7 +530,7 @@ VALUE safe_query_single_row_array(query_ctx *ctx) {
   if (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
   }
 
   RB_GC_GUARD(row);
@@ -554,7 +554,7 @@ static inline VALUE batch_iterate_hash(query_ctx *ctx) {
   while (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
     if (do_transform)
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
     rb_ary_push(rows, row);
   }
 
@@ -573,7 +573,7 @@ static inline VALUE batch_iterate_array(query_ctx *ctx) {
   while (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = rb_funcall(ctx->transform_proc, ID_call, 1, row);
+      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
     rb_ary_push(rows, row);
   }
 
@@ -619,6 +619,19 @@ static inline void batch_iterate(query_ctx *ctx, enum batch_mode mode, VALUE *ro
   }
 }
 
+static inline void invoke_pre_query_hook(query_ctx *ctx, VALUE params) {
+  int argc = 1;
+  switch (TYPE(params)) {
+    case T_ARRAY:
+      argc = -1;
+      break;
+    case T_NIL:
+      argc = 0;
+  }
+
+  Database_pre_query_hook(ctx->db, ctx->stmt, ctx->sql, argc, &params);
+}
+
 static inline VALUE batch_run_array(query_ctx *ctx, enum batch_mode batch_mode) {
   int count = RARRAY_LEN(ctx->params);
   int block_given = rb_block_given_p();
@@ -629,8 +642,9 @@ static inline VALUE batch_run_array(query_ctx *ctx, enum batch_mode batch_mode)
   for (int i = 0; i < count; i++) {
     sqlite3_reset(ctx->stmt);
     sqlite3_clear_bindings(ctx->stmt);
-    Database_issue_query(ctx->db, ctx->stmt);
-    bind_all_parameters_from_object(ctx->stmt, RARRAY_AREF(ctx->params, i));
+    VALUE params = RARRAY_AREF(ctx->params, i);
+    bind_all_parameters_from_object(ctx->stmt, params);
+    invoke_pre_query_hook(ctx, params);
 
     batch_iterate(ctx, batch_mode, &rows);
     changes += sqlite3_changes(ctx->sqlite3_db);
@@ -666,8 +680,8 @@ static VALUE batch_run_each_iter(RB_BLOCK_CALL_FUNC_ARGLIST(yield_value, vctx))
 
   sqlite3_reset(each_ctx->ctx->stmt);
   sqlite3_clear_bindings(each_ctx->ctx->stmt);
-  Database_issue_query(each_ctx->ctx->db, each_ctx->ctx->stmt);
   bind_all_parameters_from_object(each_ctx->ctx->stmt, yield_value);
+  invoke_pre_query_hook(each_ctx->ctx, yield_value);
 
   batch_iterate(each_ctx->ctx, each_ctx->batch_mode, &rows);
   each_ctx->changes += sqlite3_changes(each_ctx->ctx->sqlite3_db);
@@ -707,13 +721,13 @@ static inline VALUE batch_run_proc(query_ctx *ctx, enum batch_mode batch_mode) {
   int changes = 0;
 
   while (1) {
-    params = rb_funcall(ctx->params, ID_call, 0);
+    params = INVOKE_PROC(ctx->params, 0, NULL);
     if (NIL_P(params)) break;
 
     sqlite3_reset(ctx->stmt);
     sqlite3_clear_bindings(ctx->stmt);
-    Database_issue_query(ctx->db, ctx->stmt);
     bind_all_parameters_from_object(ctx->stmt, params);
+    invoke_pre_query_hook(ctx, params);
 
     batch_iterate(ctx, batch_mode, &rows);
     changes += sqlite3_changes(ctx->sqlite3_db);

data/ext/extralite/database.c

@@ -150,14 +150,15 @@ int Database_progress_handler(void *ptr) {
 
   db->progress_handler.tick_count -= db->progress_handler.period;
   db->progress_handler.call_count += 1;
-  rb_funcall(db->progress_handler.proc, ID_call, 0);
+  INVOKE_PROC(db->progress_handler.proc, 0, NULL);
 done:
   return 0;
 }
 
 int Database_busy_handler(void *ptr, int v) {
   Database_t *db = (Database_t *)ptr;
-  rb_funcall(db->progress_handler.proc, ID_call, 1, Qtrue);
+  VALUE arg = Qtrue;
+  INVOKE_PROC(db->progress_handler.proc, 1, &arg);
   return 1;
 }
 
@@ -297,7 +298,7 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
   if (stmt == NULL) return Qnil;
 
   bind_all_parameters(stmt, argc - 1, argv + 1);
-  Database_issue_query(db, stmt);
+  Database_pre_query_hook(db, stmt, sql, argc - 1, argv + 1);
 
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, Qnil, transform,
@@ -1104,16 +1105,45 @@ static inline enum progress_handler_mode symbol_to_progress_mode(VALUE mode) {
   rb_raise(eArgumentError, "Invalid progress handler mode");
 }
 
-inline void Database_issue_query(Database_t *db, sqlite3_stmt *stmt) {
-  if (db->trace_proc != Qnil) {
-    VALUE sql = rb_str_new_cstr(sqlite3_expanded_sql(stmt));
-    rb_funcall(db->trace_proc, ID_call, 1, sql);
-    RB_GC_GUARD(sql);
+#define MAX_TRACE_ARGS 16
+
+static inline void Database_trace_invoke(Database_t *db, VALUE sql, int argc, VALUE *argv) {
+  if (argc == 0)
+    INVOKE_PROC(db->trace_proc, 1, &sql);
+  else if (argc == -1) {
+    VALUE args = argv[0];
+    if (TYPE(args) == T_ARRAY) {
+      int args_len = RARRAY_LEN(args);
+      VALUE params = rb_ary_new_capa(args_len + 1);
+      rb_ary_push(params, sql);
+      for (int i = 0; i < args_len; i++)
+        rb_ary_push(params, RARRAY_AREF(args, i));
+      rb_proc_call_kw(db->trace_proc, params, RB_NO_KEYWORDS);
+      RB_GC_GUARD(params);
+    }
+    else
+      INVOKE_PROC(db->trace_proc, 1, &sql);
+  }
+  else if (argc > MAX_TRACE_ARGS) {
+    rb_raise(cError, "Too many arguments provided to trace proc");
+  }
+  else {
+    VALUE trace_argv[MAX_TRACE_ARGS];
+    trace_argv[0] = sql;
+    for (int i = 0; i < argc; i++)
+      trace_argv[i + 1] = argv[i];
+    INVOKE_PROC(db->trace_proc, argc + 1, trace_argv);
   }
+}
+
+inline void Database_pre_query_hook(Database_t *db, sqlite3_stmt *stmt, VALUE sql, int argc, VALUE *argv) {
+  if (db->trace_proc != Qnil)
+    Database_trace_invoke(db, sql, argc, argv);
+
   switch (db->progress_handler.mode) {
     case PROGRESS_AT_LEAST_ONCE:
     case PROGRESS_ONCE:
-      rb_funcall(db->progress_handler.proc, ID_call, 0);
+      INVOKE_PROC(db->progress_handler.proc, 0, NULL);
     default:
       ; // do nothing
 

data/ext/extralite/extralite.h

@@ -22,6 +22,8 @@
 
 #define SAFE(f) (VALUE (*)(VALUE))(f)
 
+#define INVOKE_PROC(proc, argc, argv) rb_proc_call_with_block(proc, argc, argv, Qnil)
+
 extern VALUE cDatabase;
 extern VALUE cQuery;
 extern VALUE cIterator;
@@ -76,14 +78,17 @@ enum query_mode {
 };
 
 typedef struct {
+  VALUE               self;
   VALUE               db;
   VALUE               sql;
   VALUE               transform_proc;
+  VALUE               bound_params;
   Database_t          *db_struct;
   sqlite3             *sqlite3_db;
   sqlite3_stmt        *stmt;
   int                 eof;
   int                 closed;
+  int                 should_reset;
   enum query_mode     query_mode;
 } Query_t;
 
@@ -180,7 +185,7 @@ void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj);
 int stmt_iterate(query_ctx *ctx);
 VALUE cleanup_stmt(query_ctx *ctx);
 
-void Database_issue_query(Database_t *db, sqlite3_stmt *stmt);
+void Database_pre_query_hook(Database_t *db, sqlite3_stmt *stmt, VALUE sql, int argc, VALUE *argv);
 sqlite3 *Database_sqlite3_db(VALUE self);
 enum gvl_mode Database_prepare_gvl_mode(Database_t *db);
 Database_t *self_to_database(VALUE self);

data/ext/extralite/query.c

@@ -29,6 +29,7 @@ static void Query_mark(void *ptr) {
   rb_gc_mark_movable(query->db);
   rb_gc_mark_movable(query->sql);
   rb_gc_mark_movable(query->transform_proc);
+  rb_gc_mark_movable(query->bound_params);
 }
 
 static void Query_compact(void *ptr) {
@@ -36,6 +37,7 @@ static void Query_compact(void *ptr) {
   query->db = rb_gc_location(query->db);
   query->sql = rb_gc_location(query->sql);
   query->transform_proc = rb_gc_location(query->transform_proc);
+  query->bound_params = rb_gc_location(query->bound_params);
 }
 
 static void Query_free(void *ptr) {
@@ -55,6 +57,7 @@ static VALUE Query_allocate(VALUE klass) {
   query->db = Qnil;
   query->sql = Qnil;
   query->transform_proc = Qnil;
+  query->bound_params = Qnil;
   query->sqlite3_db = NULL;
   query->stmt = NULL;
   return TypedData_Wrap_Struct(klass, &Query_type, query);
@@ -66,6 +69,14 @@ static inline Query_t *self_to_query(VALUE obj) {
   return query;
 }
 
+// verifies that the query is not closed
+static inline Query_t *self_to_query_verify(VALUE obj) {
+  Query_t *query = self_to_query(obj);
+  if (query->closed) rb_raise(cError, "Query is closed");
+  return query;
+}
+
+
 static inline enum query_mode symbol_to_query_mode(VALUE sym) {
   if (sym == SYM_hash)          return QUERY_HASH;
   if (sym == SYM_splat)         return QUERY_SPLAT;
@@ -109,12 +120,14 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql, VALUE mode) {
   if (rb_block_given_p())
     RB_OBJ_WRITE(self, &query->transform_proc, rb_block_proc());
 
+  query->self = self;
   query->db = db;
   query->db_struct = self_to_database(db);
   query->sqlite3_db = Database_sqlite3_db(db);
   query->stmt = NULL;
   query->closed = 0;
   query->eof = 0;
+  query->should_reset = 0;
   query->query_mode = symbol_to_query_mode(mode);
 
   return Qnil;
@@ -123,20 +136,31 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql, VALUE mode) {
 static inline void query_reset(Query_t *query) {
   if (!query->stmt)
     prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
-  Database_issue_query(query->db_struct, query->stmt);
-  sqlite3_reset(query->stmt);
+  else
+    sqlite3_reset(query->stmt);
+
+  Database_pre_query_hook(query->db_struct, query->stmt, query->sql, query->bound_params == Qnil ? 0 : -1, &query->bound_params);
+
   query->eof = 0;
+  query->should_reset = 0;
 }
 
-static inline void query_reset_and_bind(Query_t *query, int argc, VALUE * argv) {
+static inline void query_bind(Query_t *query, int argc, VALUE * argv) {
   if (!query->stmt)
     prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
-  Database_issue_query(query->db_struct, query->stmt);
-  sqlite3_reset(query->stmt);
-  query->eof = 0;
+  else
+    // we call sqlite3_reset because that's what the SQLite API expects before
+    // changing the binding. See note at bottom of
+    // https://www.sqlite.org/c3ref/bind_blob.html
+    sqlite3_reset(query->stmt);
+  
+  sqlite3_clear_bindings(query->stmt);
   if (argc > 0) {
-    sqlite3_clear_bindings(query->stmt);
     bind_all_parameters(query->stmt, argc, argv);
+    RB_OBJ_WRITE(query->self, &query->bound_params, rb_ary_new_from_values(argc, argv));
+  }
+  else {
+    RB_OBJ_WRITE(query->self, &query->bound_params, Qnil);
   }
 }
 
@@ -154,8 +178,7 @@ static inline void query_reset_and_bind(Query_t *query, int argc, VALUE * argv)
  * @return [Extralite::Query] self
  */
 VALUE Query_reset(VALUE self) {
-  Query_t *query = self_to_query(self);
-  if (query->closed) rb_raise(cError, "Query is closed");
+  Query_t *query = self_to_query_verify(self);
 
   query_reset(query);
   return self;
@@ -183,10 +206,10 @@ VALUE Query_reset(VALUE self) {
  * @return [Extralite::Query] self
  */
 VALUE Query_bind(int argc, VALUE *argv, VALUE self) {
-  Query_t *query = self_to_query(self);
-  if (query->closed) rb_raise(cError, "Query is closed");
+  Query_t *query = self_to_query_verify(self);
 
-  query_reset_and_bind(query, argc, argv);
+  query_bind(query, argc, argv);
+  query->should_reset = 1;
   return self;
 }
 
@@ -195,8 +218,7 @@ VALUE Query_bind(int argc, VALUE *argv, VALUE self) {
  * @return [boolean] true if iteration has reached the end of the result set
  */
 VALUE Query_eof_p(VALUE self) {
-  Query_t *query = self_to_query(self);
-  if (query->closed) rb_raise(cError, "Query is closed");
+  Query_t *query = self_to_query_verify(self);
 
   return query->eof ? Qtrue : Qfalse;
 }
@@ -204,10 +226,9 @@ VALUE Query_eof_p(VALUE self) {
 #define MAX_ROWS(max_rows) (max_rows == SINGLE_ROW ? 1 : max_rows)
 
 static inline VALUE Query_perform_next(VALUE self, int max_rows, safe_query_impl call) {
-  Query_t *query = self_to_query(self);
-  if (query->closed) rb_raise(cError, "Query is closed");
+  Query_t *query = self_to_query_verify(self);
 
-  if (!query->stmt) query_reset(query);
+  if (!query->stmt || query->should_reset) query_reset(query);
   if (query->eof) return rb_block_given_p() ? self : Qnil;
 
   query_ctx ctx = QUERY_CTX(
@@ -258,7 +279,7 @@ inline safe_query_impl query_impl(enum query_mode query_mode) {
  *   @return [Array<any>, Extralite::Query] next rows or self if block is given
  */
 VALUE Query_next(int argc, VALUE *argv, VALUE self) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   rb_check_arity(argc, 0, 1);
   return Query_perform_next(self, MAX_ROWS_FROM_ARGV(argc, argv), query_impl(query->query_mode));
 }
@@ -269,7 +290,7 @@ VALUE Query_next(int argc, VALUE *argv, VALUE self) {
  * @return [Array<any>] all rows
  */
 VALUE Query_to_a(VALUE self) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   query_reset(query);
   return Query_perform_next(self, ALL_ROWS, query_impl(query->query_mode));
 }
@@ -283,7 +304,7 @@ VALUE Query_to_a(VALUE self) {
 VALUE Query_each(VALUE self) {
   if (!rb_block_given_p()) return rb_funcall(cIterator, ID_new, 1, self);
 
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   query_reset(query);
   return Query_perform_next(self, ALL_ROWS, query_impl(query->query_mode));
 }
@@ -312,8 +333,9 @@ VALUE Query_each(VALUE self) {
  *     query.execute(':bar' => 42)
  */
 VALUE Query_execute(int argc, VALUE *argv, VALUE self) {
-  Query_t *query = self_to_query(self);
-  query_reset_and_bind(query, argc, argv);
+  Query_t *query = self_to_query_verify(self);
+  query_bind(query, argc, argv);
+  query_reset(query);
   return Query_perform_next(self, ALL_ROWS, safe_query_changes);
 }
 
@@ -377,7 +399,7 @@ VALUE Query_execute_chevrons(VALUE self, VALUE params) {
  * @return [Integer] number of changes effected
  */
 VALUE Query_batch_execute(VALUE self, VALUE parameters) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
@@ -426,7 +448,7 @@ VALUE Query_batch_execute(VALUE self, VALUE parameters) {
  * @return [Array<Array>, Integer] Returned rows or total number of changes effected
  */
 VALUE Query_batch_query(VALUE self, VALUE parameters) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
@@ -472,7 +494,7 @@ VALUE Query_sql(VALUE self) {
  * @return [Array<Symbol>] column names
  */
 VALUE Query_columns(VALUE self) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
   query_reset(query);
   return Query_perform_next(self, ALL_ROWS, safe_query_columns);
 }
@@ -535,8 +557,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
 
   rb_scan_args(argc, argv, "11", &op, &reset);
 
-  Query_t *query = self_to_query(self);
-  if (query->closed) rb_raise(cError, "Query is closed");
+  Query_t *query = self_to_query_verify(self);
 
   if (!query->stmt)
     prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
@@ -560,7 +581,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
  * @return [Extralite::Query] query
  */
 VALUE Query_transform(VALUE self) {
-  Query_t *query = self_to_query(self);
+  Query_t *query = self_to_query_verify(self);
 
   RB_OBJ_WRITE(self, &query->transform_proc, rb_block_given_p() ? rb_block_proc() : Qnil);
   return self;

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.11'
+  VERSION = '2.12'
 end

data/test/perf_array.rb

@@ -4,7 +4,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'sqlite3'
+  gem 'sqlite3', '2.6.0'
   gem 'extralite', path: '..'
   gem 'benchmark-ips'
 end

data/test/perf_hash.rb

@@ -7,7 +7,7 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'extralite', path: '..'
-  gem 'sqlite3'
+  gem 'sqlite3', '2.6.0'
   gem 'benchmark-ips'
 end
 

data/test/perf_hash_prepared.rb

@@ -5,7 +5,7 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'extralite', path: '..'
-  gem 'sqlite3'
+  gem 'sqlite3', '2.6.0'
   gem 'benchmark-ips'
 end
 

data/test/perf_polyphony.rb

@@ -20,7 +20,7 @@ $db2 = Extralite::Database.new(DB_PATH, gvl_release_threshold: 0)
 $db3 = Extralite::Database.new(DB_PATH)
 
 $snooze_count = 0
-$db3.on_progress(25) { $snooze_count += 1; snooze }
+$db3.on_progress(tick: 50, period: 100, mode: :at_least_once) { $snooze_count += 1; snooze }
 
 def prepare_database(count)
   $db1.execute('create table if not exists foo ( a integer primary key, b text )')

data/test/perf_splat.rb

@@ -4,7 +4,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'sqlite3'
+  gem 'sqlite3', '2.6.0'
   gem 'extralite', path: '..'
   gem 'benchmark-ips'
 end

data/test/test_database.rb

@@ -1221,6 +1221,8 @@ class ScenarioTest < Minitest::Test
     t2&.kill
   end
 
+  # Note: more comprehensive testing of the trace functionality is done in
+  # test_trace.rb
   def test_database_trace
     sqls = []
     @db.trace { |sql| sqls << sql }
@@ -1245,18 +1247,6 @@ class ScenarioTest < Minitest::Test
     @db.query('select 4')
     assert_equal ['select 1', 'select 2', 'select 3'], sqls
   end
-
-  def test_database_trace_expanded_sql
-    sqls = []
-    @db.trace { |sql| sqls << sql }
-
-    @db.query('select ?, ?, ?', 1, '2', 3)
-    assert_equal ["select 1, '2', 3"], sqls
-
-    sqls = []
-    @db.query('select :x, :y, :z', x: 42, y: '43')
-    assert_equal ["select 42, '43', NULL"], sqls
-  end
 end
 
 class BackupTest < Minitest::Test
@@ -1337,7 +1327,7 @@ class ConcurrencyTest < Minitest::Test
     t2.join
     t1.join
 
-    assert delays.size > 4
+    assert_in_range 4.., delays.size
     assert_equal 0, delays.select { |d| d > 0.15 }.size
   ensure
     t1&.kill

data/test/test_trace.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'date'
+require 'json'
+
+class DatabaseTraceTest < Minitest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+
+    @trace_buf = []
+    @db.trace { |sql, *args| @trace_buf << { sql: sql, args: args } }
+  end
+
+  def test_trace_database_query
+    @db.query('select 1')
+    @db.query('select ?', 2)
+    @db.query('select ?, ?, ?', 3, 4, 5)
+    @db.query('select :x, :y, :z', x: 6, y: 7)
+
+    assert_equal [
+      { sql: 'select 1', args: [] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?, ?, ?', args: [3, 4, 5] },
+      { sql: 'select :x, :y, :z', args: [{ x: 6, y: 7 }] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_execute
+    @db.execute('select 1')
+    @db.execute('select ?', 2)
+    @db.execute('select ?, ?, ?', 3, 4, 5)
+    @db.execute('select :x, :y, :z', x: 6, y: 7)
+
+    assert_equal [
+      { sql: 'select 1', args: [] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?, ?, ?', args: [3, 4, 5] },
+      { sql: 'select :x, :y, :z', args: [{ x: 6, y: 7 }] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_query_xxx
+    @db.query_single('select 1')
+    @db.query_array('select ?', 2)
+    @db.query_splat('select ?, ?, ?', 3, 4, 5)
+    @db.query_single_array('select :x, :y, :z', x: 6, y: 7)
+
+    assert_equal [
+      { sql: 'select 1', args: [] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?, ?, ?', args: [3, 4, 5] },
+      { sql: 'select :x, :y, :z', args: [{ x: 6, y: 7 }] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_batch_execute
+    @db.batch_execute('select ?', [1, 2, 3])
+    @db.batch_execute('select ?, ?', [[44, 55], [66, 77]])
+    @db.batch_execute('select :x, :y', [{ x: 5, y: 6 }, { x: 7, y: 8 }])
+
+    assert_equal [
+      { sql: 'select ?', args: [1] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?', args: [3] },
+      { sql: 'select ?, ?', args: [44, 55] },
+      { sql: 'select ?, ?', args: [66, 77] },
+      { sql: 'select :x, :y', args: [{ x: 5, y: 6 }] },
+      { sql: 'select :x, :y', args: [{ x: 7, y: 8 }] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_batch_query
+    @db.batch_query('select ?', [1, 2, 3])
+    @db.batch_query('select ?, ?', [[44, 55], [66, 77]])
+    @db.batch_query('select :x, :y', [{ x: 5, y: 6 }, { x: 7, y: 8 }])
+
+    assert_equal [
+      { sql: 'select ?', args: [1] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?', args: [3] },
+      { sql: 'select ?, ?', args: [44, 55] },
+      { sql: 'select ?, ?', args: [66, 77] },
+      { sql: 'select :x, :y', args: [{ x: 5, y: 6 }] },
+      { sql: 'select :x, :y', args: [{ x: 7, y: 8 }] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_batch_query_with_enumerable
+    @db.batch_query('select ?', 1..3)
+    
+    assert_equal [
+      { sql: 'select ?', args: [1] },
+      { sql: 'select ?', args: [2] },
+      { sql: 'select ?', args: [3] }
+    ], @trace_buf
+  end
+
+  def test_trace_database_batch_query_with_proc
+    values = [4, 5, 6]
+
+    @db.batch_query('select ?', -> { values.shift })
+    
+    assert_equal [
+      { sql: 'select ?', args: [4] },
+      { sql: 'select ?', args: [5] },
+      { sql: 'select ?', args: [6] }
+    ], @trace_buf
+  end
+end
+
+class QueryTraceTest < Minitest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+
+    @query = @db.prepare('select ?')
+
+    @trace_buf = []
+    @db.trace { |sql, *args| @trace_buf << { sql: sql, args: args } }
+  end
+
+  def test_trace_query_iteration
+    assert_equal [], @trace_buf
+
+    @query.bind(42)
+    assert_equal [], @trace_buf
+
+    @query.to_a
+    assert_equal [
+      { sql: 'select ?', args: [42] },
+    ], @trace_buf
+
+    @query.to_a
+    assert_equal [
+      { sql: 'select ?', args: [42] },
+      { sql: 'select ?', args: [42] }
+    ], @trace_buf
+
+    @query.bind(44)
+    assert_equal [
+      { sql: 'select ?', args: [42] },
+      { sql: 'select ?', args: [42] }
+    ], @trace_buf
+
+    @query.reset
+    assert_equal [
+      { sql: 'select ?', args: [42] },
+      { sql: 'select ?', args: [42] },
+      { sql: 'select ?', args: [44] }
+    ], @trace_buf
+
+    @trace_buf = []
+    @query.bind(46)
+    assert_equal [], @trace_buf
+
+    @query.each { }
+    assert_equal [
+      { sql: 'select ?', args: [46] }
+    ], @trace_buf
+
+    @trace_buf = []
+    @query.bind(48)
+    assert_equal [], @trace_buf
+
+    e = @query.each
+    e.to_a
+    assert_equal [
+      { sql: 'select ?', args: [48] }
+    ], @trace_buf
+
+    e.map {}
+    assert_equal [
+      { sql: 'select ?', args: [48] },
+      { sql: 'select ?', args: [48] }
+    ], @trace_buf
+  end
+
+  def test_trace_query_batch_execute
+    assert_equal [], @trace_buf
+
+    @query.batch_execute([42, 43, 44])
+    assert_equal [
+      { sql: 'select ?', args: [42] },
+      { sql: 'select ?', args: [43] },
+      { sql: 'select ?', args: [44] },
+    ], @trace_buf
+    
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '2.11'
+  version: '2.12'
 platform: ruby
 authors:
 - Sharon Rosner
 bindir: bin
 cert_chain: []
-date: 2025-03-14 00:00:00.000000000 Z
+date: 2025-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -144,6 +144,7 @@ files:
 - test/test_iterator.rb
 - test/test_query.rb
 - test/test_sequel.rb
+- test/test_trace.rb
 homepage: https://github.com/digital-fabric/extralite
 licenses:
 - MIT