extralite-bundle 2.4 → 2.5

data/ext/extralite/database.c

@@ -13,11 +13,15 @@ VALUE eArgumentError;
 
 ID ID_bind;
 ID ID_call;
+ID ID_each;
 ID ID_keys;
 ID ID_new;
 ID ID_strip;
 
+VALUE SYM_gvl_release_threshold;
 VALUE SYM_read_only;
+VALUE SYM_synchronous;
+VALUE SYM_wal_journal_mode;
 
 static size_t Database_size(const void *ptr) {
   return sizeof(Database_t);
@@ -25,7 +29,12 @@ static size_t Database_size(const void *ptr) {
 
 static void Database_mark(void *ptr) {
   Database_t *db = ptr;
-  rb_gc_mark(db->trace_block);
+  rb_gc_mark_movable(db->trace_block);
+}
+
+static void Database_compact(void *ptr) {
+  Database_t *db = ptr;
+  db->trace_block = rb_gc_location(db->trace_block);
 }
 
 static void Database_free(void *ptr) {
@@ -36,7 +45,7 @@ static void Database_free(void *ptr) {
 
 static const rb_data_type_t Database_type = {
     "Database",
-    {Database_mark, Database_free, Database_size,},
+    {Database_mark, Database_free, Database_size, Database_compact},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
@@ -85,14 +94,40 @@ default_flags:
   return SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
 }
 
+VALUE Database_execute(int argc, VALUE *argv, VALUE self);
+
+void Database_apply_opts(VALUE self, Database_t *db, VALUE opts) {
+  VALUE value = Qnil;
+
+  value = rb_hash_aref(opts, SYM_gvl_release_threshold);
+  if (!NIL_P(value)) db->gvl_release_threshold = NUM2INT(value);
+
+  value = rb_hash_aref(opts, SYM_wal_journal_mode);
+  if (RTEST(value)) {
+    value = rb_str_new_literal("PRAGMA journal_mode=wal");
+    Database_execute(1, &value, self);
+  }
+
+  value = rb_hash_aref(opts, SYM_synchronous);
+  if (RTEST(value)) {
+    value = rb_str_new_literal("PRAGMA synchronous=1");
+    Database_execute(1, &value, self);
+  }
+
+  RB_GC_GUARD(value);
+}
+
 /* Initializes a new SQLite database with the given path and options.
  *
  * @overload initialize(path)
  *   @param path [String] file path (or ':memory:' for memory database)
  *   @return [void]
- * @overload initialize(path, read_only: false)
+ * @overload initialize(path, gvl_release_threshold: , read_only: , synchronous: , wal_journal_mode: )
  *   @param path [String] file path (or ':memory:' for memory database)
+ *   @param gvl_release_threshold [Integer] GVL release threshold
  *   @param read_only [boolean] true for opening the database for reading only
+ *   @param synchronous [boolean] true to set PRAGMA synchronous=1
+ *   @param wal_journal_mode [boolean] true to set PRAGMA journal_mode=wal
  *   @return [void]
  */
 VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
@@ -127,6 +162,8 @@ VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
   db->trace_block = Qnil;
   db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
 
+  if (!NIL_P(opts)) Database_apply_opts(self, db, opts);
+
   return Qnil;
 }
 
@@ -180,7 +217,6 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
   sql = rb_funcall(argv[0], ID_strip, 0);
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
-  // prepare query ctx
   if (db->trace_block != Qnil) rb_funcall(db->trace_block, ID_call, 1, sql);
   prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
   RB_GC_GUARD(sql);
@@ -342,30 +378,150 @@ VALUE Database_execute(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   db.execute_multi(sql, params_array) -> changes
+ *   db.batch_execute(sql, params_array) -> changes
+ *   db.batch_execute(sql, enumerable) -> changes
+ *   db.batch_execute(sql, callable) -> changes
+ *
+ * Executes the given query for each list of parameters in the paramter source.
+ * If an enumerable is given, it is iterated and each of its values is used as
+ * the parameters for running the query. If a callable is given, it is called
+ * repeatedly and each of its return values is used as the parameters, until nil
+ * is returned.
  *
- * Executes the given query for each list of parameters in params_array. Returns
- * the number of changes effected. This method is designed for inserting
- * multiple records.
+ * Returns the number of changes effected. This method is designed for inserting
+ * multiple records or performing other mass operations.
  *
  *     records = [
  *       [1, 2, 3],
  *       [4, 5, 6]
  *     ]
- *     db.execute_multi('insert into foo values (?, ?, ?)', records)
+ *     db.batch_execute('insert into foo values (?, ?, ?)', records)
  *
+ *     source = [
+ *       [1, 2, 3],
+ *       [4, 5, 6]
+ *     ]
+ *     db.batch_execute('insert into foo values (?, ?, ?)', -> { records.shift })
+ *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Integer] Total number of changes effected
  */
-VALUE Database_execute_multi(VALUE self, VALUE sql, VALUE params_array) {
+VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
 
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
-  // prepare query ctx
   prepare_single_stmt(db->sqlite3_db, &stmt, sql);
-  query_ctx ctx = QUERY_CTX(self, db, stmt, params_array, QUERY_MULTI_ROW, ALL_ROWS);
+  query_ctx ctx = QUERY_CTX(self, db, stmt, parameters, QUERY_MULTI_ROW, ALL_ROWS);
+
+  return rb_ensure(SAFE(safe_batch_execute), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+}
+
+/* call-seq:
+ *   db.batch_query(sql, params_array) -> rows
+ *   db.batch_query(sql, enumerable) -> rows
+ *   db.batch_query(sql, callable) -> rows
+ *   db.batch_query(sql, params_array) { |rows| ... } -> changes
+ *   db.batch_query(sql, enumerable) { |rows| ... } -> changes
+ *   db.batch_query(sql, callable) { |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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned.
+ *
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     db.batch_query('insert into foo values (?, ?) returning bar, baz', records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Database_batch_query(VALUE self, VALUE sql, VALUE parameters) {
+  Database_t *db = self_to_open_database(self);
+  sqlite3_stmt *stmt;
+
+  prepare_single_stmt(db->sqlite3_db, &stmt, sql);
+  query_ctx ctx = QUERY_CTX(self, db, stmt, parameters, QUERY_MULTI_ROW, ALL_ROWS);
+
+  return rb_ensure(SAFE(safe_batch_query), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+}
+
+/* call-seq:
+ *   db.batch_query_ary(sql, params_array) -> rows
+ *   db.batch_query_ary(sql, enumerable) -> rows
+ *   db.batch_query_ary(sql, callable) -> rows
+ *   db.batch_query_ary(sql, params_array) { |rows| ... } -> changes
+ *   db.batch_query_ary(sql, enumerable) { |rows| ... } -> changes
+ *   db.batch_query_ary(sql, callable) { |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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are represented as arrays.
+ *
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     db.batch_query_ary('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) {
+  Database_t *db = self_to_open_database(self);
+  sqlite3_stmt *stmt;
+
+  prepare_single_stmt(db->sqlite3_db, &stmt, sql);
+  query_ctx ctx = QUERY_CTX(self, db, stmt, parameters, QUERY_MULTI_ROW, ALL_ROWS);
 
-  return rb_ensure(SAFE(safe_execute_multi), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+  return rb_ensure(SAFE(safe_batch_query_ary), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+}
+
+/* call-seq:
+ *   db.batch_query_single_column(sql, params_array) -> rows
+ *   db.batch_query_single_column(sql, enumerable) -> rows
+ *   db.batch_query_single_column(sql, callable) -> rows
+ *   db.batch_query_single_column(sql, params_array) { |rows| ... } -> changes
+ *   db.batch_query_single_column(sql, enumerable) { |rows| ... } -> changes
+ *   db.batch_query_single_column(sql, callable) { |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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are single values.
+ *
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     db.batch_query_ary('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_single_column(VALUE self, VALUE sql, VALUE parameters) {
+  Database_t *db = self_to_open_database(self);
+  sqlite3_stmt *stmt;
+
+  prepare_single_stmt(db->sqlite3_db, &stmt, sql);
+  query_ctx ctx = QUERY_CTX(self, db, stmt, parameters, QUERY_MULTI_ROW, ALL_ROWS);
+
+  return rb_ensure(SAFE(safe_batch_query_single_column), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
 
 /* call-seq:
@@ -449,8 +605,10 @@ VALUE Database_load_extension(VALUE self, VALUE path) {
 
 /* call-seq:
  *   db.prepare(sql) -> Extralite::Query
+ *   db.prepare(sql, ...) -> Extralite::Query
  *
- * Creates a prepared statement with the given SQL query.
+ * Creates a prepared statement with the given SQL query. If query parameters
+ * are given, they are bound to the query.
  */
 VALUE Database_prepare(int argc, VALUE *argv, VALUE self) {
   rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
@@ -811,7 +969,10 @@ void Init_ExtraliteDatabase(void) {
   #endif
 
   rb_define_method(cDatabase, "execute", Database_execute, -1);
-  rb_define_method(cDatabase, "execute_multi", Database_execute_multi, 2);
+  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_single_column", Database_batch_query_single_column, 2);
   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);
@@ -849,12 +1010,20 @@ void Init_ExtraliteDatabase(void) {
 
   ID_bind   = rb_intern("bind");
   ID_call   = rb_intern("call");
+  ID_each   = rb_intern("each");
   ID_keys   = rb_intern("keys");
   ID_new    = rb_intern("new");
   ID_strip  = rb_intern("strip");
 
-  SYM_read_only = ID2SYM(rb_intern("read_only"));
+  SYM_gvl_release_threshold = ID2SYM(rb_intern("gvl_release_threshold"));
+  SYM_read_only             = ID2SYM(rb_intern("read_only"));
+  SYM_synchronous           = ID2SYM(rb_intern("synchronous"));
+  SYM_wal_journal_mode      = ID2SYM(rb_intern("wal_journal_mode"));
+
+  rb_gc_register_mark_object(SYM_gvl_release_threshold);
   rb_gc_register_mark_object(SYM_read_only);
+  rb_gc_register_mark_object(SYM_synchronous);
+  rb_gc_register_mark_object(SYM_wal_journal_mode);
 
   UTF8_ENCODING = rb_utf8_encoding();
 }

data/ext/extralite/extralite.h

@@ -32,6 +32,7 @@ extern VALUE cInterruptError;
 extern VALUE cParameterError;
 
 extern ID ID_call;
+extern ID ID_each;
 extern ID ID_keys;
 extern ID ID_new;
 extern ID ID_strip;
@@ -100,7 +101,10 @@ enum gvl_mode {
 
 extern rb_encoding *UTF8_ENCODING;
 
-VALUE safe_execute_multi(query_ctx *ctx);
+VALUE safe_batch_execute(query_ctx *ctx);
+VALUE safe_batch_query(query_ctx *ctx);
+VALUE safe_batch_query_ary(query_ctx *ctx);
+VALUE safe_batch_query_single_column(query_ctx *ctx);
 VALUE safe_query_ary(query_ctx *ctx);
 VALUE safe_query_changes(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);

data/ext/extralite/extralite_ext.c

@@ -1,8 +1,12 @@
+#include "ruby.h"
+
 void Init_ExtraliteDatabase();
 void Init_ExtraliteQuery();
 void Init_ExtraliteIterator();
 
 void Init_extralite_ext(void) {
+  rb_ext_ractor_safe(true);
+
   Init_ExtraliteDatabase();
   Init_ExtraliteQuery();
   Init_ExtraliteIterator();

data/ext/extralite/query.c

@@ -20,8 +20,14 @@ static size_t Query_size(const void *ptr) {
 
 static void Query_mark(void *ptr) {
   Query_t *query = ptr;
-  rb_gc_mark(query->db);
-  rb_gc_mark(query->sql);
+  rb_gc_mark_movable(query->db);
+  rb_gc_mark_movable(query->sql);
+}
+
+static void Query_compact(void *ptr) {
+  Query_t *query = ptr;
+  query->db = rb_gc_location(query->db);
+  query->sql = rb_gc_location(query->sql);
 }
 
 static void Query_free(void *ptr) {
@@ -32,7 +38,7 @@ static void Query_free(void *ptr) {
 
 static const rb_data_type_t Query_type = {
     "Query",
-    {Query_mark, Query_free, Query_size,},
+    {Query_mark, Query_free, Query_size, Query_compact},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
@@ -367,22 +373,66 @@ VALUE Query_execute(int argc, VALUE *argv, VALUE self) {
   return Query_perform_next(self, ALL_ROWS, safe_query_changes);
 }
 
-/* Executes the query for each set of parameters in the given array. Parameters
- * can be specified as either an array (for unnamed parameters) or a hash (for
- * named parameters). Returns the number of changes effected. This method is
- * designed for inserting multiple records.
+/* call-seq:
+ *   query << [...] -> query
+ *   query << { ... } -> query
+ *
+ * Runs the with the given parameters, returning the total changes effected.
+ * This method should be used for data- or schema-manipulation queries.
+ *
+ * Query parameters to be bound to placeholders in the query can be specified as
+ * a list of values or as a hash mapping parameter names to values. When
+ * parameters are given as an array, the query should specify parameters using
+ * `?`:
+ *
+ *     query = db.prepare('update foo set x = ? where y = ?')
+ *     query << [42, 43]
+ *
+ * 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:
+ *
+ *     query = db.prepare('update foo set x = :bar')
+ *     query << { bar: 42 }
+ *     query << { 'bar' => 42 }
+ *     query << { ':bar' => 42 }
+ */
+VALUE Query_execute_chevrons(VALUE self, VALUE params) {
+  Query_execute(1, &params, self);
+  return self;
+}
+
+/* call-seq:
+ *   query.batch_execute(params_array) -> changes
+ *   query.batch_execute(enumerable) -> changes
+ *   query.batch_execute(callable) -> changes
+ *
+ * Executes the query for each set of parameters in the paramter source. If an
+ * enumerable is given, it is iterated and each of its values is used as the
+ * parameters for running the query. If a callable is given, it is called
+ * repeatedly and each of its return values is used as the parameters, until nil
+ * is returned.
+ * 
+ * Returns the number of changes effected. This method is designed for inserting
+ * multiple records.
  *
  *     query = db.prepare('insert into foo values (?, ?, ?)')
  *     records = [
  *       [1, 2, 3],
  *       [4, 5, 6]
  *     ]
- *     query.execute_multi(records)
+ *     query.batch_execute(records)
+ * 
+ *     source = [
+ *       [1, 2, 3],
+ *       [4, 5, 6]
+ *     ]
+ *     query.batch_execute { records.shift }
  *
- * @param parameters [Array<Array, Hash>] array of parameters to run query with
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] array of parameters to run query with
  * @return [Integer] number of changes effected
  */
-VALUE Query_execute_multi(VALUE self, VALUE parameters) {
+VALUE Query_batch_execute(VALUE self, VALUE parameters) {
   Query_t *query = self_to_query(self);
   if (query->closed) rb_raise(cError, "Query is closed");
 
@@ -397,7 +447,139 @@ VALUE Query_execute_multi(VALUE self, VALUE parameters) {
     QUERY_MODE(QUERY_MULTI_ROW),
     ALL_ROWS
   );
-  return safe_execute_multi(&ctx);
+  return safe_batch_execute(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query(sql, params_array) -> rows
+ *   query.batch_query(sql, enumerable) -> rows
+ *   query.batch_query(sql, callable) -> rows
+ *   query.batch_query(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared 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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_query(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query_ary(sql, params_array) -> rows
+ *   query.batch_query_ary(sql, enumerable) -> rows
+ *   query.batch_query_ary(sql, callable) -> rows
+ *   query.batch_query_ary(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query_ary(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query_ary(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared 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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are represented as arrays.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query_ary(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query_ary(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_query_ary(&ctx);
+}
+
+/* call-seq:
+ *   query.batch_query_single_column(sql, params_array) -> rows
+ *   query.batch_query_single_column(sql, enumerable) -> rows
+ *   query.batch_query_single_column(sql, callable) -> rows
+ *   query.batch_query_single_column(sql, params_array) { |rows| ... } -> changes
+ *   query.batch_query_single_column(sql, enumerable) { |rows| ... } -> changes
+ *   query.batch_query_single_column(sql, callable) { |rows| ... } -> changes
+ *
+ * Executes the prepared 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
+ * invocation of the query, and the total number of changes is returned.
+ * Otherwise, an array containing the resulting rows for each invocation is
+ * returned. Rows are represented as single values.
+ *
+ *     q = db.prepare('insert into foo values (?, ?) returning bar, baz')
+ *     records = [
+ *       [1, 2],
+ *       [3, 4]
+ *     ]
+ *     q.batch_query_single_column(records)
+ *     #=> [{ bar: 1, baz: 2 }, { bar: 3, baz: 4}]
+ * *
+ * @param sql [String] query SQL
+ * @param parameters [Array<Array, Hash>, Enumerable, Enumerator, Callable] parameters to run query with
+ * @return [Array<Hash>, Integer] Total number of changes effected
+ */
+VALUE Query_batch_query_single_column(VALUE self, VALUE parameters) {
+  Query_t *query = self_to_query(self);
+  if (query->closed) rb_raise(cError, "Query is closed");
+
+  if (!query->stmt)
+    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+
+  query_ctx ctx = QUERY_CTX(
+    self,
+    query->db_struct,
+    query->stmt,
+    parameters,
+    QUERY_MODE(QUERY_MULTI_ROW),
+    ALL_ROWS
+  );
+  return safe_batch_query_single_column(&ctx);
 }
 
 /* Returns the database associated with the query.
@@ -431,6 +613,19 @@ VALUE Query_columns(VALUE self) {
   return Query_perform_next(self, ALL_ROWS, safe_query_columns);
 }
 
+/* call-seq:
+ *   query.clone -> copy
+ *   query.dup -> copy
+ *
+ * Returns a new query instance for the same SQL as the original query.
+ *
+ * @return [Extralite::Query] copy of query
+ */
+VALUE Query_clone(VALUE self) {
+  Query_t *query = self_to_query(self);
+  return rb_funcall(cQuery, ID_new, 2, query->db, query->sql);
+}
+
 /* Closes the query. Attempting to run a closed query will raise an error.
  *
  * @return [Extralite::Query] self
@@ -509,8 +704,10 @@ void Init_ExtraliteQuery(void) {
   rb_define_method(cQuery, "close", Query_close, 0);
   rb_define_method(cQuery, "closed?", Query_closed_p, 0);
   rb_define_method(cQuery, "columns", Query_columns, 0);
+  rb_define_method(cQuery, "clone", Query_clone, 0);
   rb_define_method(cQuery, "database", Query_database, 0);
   rb_define_method(cQuery, "db", Query_database, 0);
+  rb_define_method(cQuery, "dup", Query_clone, 0);
 
   rb_define_method(cQuery, "each", Query_each_hash, 0);
   rb_define_method(cQuery, "each_ary", Query_each_ary, 0);
@@ -519,7 +716,11 @@ void Init_ExtraliteQuery(void) {
 
   rb_define_method(cQuery, "eof?", Query_eof_p, 0);
   rb_define_method(cQuery, "execute", Query_execute, -1);
-  rb_define_method(cQuery, "execute_multi", Query_execute_multi, 1);
+  rb_define_method(cQuery, "<<", Query_execute_chevrons, 1);
+  rb_define_method(cQuery, "batch_execute", Query_batch_execute, 1);
+  rb_define_method(cQuery, "batch_query", Query_batch_query, 1);
+  rb_define_method(cQuery, "batch_query_ary", Query_batch_query_ary, 1);
+  rb_define_method(cQuery, "batch_query_single_column", Query_batch_query_single_column, 1);
   rb_define_method(cQuery, "initialize", Query_initialize, 2);
   rb_define_method(cQuery, "inspect", Query_inspect, 0);