extralite 2.7.1 → 2.8.1

data/ext/extralite/database.c

@@ -22,12 +22,16 @@ ID ID_to_s;
 ID ID_track;
 
 VALUE SYM_at_least_once;
+VALUE SYM_full;
 VALUE SYM_gvl_release_threshold;
 VALUE SYM_once;
 VALUE SYM_none;
 VALUE SYM_normal;
+VALUE SYM_passive;
 VALUE SYM_pragma;
 VALUE SYM_read_only;
+VALUE SYM_restart;
+VALUE SYM_truncate;
 VALUE SYM_wal;
 
 struct progress_handler global_progress_handler = {
@@ -290,6 +294,8 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
   prepare_multi_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
   RB_GC_GUARD(sql);
 
+  if (stmt == NULL) return Qnil;
+
   bind_all_parameters(stmt, argc - 1, argv + 1);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, Qnil, transform,
@@ -342,18 +348,18 @@ VALUE Database_query(int argc, VALUE *argv, VALUE self) {
  * splatted:
  *
  *     transform = ->(a, b, c) { a * 100 + b * 10 + c }
- *     db.query_argv(transform, 'select a, b, c from foo where c = ?', 42)
+ *     db.query_splat(transform, 'select a, b, c from foo where c = ?', 42)
  *
- * @overload query_argv(sql, ...)
+ * @overload query_splat(sql, ...)
  *   @param sql [String] SQL statement
  *   @return [Array<Array, any>, Integer] rows or total changes
- * @overload query_argv(transform, sql, ...)
+ * @overload query_splat(transform, sql, ...)
  *   @param transform [Proc] transform proc
  *   @param sql [String] SQL statement
  *   @return [Array<Array, any>, Integer] rows or total changes
  */
-VALUE Database_query_argv(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_argv, QUERY_ARGV);
+VALUE Database_query_splat(int argc, VALUE *argv, VALUE self) {
+  return Database_perform_query(argc, argv, self, safe_query_splat, QUERY_SPLAT);
 }
 
 /* Runs a query returning rows as arrays. If a block is given, it will be called
@@ -364,26 +370,26 @@ VALUE Database_query_argv(int argc, VALUE *argv, VALUE self) {
  * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
- *     db.query_ary('select * from foo where x = ?', 42)
+ *     db.query_array('select * from foo where x = ?', 42)
  *
  * Named placeholders are specified using `:`. The placeholder values are
  * specified using a hash, where keys are either strings are symbols. String
  * keys can include or omit the `:` prefix. The following are equivalent:
  *
- *     db.query_ary('select * from foo where x = :bar', bar: 42)
- *     db.query_ary('select * from foo where x = :bar', 'bar' => 42)
- *     db.query_ary('select * from foo where x = :bar', ':bar' => 42)
+ *     db.query_array('select * from foo where x = :bar', bar: 42)
+ *     db.query_array('select * from foo where x = :bar', 'bar' => 42)
+ *     db.query_array('select * from foo where x = :bar', ':bar' => 42)
  * 
- * @overload query_ary(sql, ...)
+ * @overload query_array(sql, ...)
  *   @param sql [String] SQL statement
  *   @return [Array<Array>, Integer] rows or total changes
- * @overload query_ary(transform, sql, ...)
+ * @overload query_array(transform, sql, ...)
  *   @param transform [Proc] transform proc
  *   @param sql [String] SQL statement
  *   @return [Array<Array>, Integer] rows or total changes
  */
-VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_ary, QUERY_ARY);
+VALUE Database_query_array(int argc, VALUE *argv, VALUE self) {
+  return Database_perform_query(argc, argv, self, safe_query_array, QUERY_ARRAY);
 }
 
 /* Runs a query returning a single row as a hash.
@@ -419,23 +425,23 @@ VALUE Database_query_single(int argc, VALUE *argv, VALUE self) {
  * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
- *     db.query_single_argv('select * from foo where x = ?', 42)
+ *     db.query_single_splat('select * from foo where x = ?', 42)
  *
  * Named placeholders are specified using `:`. The placeholder values are
  * specified using keyword arguments:
  *
- *     db.query_single_argv('select * from foo where x = :bar', bar: 42)
+ *     db.query_single_splat('select * from foo where x = :bar', bar: 42)
  * 
- * @overload query_single_argv(sql, ...) -> row
+ * @overload query_single_splat(sql, ...) -> row
  *   @param sql [String] SQL statement
  *   @return [Array, any] row
- * @overload query_single_argv(transform, sql, ...) -> row
+ * @overload query_single_splat(transform, sql, ...) -> row
  *   @param transform [Proc] transform proc
  *   @param sql [String] SQL statement
  *   @return [Array, any] row
  */
-VALUE Database_query_single_argv(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_single_row_argv, QUERY_ARGV);
+VALUE Database_query_single_splat(int argc, VALUE *argv, VALUE self) {
+  return Database_perform_query(argc, argv, self, safe_query_single_row_splat, QUERY_SPLAT);
 }
 
 /* Runs a query returning a single row as an array.
@@ -445,23 +451,23 @@ VALUE Database_query_single_argv(int argc, VALUE *argv, VALUE self) {
  * parameters are given as an array, the query should specify parameters using
  * `?`:
  *
- *     db.query_single_ary('select * from foo where x = ?', 42)
+ *     db.query_single_array('select * from foo where x = ?', 42)
  *
  * Named placeholders are specified using `:`. The placeholder values are
  * specified using keyword arguments:
  *
- *     db.query_single_ary('select * from foo where x = :bar', bar: 42)
+ *     db.query_single_array('select * from foo where x = :bar', bar: 42)
  * 
- * @overload query_single_ary(sql, ...) -> row
+ * @overload query_single_array(sql, ...) -> row
  *   @param sql [String] SQL statement
  *   @return [Array, any] row
- * @overload query_single_ary(transform, sql, ...) -> row
+ * @overload query_single_array(transform, sql, ...) -> row
  *   @param transform [Proc] transform proc
  *   @param sql [String] SQL statement
  *   @return [Array, any] row
  */
-VALUE Database_query_single_ary(int argc, VALUE *argv, VALUE self) {
-  return Database_perform_query(argc, argv, self, safe_query_single_row_ary, QUERY_ARY);
+VALUE Database_query_single_array(int argc, VALUE *argv, VALUE self) {
+  return Database_perform_query(argc, argv, self, safe_query_single_row_array, QUERY_ARRAY);
 }
 
 /* call-seq:
@@ -481,6 +487,10 @@ VALUE Database_query_single_ary(int argc, VALUE *argv, VALUE self) {
  * specified using keyword arguments:
  *
  *     db.execute('update foo set x = :bar', bar: 42)
+ *
+ * @param sql [String] query SQL
+ * @param parameters [Array, Hash] parameters to run query with
+ * @return [Integer, nil] Total number of changes effected or `nil` if the query ends with a comment.
  */
 VALUE Database_execute(int argc, VALUE *argv, VALUE self) {
   return Database_perform_query(argc, argv, self, safe_query_changes, QUERY_HASH);
@@ -532,6 +542,8 @@ VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
 /* call-seq:
  *   db.batch_query(sql, params_source) -> rows
  *   db.batch_query(sql, params_source) { |rows| ... } -> changes
+ *   db.batch_query_hash(sql, params_source) -> rows
+ *   db.batch_query_hash(sql, params_source) { |rows| ... } -> changes
  *
  * Executes the given query for each list of parameters in the given paramter
  * source. If a block is given, it is called with the resulting rows for each
@@ -564,8 +576,8 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
 }
 
 /* call-seq:
- *   db.batch_query_ary(sql, params_source) -> rows
- *   db.batch_query_ary(sql, params_source) { |rows| ... } -> changes
+ *   db.batch_query_array(sql, params_source) -> rows
+ *   db.batch_query_array(sql, params_source) { |rows| ... } -> changes
  *
  * Executes the given query for each list of parameters in the given paramter
  * source. If a block is given, it is called with the resulting rows for each
@@ -577,29 +589,29 @@ VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
  *       [1, 2],
  *       [3, 4]
  *     ]
- *     db.batch_query_ary('insert into foo values (?, ?) returning bar, baz', records)
+ *     db.batch_query_array('insert into foo values (?, ?) returning bar, baz', records)
  *     #=> [[1, 2], [3, 4]]
  * *
  * @param sql [String] query SQL
  * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
  * @return [Array<Array>, Integer] Total number of changes effected
  */
-VALUE Database_batch_query_ary(VALUE self, VALUE sql, VALUE parameters) {
+VALUE Database_batch_query_array(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
   prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
-    Qnil, QUERY_ARY, ROW_MULTI, ALL_ROWS
+    Qnil, QUERY_ARRAY, ROW_MULTI, ALL_ROWS
   );
 
-  return rb_ensure(SAFE(safe_batch_query_ary), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+  return rb_ensure(SAFE(safe_batch_query_array), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
 
 /* call-seq:
- *   db.batch_query_argv(sql, params_source) -> rows
- *   db.batch_query_argv(sql, params_source) { |rows| ... } -> changes
+ *   db.batch_query_splat(sql, params_source) -> rows
+ *   db.batch_query_splat(sql, params_source) { |rows| ... } -> changes
  *
  * Executes the given query for each list of parameters in the given paramter
  * source. If a block is given, it is called with the resulting rows for each
@@ -611,24 +623,24 @@ VALUE Database_batch_query_ary(VALUE self, VALUE sql, VALUE parameters) {
  *       [1, 2],
  *       [3, 4]
  *     ]
- *     db.batch_query_argv('insert into foo values (?, ?) returning baz', records)
+ *     db.batch_query_splat('insert into foo values (?, ?) returning baz', records)
  *     #=> [2, 4]
  * *
  * @param sql [String] query SQL
  * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
  * @return [Array<any>, Integer] Total number of changes effected
  */
-VALUE Database_batch_query_argv(VALUE self, VALUE sql, VALUE parameters) {
+VALUE Database_batch_query_splat(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
   prepare_single_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
   query_ctx ctx = QUERY_CTX(
     self, sql, db, stmt, parameters,
-    Qnil, QUERY_ARGV, ROW_MULTI, ALL_ROWS
+    Qnil, QUERY_SPLAT, ROW_MULTI, ALL_ROWS
   );
 
-  return rb_ensure(SAFE(safe_batch_query_argv), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+  return rb_ensure(SAFE(safe_batch_query_splat), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
 
 /* Returns the column names for the given query, without running it.
@@ -738,9 +750,9 @@ VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   db.prepare_argv(sql) -> Extralite::Query
- *   db.prepare_argv(sql, *params) -> Extralite::Query
- *   db.prepare_argv(sql, *params) { ... } -> Extralite::Query
+ *   db.prepare_splat(sql) -> Extralite::Query
+ *   db.prepare_splat(sql, *params) -> Extralite::Query
+ *   db.prepare_splat(sql, *params) { ... } -> Extralite::Query
  *
  * Creates a prepared query with the given SQL query in argv mode. If query
  * parameters are given, they are bound to the query. If a block is given, it is
@@ -750,16 +762,16 @@ VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
  * @param *params [Array<any>] parameters to bind
  * @return [Extralite::Query] prepared query
  */
-VALUE Database_prepare_argv(int argc, VALUE *argv, VALUE self) {
-  return Database_prepare(argc, argv, self, SYM_argv);
+VALUE Database_prepare_splat(int argc, VALUE *argv, VALUE self) {
+  return Database_prepare(argc, argv, self, SYM_splat);
 }
 
 /* call-seq:
- *   db.prepare_ary(sql) -> Extralite::Query
- *   db.prepare_ary(sql, *params) -> Extralite::Query
- *   db.prepare_ary(sql, *params) { ... } -> Extralite::Query
+ *   db.prepare_array(sql) -> Extralite::Query
+ *   db.prepare_array(sql, *params) -> Extralite::Query
+ *   db.prepare_array(sql, *params) { ... } -> Extralite::Query
  *
- * Creates a prepared query with the given SQL query in ary mode. If query
+ * Creates a prepared query with the given SQL query in array mode. If query
  * parameters are given, they are bound to the query. If a block is given, it is
  * used as a transform proc.
  * 
@@ -767,8 +779,8 @@ VALUE Database_prepare_argv(int argc, VALUE *argv, VALUE self) {
  * @param *params [Array<any>] parameters to bind
  * @return [Extralite::Query] prepared query
  */
-VALUE Database_prepare_ary(int argc, VALUE *argv, VALUE self) {
-  return Database_prepare(argc, argv, self, SYM_ary);
+VALUE Database_prepare_array(int argc, VALUE *argv, VALUE self) {
+  return Database_prepare(argc, argv, self, SYM_array);
 }
 
 /* Interrupts a long running query. This method is to be called from a different
@@ -853,11 +865,7 @@ VALUE backup_cleanup(VALUE ptr) {
   return Qnil;
 }
 
-/* call-seq:
- *   db.backup(dest, src_db_name = 'main', dst_db_name = 'main') { |remaining, total| ... } -> db
- *
- * 
- * Creates a backup of the database to the given destination, which can be
+/* Creates a backup of the database to the given destination, which can be
  * either a filename or a database instance. In order to monitor the backup
  * progress you can pass a block that will be called periodically by the backup
  * method with two arguments: the remaining page count, and the total page
@@ -871,6 +879,8 @@ VALUE backup_cleanup(VALUE ptr) {
  * @param dest [String, Extralite::Database] backup destination
  * @param src_db_name [String] source database name (default: "main")
  * @param dst_db_name [String] Destination database name (default: "main")
+ * @yieldparam remaining [Integer] remaining page count
+ * @yieldparam total [Integer] total page count
  * @return [Extralite::Database] source database
  */
 VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
@@ -920,6 +930,13 @@ VALUE Database_backup(int argc, VALUE *argv, VALUE self) {
 /* Returns runtime status values for the given op as an array containing the
  * current value and the high water mark value. To reset the high water mark,
  * pass true as reset.
+ * 
+ * You can use the various `Extralite::SQLITE_STATUS_xxx` constants with this
+ * method:
+ * 
+ *     Extralite.runtime_status(Extralite::SQLITE_STATUS_MEMORY_USED)
+ * 
+ * For more information see the SQLite docs: https://sqlite.org/c3ref/c_status_malloc_count.html
  *
  * @overload runtime_status(op)
  *   @param op [Integer] op
@@ -1404,6 +1421,53 @@ VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
   return INT2NUM(db->gvl_release_threshold);
 }
 
+int checkpoint_mode_symbol_to_int(VALUE mode) {
+  if (mode == SYM_passive)  return SQLITE_CHECKPOINT_PASSIVE;
+  if (mode == SYM_full)     return SQLITE_CHECKPOINT_FULL;
+  if (mode == SYM_restart)  return SQLITE_CHECKPOINT_RESTART;
+  if (mode == SYM_truncate) return SQLITE_CHECKPOINT_TRUNCATE;
+
+  rb_raise(eArgumentError, "Invalid WAL checkpoint mode specified");
+}
+
+/* Runs a WAL checkpoint operation with the given mode. If a database name is
+ * given, the checkpoint operation is ran on the corresponding attached
+ * database, otherwise it is run on the main database. Returns an array
+ * containing the total number of frames in the WAL file, and the number of
+ * frames checkpointed. For more information see:
+ *   https://sqlite.org/c3ref/wal_checkpoint_v2.html
+ *
+ * @overload wal_checkpoint(mode)
+ *   @param mode [Symbol] checkpoint mode (`:passive`, `:full`, `:restart`, `:truncate`)
+ *   @return [Array<int>] total and checkpointed frame count
+ * @overload wal_checkpoint(mode, db_name)
+ *   @param mode [Symbol] checkpoint mode (`:passive`, `:full`, `:restart`, `:truncate`)
+ *   @param db_name [String] attached database name
+ *   @return [Array<int>] total and checkpointed frame count
+*/
+VALUE Database_wal_checkpoint(int argc, VALUE *argv, VALUE self) {
+  Database_t *db = self_to_open_database(self);
+  VALUE mode = Qnil;
+  VALUE db_name = Qnil;
+  int total_frames;
+  int checkpointed_frames;
+
+  rb_scan_args(argc, argv, "11", &mode, &db_name);
+
+  int mode_int = checkpoint_mode_symbol_to_int(mode);
+  int rc = sqlite3_wal_checkpoint_v2(
+    db->sqlite3_db,
+    NIL_P(db_name) ? NULL : StringValueCStr(db_name),
+    mode_int,
+    &total_frames,
+    &checkpointed_frames
+  );
+  if (rc != SQLITE_OK)
+    rb_raise(cError, "Failed to perform WAL checkpoint: %s", sqlite3_errstr(rc));
+  
+  return rb_ary_new3(2, INT2NUM(total_frames), INT2NUM(checkpointed_frames));
+}
+
 void Init_ExtraliteDatabase(void) {
   VALUE mExtralite = rb_define_module("Extralite");
   rb_define_singleton_method(mExtralite, "runtime_status", Extralite_runtime_status, -1);
@@ -1416,8 +1480,8 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "backup",                 Database_backup, -1);
   rb_define_method(cDatabase, "batch_execute",          Database_batch_execute, 2);
   rb_define_method(cDatabase, "batch_query",            Database_batch_query, 2);
-  rb_define_method(cDatabase, "batch_query_ary",        Database_batch_query_ary, 2);
-  rb_define_method(cDatabase, "batch_query_argv",       Database_batch_query_argv, 2);
+  rb_define_method(cDatabase, "batch_query_array",        Database_batch_query_array, 2);
+  rb_define_method(cDatabase, "batch_query_splat",       Database_batch_query_splat, 2);
   rb_define_method(cDatabase, "batch_query_hash",       Database_batch_query, 2);
   rb_define_method(cDatabase, "busy_timeout=",          Database_busy_timeout_set, 1);
   rb_define_method(cDatabase, "changes",                Database_changes, 0);
@@ -1447,21 +1511,22 @@ void Init_ExtraliteDatabase(void) {
 
   rb_define_method(cDatabase, "on_progress",            Database_on_progress, -1);
   rb_define_method(cDatabase, "prepare",                Database_prepare_hash, -1);
-  rb_define_method(cDatabase, "prepare_argv",           Database_prepare_argv, -1);
-  rb_define_method(cDatabase, "prepare_ary",            Database_prepare_ary, -1);
+  rb_define_method(cDatabase, "prepare_splat",          Database_prepare_splat, -1);
+  rb_define_method(cDatabase, "prepare_array",          Database_prepare_array, -1);
   rb_define_method(cDatabase, "prepare_hash",           Database_prepare_hash, -1);
   rb_define_method(cDatabase, "query",                  Database_query, -1);
-  rb_define_method(cDatabase, "query_argv",             Database_query_argv, -1);
-  rb_define_method(cDatabase, "query_ary",              Database_query_ary, -1);
+  rb_define_method(cDatabase, "query_splat",            Database_query_splat, -1);
+  rb_define_method(cDatabase, "query_array",            Database_query_array, -1);
   rb_define_method(cDatabase, "query_hash",             Database_query, -1);
   rb_define_method(cDatabase, "query_single",           Database_query_single, -1);
-  rb_define_method(cDatabase, "query_single_ary",       Database_query_single_ary, -1);
-  rb_define_method(cDatabase, "query_single_argv",      Database_query_single_argv, -1);
+  rb_define_method(cDatabase, "query_single_array",     Database_query_single_array, -1);
+  rb_define_method(cDatabase, "query_single_splat",     Database_query_single_splat, -1);
   rb_define_method(cDatabase, "query_single_hash",      Database_query_single, -1);
   rb_define_method(cDatabase, "read_only?",             Database_read_only_p, 0);
   rb_define_method(cDatabase, "status",                 Database_status, -1);
   rb_define_method(cDatabase, "total_changes",          Database_total_changes, 0);
   rb_define_method(cDatabase, "trace",                  Database_trace, 0);
+  rb_define_method(cDatabase, "wal_checkpoint",         Database_wal_checkpoint, -1);
 
   #ifdef EXTRALITE_ENABLE_CHANGESET
   rb_define_method(cDatabase, "track_changes",          Database_track_changes, -1);
@@ -1488,21 +1553,29 @@ void Init_ExtraliteDatabase(void) {
   ID_track        = rb_intern("track");
 
   SYM_at_least_once         = ID2SYM(rb_intern("at_least_once"));
+  SYM_full                  = ID2SYM(rb_intern("full"));
   SYM_gvl_release_threshold = ID2SYM(rb_intern("gvl_release_threshold"));
   SYM_once                  = ID2SYM(rb_intern("once"));
   SYM_none                  = ID2SYM(rb_intern("none"));
   SYM_normal                = ID2SYM(rb_intern("normal"));
+  SYM_passive               = ID2SYM(rb_intern("passive"));
   SYM_pragma                = ID2SYM(rb_intern("pragma"));
   SYM_read_only             = ID2SYM(rb_intern("read_only"));
+  SYM_restart               = ID2SYM(rb_intern("restart"));
+  SYM_truncate              = ID2SYM(rb_intern("truncate"));
   SYM_wal                   = ID2SYM(rb_intern("wal"));
 
   rb_gc_register_mark_object(SYM_at_least_once);
+  rb_gc_register_mark_object(SYM_full);
   rb_gc_register_mark_object(SYM_gvl_release_threshold);
   rb_gc_register_mark_object(SYM_once);
   rb_gc_register_mark_object(SYM_none);
   rb_gc_register_mark_object(SYM_normal);
+  rb_gc_register_mark_object(SYM_passive);
   rb_gc_register_mark_object(SYM_pragma);
   rb_gc_register_mark_object(SYM_read_only);
+  rb_gc_register_mark_object(SYM_restart);
+  rb_gc_register_mark_object(SYM_truncate);
   rb_gc_register_mark_object(SYM_wal);
 
   rb_gc_register_mark_object(global_progress_handler.proc);

data/ext/extralite/extralite.h

@@ -42,8 +42,8 @@ extern ID ID_strip;
 extern ID ID_to_s;
 extern ID ID_track;
 
-extern VALUE SYM_argv;
-extern VALUE SYM_ary;
+extern VALUE SYM_splat;
+extern VALUE SYM_array;
 extern VALUE SYM_hash;
 
 enum progress_handler_mode {
@@ -71,8 +71,8 @@ typedef struct {
 
 enum query_mode {
   QUERY_HASH,
-  QUERY_ARGV,
-  QUERY_ARY
+  QUERY_SPLAT,
+  QUERY_ARRAY
 };
 
 typedef struct {
@@ -87,13 +87,6 @@ typedef struct {
   enum query_mode     query_mode;
 } Query_t;
 
-enum iterator_mode {
-  ITERATOR_HASH,
-  ITERATOR_ARGV,
-  ITERATOR_ARY,
-  ITERATOR_SINGLE_COLUMN
-};
-
 typedef struct {
   VALUE               query;
 } Iterator_t;
@@ -165,16 +158,16 @@ typedef VALUE (*safe_query_impl)(query_ctx *);
 
 VALUE safe_batch_execute(query_ctx *ctx);
 VALUE safe_batch_query(query_ctx *ctx);
-VALUE safe_batch_query_argv(query_ctx *ctx);
-VALUE safe_batch_query_ary(query_ctx *ctx);
-VALUE safe_query_argv(query_ctx *ctx);
-VALUE safe_query_ary(query_ctx *ctx);
+VALUE safe_batch_query_splat(query_ctx *ctx);
+VALUE safe_batch_query_array(query_ctx *ctx);
+VALUE safe_query_splat(query_ctx *ctx);
+VALUE safe_query_array(query_ctx *ctx);
 VALUE safe_query_changes(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);
 VALUE safe_query_hash(query_ctx *ctx);
 VALUE safe_query_single_row_hash(query_ctx *ctx);
-VALUE safe_query_single_row_argv(query_ctx *ctx);
-VALUE safe_query_single_row_ary(query_ctx *ctx);
+VALUE safe_query_single_row_splat(query_ctx *ctx);
+VALUE safe_query_single_row_array(query_ctx *ctx);
 
 VALUE Query_each(VALUE self);
 VALUE Query_next(int argc, VALUE *argv, VALUE self);

data/ext/extralite/query.c

@@ -15,8 +15,8 @@ ID ID_inspect;
 ID ID_slice;
 
 VALUE SYM_hash;
-VALUE SYM_argv;
-VALUE SYM_ary;
+VALUE SYM_splat;
+VALUE SYM_array;
 
 #define DB_GVL_MODE(query) Database_prepare_gvl_mode(query->db_struct)
 
@@ -68,8 +68,8 @@ static inline Query_t *self_to_query(VALUE obj) {
 
 static inline enum query_mode symbol_to_query_mode(VALUE sym) {
   if (sym == SYM_hash)          return QUERY_HASH;
-  if (sym == SYM_argv)          return QUERY_ARGV;
-  if (sym == SYM_ary)           return QUERY_ARY;
+  if (sym == SYM_splat)         return QUERY_SPLAT;
+  if (sym == SYM_array)         return QUERY_ARRAY;
 
   rb_raise(cError, "Invalid query mode");
 }
@@ -78,10 +78,10 @@ static inline VALUE query_mode_to_symbol(enum query_mode query_mode) {
   switch (query_mode) {
     case QUERY_HASH:
       return SYM_hash;
-    case QUERY_ARGV:
-      return SYM_argv;
-    case QUERY_ARY:
-      return SYM_ary;
+    case QUERY_SPLAT:
+      return SYM_splat;
+    case QUERY_ARRAY:
+      return SYM_array;
     default:
       rb_raise(cError, "Invalid mode");
   }
@@ -232,10 +232,10 @@ inline safe_query_impl query_impl(enum query_mode query_mode) {
   switch (query_mode) {
     case QUERY_HASH:
       return safe_query_hash;
-    case QUERY_ARGV:
-      return safe_query_argv;
-    case QUERY_ARY:
-      return safe_query_ary;
+    case QUERY_SPLAT:
+      return safe_query_splat;
+    case QUERY_ARRAY:
+      return safe_query_array;
     default:
       rb_raise(cError, "Invalid query mode (query_impl)");
   }
@@ -596,7 +596,7 @@ VALUE Query_mode_get(VALUE self) {
 /* call-seq:
  *   query.mode = mode
  * 
- * Sets the query mode. This can be one of `:hash`, `:argv`, `:ary`.
+ * Sets the query mode. This can be one of `:hash`, `:splat`, `:array`.
  *
  * @param mode [Symbol] query mode
  * @return [Symbol] query mode
@@ -642,10 +642,10 @@ void Init_ExtraliteQuery(void) {
   ID_slice    = rb_intern("slice");
 
   SYM_hash          = ID2SYM(rb_intern("hash"));
-  SYM_argv          = ID2SYM(rb_intern("argv"));
-  SYM_ary           = ID2SYM(rb_intern("ary"));
+  SYM_splat          = ID2SYM(rb_intern("splat"));
+  SYM_array           = ID2SYM(rb_intern("array"));
 
   rb_gc_register_mark_object(SYM_hash);
-  rb_gc_register_mark_object(SYM_argv);
-  rb_gc_register_mark_object(SYM_ary);
+  rb_gc_register_mark_object(SYM_splat);
+  rb_gc_register_mark_object(SYM_array);
 }

data/gemspec.rb

@@ -18,7 +18,7 @@ def common_spec(s)
   s.required_ruby_version = '>= 3.0'
 
   s.add_development_dependency  'rake-compiler',        '1.2.7'
-  s.add_development_dependency  'minitest',             '5.21.2'
+  s.add_development_dependency  'minitest',             '5.22.2'
   s.add_development_dependency  'simplecov',            '0.17.1'
   s.add_development_dependency  'yard',                 '0.9.34'
   s.add_development_dependency  'sequel',               '5.77.0'

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.7.1'
+  VERSION = '2.8.1'
 end