extralite 2.7 → 2.8

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 = {
@@ -342,18 +346,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 +368,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 +423,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 +449,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:
@@ -532,6 +536,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 +570,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 +583,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 +617,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.
@@ -721,15 +727,16 @@ static inline VALUE Database_prepare(int argc, VALUE *argv, VALUE self, VALUE mo
 }
 
 /* call-seq:
- *   db.prepare(sql) -> Extralite::Query
- *   db.prepare(sql, ...) -> Extralite::Query
- *   db.prepare(sql, ...) { ... } -> Extralite::Query
+ *   db.prepare(sql) -> query
+ *   db.prepare(sql, *params) -> query
+ *   db.prepare(sql, *params) { ... } -> query
  *
  * Creates a prepared query with the given SQL query in hash mode. If query
  * parameters are given, they are bound to the query. If a block is given, it is
  * used as a transform proc.
  * 
  * @param sql [String] SQL statement
+ * @param *params [Array<any>] parameters to bind
  * @return [Extralite::Query] prepared query
  */
 VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
@@ -737,35 +744,37 @@ VALUE Database_prepare_hash(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   db.prepare_argv(sql) -> Extralite::Query
- *   db.prepare_argv(sql, ...) -> Extralite::Query
- *   db.prepare_argv(sql, ...) { ... } -> 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
  * used as a transform proc.
  * 
  * @param sql [String] SQL statement
+ * @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, ...) -> Extralite::Query
- *   db.prepare_ary(sql, ...) { ... } -> 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.
  * 
  * @param sql [String] SQL statement
+ * @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
@@ -862,6 +871,10 @@ VALUE backup_cleanup(VALUE ptr) {
  *     end
  * 
  * @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) {
@@ -911,6 +924,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
@@ -1030,7 +1050,10 @@ VALUE Database_trace(VALUE self) {
 }
 
 #ifdef EXTRALITE_ENABLE_CHANGESET
-/* Tracks changes to the database and returns a changeset. The changeset can
+/* call-seq:
+ *   db.track_changes(*tables) { ... } -> changeset
+ *
+ * Tracks changes to the database and returns a changeset. The changeset can
  * then be used to store the changes to a file, apply them to another database,
  * or undo the changes. The given table names specify which tables should be
  * tracked for changes. Passing a value of nil causes all tables to be tracked.
@@ -1041,7 +1064,7 @@ VALUE Database_trace(VALUE self) {
  * 
  *     File.open('my.changes', 'w+') { |f| f << changeset.to_blob }
  * 
- * @param table [String, Symbol] table to track
+ * @param *tables [Array<String, Symbol>] table(s) to track
  * @return [Extralite::Changeset] changeset
 */
 VALUE Database_track_changes(int argc, VALUE *argv, VALUE self) {
@@ -1185,7 +1208,7 @@ struct progress_handler parse_progress_handler_opts(VALUE opts) {
  * @option opts [Integer] :period period value (`1000` by default)
  * @option opts [Integer] :tick tick value (`10` by default)
  * @option opts [Symbol] :mode progress handler mode (`:normal` by default)
- * @returns [Extralite::Database] database
+ * @return [Extralite::Database] database
  */
 VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
   Database_t *db = self_to_open_database(self);
@@ -1220,7 +1243,10 @@ VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-/* Installs or removes a global progress handler that will be executed
+/* call-seq:
+ *   Extralite.on_progress(**opts) { ... }
+ * 
+ * Installs or removes a global progress handler that will be executed
  * periodically while a query is running. This method can be used to support
  * switching between fibers and threads or implementing timeouts for running
  * queries.
@@ -1275,7 +1301,7 @@ VALUE Database_on_progress(int argc, VALUE *argv, VALUE self) {
  * @option opts [Integer] :period period value (`1000` by default)
  * @option opts [Integer] :tick tick value (`10` by default)
  * @option opts [Symbol] :mode progress handler mode (`:normal` by default)
- * @returns [Extralite::Database] database
+ * @return [Extralite::Database] database
  */
 VALUE Extralite_on_progress(int argc, VALUE *argv, VALUE self) {
   VALUE opts;
@@ -1361,7 +1387,7 @@ VALUE Database_gvl_release_threshold_get(VALUE self) {
  * A value of nil sets the threshold to the default value, which is
  * currently 1000.
  *
- * @param [Integer, nil] GVL release threshold
+ * @param threshold [Integer, nil] GVL release threshold
  * @return [Integer] GVL release threshold
  */
 VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
@@ -1389,6 +1415,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);
@@ -1398,63 +1471,62 @@ void Init_ExtraliteDatabase(void) {
   cDatabase = rb_define_class_under(mExtralite, "Database", rb_cObject);
   rb_define_alloc_func(cDatabase, Database_allocate);
 
-  #define DEF(s, f, a) rb_define_method(cDatabase, s, f, a)
-
-  DEF("backup",                 Database_backup, -1);
-  DEF("batch_execute",          Database_batch_execute, 2);
-  DEF("batch_query",            Database_batch_query, 2);
-  DEF("batch_query_ary",        Database_batch_query_ary, 2);
-  DEF("batch_query_argv",       Database_batch_query_argv, 2);
-  DEF("batch_query_hash",       Database_batch_query, 2);
-  DEF("busy_timeout=",          Database_busy_timeout_set, 1);
-  DEF("changes",                Database_changes, 0);
-  DEF("close",                  Database_close, 0);
-  DEF("closed?",                Database_closed_p, 0);
-  DEF("columns",                Database_columns, 1);
-  DEF("errcode",                Database_errcode, 0);
-  DEF("errmsg",                 Database_errmsg, 0);
+  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_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);
+  rb_define_method(cDatabase, "close",                  Database_close, 0);
+  rb_define_method(cDatabase, "closed?",                Database_closed_p, 0);
+  rb_define_method(cDatabase, "columns",                Database_columns, 1);
+  rb_define_method(cDatabase, "errcode",                Database_errcode, 0);
+  rb_define_method(cDatabase, "errmsg",                 Database_errmsg, 0);
 
   #ifdef HAVE_SQLITE3_ERROR_OFFSET
-  DEF("error_offset",           Database_error_offset, 0);
+  rb_define_method(cDatabase, "error_offset",           Database_error_offset, 0);
   #endif
 
-  DEF("execute",                Database_execute, -1);
-  DEF("filename",               Database_filename, -1);
-  DEF("gvl_release_threshold",  Database_gvl_release_threshold_get, 0);
-  DEF("gvl_release_threshold=", Database_gvl_release_threshold_set, 1);
-  DEF("initialize",             Database_initialize, -1);
-  DEF("inspect",                Database_inspect, 0);
-  DEF("interrupt",              Database_interrupt, 0);
-  DEF("last_insert_rowid",      Database_last_insert_rowid, 0);
-  DEF("limit",                  Database_limit, -1);
+  rb_define_method(cDatabase, "execute",                Database_execute, -1);
+  rb_define_method(cDatabase, "filename",               Database_filename, -1);
+  rb_define_method(cDatabase, "gvl_release_threshold",  Database_gvl_release_threshold_get, 0);
+  rb_define_method(cDatabase, "gvl_release_threshold=", Database_gvl_release_threshold_set, 1);
+  rb_define_method(cDatabase, "initialize",             Database_initialize, -1);
+  rb_define_method(cDatabase, "inspect",                Database_inspect, 0);
+  rb_define_method(cDatabase, "interrupt",              Database_interrupt, 0);
+  rb_define_method(cDatabase, "last_insert_rowid",      Database_last_insert_rowid, 0);
+  rb_define_method(cDatabase, "limit",                  Database_limit, -1);
 
   #ifdef HAVE_SQLITE3_LOAD_EXTENSION
-  DEF("load_extension",         Database_load_extension, 1);
+  rb_define_method(cDatabase, "load_extension",         Database_load_extension, 1);
   #endif
 
-  DEF("on_progress",            Database_on_progress, -1);
-  DEF("prepare",                Database_prepare_hash, -1);
-  DEF("prepare_argv",           Database_prepare_argv, -1);
-  DEF("prepare_ary",            Database_prepare_ary, -1);
-  DEF("prepare_hash",           Database_prepare_hash, -1);
-  DEF("query",                  Database_query, -1);
-  DEF("query_argv",             Database_query_argv, -1);
-  DEF("query_ary",              Database_query_ary, -1);
-  DEF("query_hash",             Database_query, -1);
-  DEF("query_single",           Database_query_single, -1);
-  DEF("query_single_ary",       Database_query_single_ary, -1);
-  DEF("query_single_argv",      Database_query_single_argv, -1);
-  DEF("query_single_hash",      Database_query_single, -1);
-  DEF("read_only?",             Database_read_only_p, 0);
-  DEF("status",                 Database_status, -1);
-  DEF("total_changes",          Database_total_changes, 0);
-  DEF("trace",                  Database_trace, 0);
+  rb_define_method(cDatabase, "on_progress",            Database_on_progress, -1);
+  rb_define_method(cDatabase, "prepare",                Database_prepare_hash, -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_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_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
-  DEF("track_changes",          Database_track_changes, -1);
+  rb_define_method(cDatabase, "track_changes",          Database_track_changes, -1);
   #endif
   
-  DEF("transaction_active?",    Database_transaction_active_p, 0);
+  rb_define_method(cDatabase, "transaction_active?",    Database_transaction_active_p, 0);
 
   cBlob           = rb_define_class_under(mExtralite, "Blob", rb_cString);
   cError          = rb_define_class_under(mExtralite, "Error", rb_eStandardError);
@@ -1475,21 +1547,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/iterator.c

@@ -50,7 +50,6 @@ static inline Iterator_t *self_to_iterator(VALUE obj) {
  *     ...
  *
  * @param query [Extralite::Query] associated query
- * @param mode [Symbol] iteration mode
  * @return [void]
  */
 VALUE Iterator_initialize(VALUE self, VALUE query) {