extralite 2.3 → 2.5

data/ext/extralite/database.c

@@ -1,26 +1,42 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include "extralite.h"
 
 VALUE cDatabase;
+VALUE cBlob;
 VALUE cError;
 VALUE cSQLError;
 VALUE cBusyError;
 VALUE cInterruptError;
+VALUE cParameterError;
 VALUE eArgumentError;
 
 ID ID_bind;
 ID ID_call;
+ID ID_each;
 ID ID_keys;
 ID ID_new;
 ID ID_strip;
-ID ID_to_s;
 
+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);
 }
 
+static void Database_mark(void *ptr) {
+  Database_t *db = ptr;
+  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) {
   Database_t *db = ptr;
   if (db->sqlite3_db) sqlite3_close_v2(db->sqlite3_db);
@@ -29,8 +45,8 @@ static void Database_free(void *ptr) {
 
 static const rb_data_type_t Database_type = {
     "Database",
-    {0, Database_free, Database_size,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {Database_mark, Database_free, Database_size, Database_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE Database_allocate(VALUE klass) {
@@ -48,7 +64,7 @@ inline Database_t *self_to_database(VALUE self) {
 inline Database_t *self_to_open_database(VALUE self) {
   Database_t *db = self_to_database(self);
   if (!(db)->sqlite3_db) rb_raise(cError, "Database is closed");
-  
+
   return db;
 }
 
@@ -78,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) {
@@ -118,6 +160,9 @@ VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
 #endif
 
   db->trace_block = Qnil;
+  db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
+
+  if (!NIL_P(opts)) Database_apply_opts(self, db, opts);
 
   return Qnil;
 }
@@ -172,14 +217,13 @@ 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);
 
   bind_all_parameters(stmt, argc - 1, argv + 1);
-  query_ctx ctx = { self, db->sqlite3_db, stmt, Qnil, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS };
-
+  query_ctx ctx = QUERY_CTX(self, db, stmt, Qnil, QUERY_MODE(QUERY_MULTI_ROW), ALL_ROWS);
+  
   return rb_ensure(SAFE(call), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
 
@@ -190,18 +234,18 @@ static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VA
  * Runs a query returning rows as hashes (with symbol keys). If a block is
  * given, it will be called for each row. Otherwise, an array containing all
  * rows is returned.
- * 
+ *
  * 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
  * `?`:
- * 
+ *
  *     db.query('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('select * from foo where x = :bar', bar: 42)
  *     db.query('select * from foo where x = :bar', 'bar' => 42)
  *     db.query('select * from foo where x = :bar', ':bar' => 42)
@@ -334,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 = { self, db->sqlite3_db, stmt, params_array, QUERY_MODE(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:
@@ -391,10 +555,10 @@ VALUE Database_changes(VALUE self) {
   return INT2FIX(sqlite3_changes(db->sqlite3_db));
 }
 
-/* call-seq:
- *   db.filename -> string
+/* call-seq: db.filename -> string db.filename(db_name) -> string
  *
- * Returns the database filename.
+ * Returns the database filename. If db_name is given, returns the filename for
+ * the respective attached database.
  */
 VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
   const char *db_name;
@@ -441,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);
@@ -480,13 +646,13 @@ typedef struct {
 #define BACKUP_STEP_MAX_PAGES 16
 #define BACKUP_SLEEP_MS       100
 
-void *backup_step_without_gvl(void *ptr) {
+void *backup_step_impl(void *ptr) {
   backup_ctx *ctx = (backup_ctx *)ptr;
   ctx->rc = sqlite3_backup_step(ctx->backup, BACKUP_STEP_MAX_PAGES);
   return NULL;
 }
 
-void *backup_sleep_without_gvl(void *unused) {
+void *backup_sleep_impl(void *unused) {
   sqlite3_sleep(BACKUP_SLEEP_MS);
   return NULL;
 }
@@ -496,7 +662,7 @@ VALUE backup_safe_iterate(VALUE ptr) {
   int done = 0;
 
   while (!done) {
-    rb_thread_call_without_gvl(backup_step_without_gvl, (void *)ctx, RUBY_UBF_IO, 0);
+    gvl_call(GVL_RELEASE, backup_step_impl, (void *)ctx);
     switch(ctx->rc) {
       case SQLITE_DONE:
         if (ctx->block_given) {
@@ -514,7 +680,7 @@ VALUE backup_safe_iterate(VALUE ptr) {
         continue;
       case SQLITE_BUSY:
       case SQLITE_LOCKED:
-        rb_thread_call_without_gvl(backup_sleep_without_gvl, NULL, RUBY_UBF_IO, 0);
+        gvl_call(GVL_RELEASE, backup_sleep_impl, NULL);
         continue;
       default:
         rb_raise(cError, "%s", sqlite3_errstr(ctx->rc));
@@ -689,7 +855,7 @@ VALUE Database_total_changes(VALUE self) {
 VALUE Database_trace(VALUE self) {
   Database_t *db = self_to_open_database(self);
 
-  db->trace_block = rb_block_given_p() ? rb_block_proc() : Qnil;
+  RB_OBJ_WRITE(self, &db->trace_block, rb_block_given_p() ? rb_block_proc() : Qnil);
   return self;
 }
 
@@ -734,11 +900,51 @@ VALUE Database_error_offset(VALUE self) {
  * @return [String] string representation
  */
 VALUE Database_inspect(VALUE self) {
+  Database_t *db = self_to_database(self);
   VALUE cname = rb_class_name(CLASS_OF(self));
-  VALUE filename = Database_filename(0, NULL, self);
-  if (RSTRING_LEN(filename) == 0) filename = rb_str_new_literal(":memory:");
 
-  return rb_sprintf("#<%"PRIsVALUE":%p %"PRIsVALUE">", cname, (void*)self, filename);
+  if (!(db)->sqlite3_db)
+    return rb_sprintf("#<%"PRIsVALUE":%p (closed)>", cname, (void*)self);
+  else {
+    VALUE filename = Database_filename(0, NULL, self);
+    if (RSTRING_LEN(filename) == 0) filename = rb_str_new_literal(":memory:");
+    return rb_sprintf("#<%"PRIsVALUE":%p %"PRIsVALUE">", cname, (void*)self, filename);
+  }
+}
+
+/* Returns the database's GVL release threshold.
+ *
+ * @return [Integer] GVL release threshold
+ */
+VALUE Database_gvl_release_threshold_get(VALUE self) {
+  Database_t *db = self_to_open_database(self);
+  return INT2NUM(db->gvl_release_threshold);
+}
+
+/* Sets the database's GVL release threshold. To always hold the GVL while
+ * running a query, set the threshold to 0. To release the GVL on each record,
+ * set the threshold to 1. Larger values mean the GVL will be released less
+ * often, e.g. a value of 10 means the GVL will be released every 10 records
+ * iterated. A value of nil sets the threshold to the default value, which is
+ * currently 1000.
+ *
+ * @return [Integer, nil] New GVL release threshold
+ */
+VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
+  Database_t *db = self_to_open_database(self);
+
+  switch (TYPE(value)) {
+    case T_FIXNUM:
+      db->gvl_release_threshold = NUM2INT(value);
+      break;
+    case T_NIL:
+      db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
+      break;
+    default:
+      rb_raise(eArgumentError, "Invalid GVL release threshold value (expect integer or nil)");
+  }
+
+  return INT2NUM(db->gvl_release_threshold);
 }
 
 void Init_ExtraliteDatabase(void) {
@@ -763,8 +969,13 @@ 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);
   rb_define_method(cDatabase, "initialize", Database_initialize, -1);
   rb_define_method(cDatabase, "inspect", Database_inspect, 0);
   rb_define_method(cDatabase, "interrupt", Database_interrupt, 0);
@@ -787,26 +998,32 @@ void Init_ExtraliteDatabase(void) {
   rb_define_method(cDatabase, "load_extension", Database_load_extension, 1);
 #endif
 
+  cBlob = rb_define_class_under(mExtralite, "Blob", rb_cString);
+
   cError = rb_define_class_under(mExtralite, "Error", rb_eStandardError);
   cSQLError = rb_define_class_under(mExtralite, "SQLError", cError);
   cBusyError = rb_define_class_under(mExtralite, "BusyError", cError);
   cInterruptError = rb_define_class_under(mExtralite, "InterruptError", cError);
-  rb_gc_register_mark_object(cError);
-  rb_gc_register_mark_object(cSQLError);
-  rb_gc_register_mark_object(cBusyError);
-  rb_gc_register_mark_object(cInterruptError);
+  cParameterError = rb_define_class_under(mExtralite, "ParameterError", cError);
 
   eArgumentError = rb_const_get(rb_cObject, rb_intern("ArgumentError"));
 
   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");
-  ID_to_s   = rb_intern("to_s");
 
-  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

@@ -23,17 +23,19 @@
 extern VALUE cDatabase;
 extern VALUE cQuery;
 extern VALUE cIterator;
+extern VALUE cBlob;
 
 extern VALUE cError;
 extern VALUE cSQLError;
 extern VALUE cBusyError;
 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;
-extern ID ID_to_s;
 
 extern VALUE SYM_hash;
 extern VALUE SYM_ary;
@@ -42,6 +44,7 @@ extern VALUE SYM_single_column;
 typedef struct {
   sqlite3 *sqlite3_db;
   VALUE   trace_block;
+  int     gvl_release_threshold;
 } Database_t;
 
 typedef struct {
@@ -79,23 +82,29 @@ typedef struct {
   enum query_mode mode;
   int             max_rows;
   int             eof;
+  int             gvl_release_threshold;
+  int             step_count;
 } query_ctx;
 
-typedef struct {
-  VALUE           dst;
-  VALUE           src;
-  sqlite3_backup  *p;
-} backup_t;
+enum gvl_mode {
+  GVL_RELEASE,
+  GVL_HOLD
+};
 
-#define TUPLE_MAX_EMBEDDED_VALUES 20
 #define ALL_ROWS -1
 #define SINGLE_ROW -2
 #define QUERY_MODE(default) (rb_block_given_p() ? QUERY_YIELD : default)
 #define MULTI_ROW_P(mode) (mode == QUERY_MULTI_ROW)
+#define QUERY_CTX(self, db, stmt, params, mode, max_rows) \
+  { self, db->sqlite3_db, stmt, params, mode, max_rows, 0, db->gvl_release_threshold, 0 }
+#define DEFAULT_GVL_RELEASE_THRESHOLD 1000
 
 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);
@@ -126,4 +135,6 @@ VALUE cleanup_stmt(query_ctx *ctx);
 sqlite3 *Database_sqlite3_db(VALUE self);
 Database_t *self_to_database(VALUE self);
 
-#endif /* EXTRALITE_H */
+void *gvl_call(enum gvl_mode mode, void *(*fn)(void *), void *data);
+
+#endif /* EXTRALITE_H */

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/iterator.c

@@ -52,7 +52,7 @@ static inline enum iterator_mode symbol_to_mode(VALUE sym) {
  * iteration mode is one of: `:hash`, `:ary`, or `:single_column`. An iterator
  * is normally returned from one of the methods `Query#each`/`Query#each_hash`,
  * `Query#each_ary` or `Query#each_single_column` when called without a block:
- * 
+ *
  *     iterator = query.each
  *     ...
  *
@@ -115,12 +115,12 @@ inline next_method mode_to_next_method(enum iterator_mode mode) {
 
 /* Returns the next 1 or more rows from the associated query's result set
  * according to the iteration mode, i.e. as a hash, an array or a single value.
- * 
+ *
  * If no row count is given, a single row is returned. If a row count is given,
  * an array containing up to the `row_count` rows is returned. If `row_count` is
  * -1, all rows are returned. If the end of the result set has been reached,
  * `nil` is returned.
- * 
+ *
  * If a block is given, rows are passed to the block and self is returned.
  *
  * @overload next()
@@ -152,7 +152,7 @@ inline to_a_method mode_to_to_a_method(enum iterator_mode mode) {
 
 /* Returns all rows from the associated query's result set according to the
  * iteration mode, i.e. as a hash, an array or a single value.
- * 
+ *
  * @return [Array] array of query result set rows
  */
 VALUE Iterator_to_a(VALUE self) {
@@ -180,7 +180,7 @@ inline VALUE mode_to_symbol(Iterator_t *iterator) {
 VALUE Iterator_inspect(VALUE self) {
   VALUE cname = rb_class_name(CLASS_OF(self));
   VALUE sym = mode_to_symbol(self_to_iterator(self));
-  
+
   return rb_sprintf("#<%"PRIsVALUE":%p %"PRIsVALUE">", cname, (void*)self, sym);
 }