extralite 2.5 → 2.6

data/ext/extralite/database.c

@@ -17,24 +17,30 @@ ID ID_each;
 ID ID_keys;
 ID ID_new;
 ID ID_strip;
+ID ID_to_s;
+ID ID_track;
 
 VALUE SYM_gvl_release_threshold;
 VALUE SYM_read_only;
 VALUE SYM_synchronous;
 VALUE SYM_wal_journal_mode;
 
+#define DB_GVL_MODE(db) Database_prepare_gvl_mode(db)
+
 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);
+  rb_gc_mark_movable(db->trace_proc);
+  rb_gc_mark_movable(db->progress_handler_proc);
 }
 
 static void Database_compact(void *ptr) {
   Database_t *db = ptr;
-  db->trace_block = rb_gc_location(db->trace_block);
+  db->trace_proc = rb_gc_location(db->trace_proc);
+  db->progress_handler_proc = rb_gc_location(db->progress_handler_proc);
 }
 
 static void Database_free(void *ptr) {
@@ -159,7 +165,8 @@ VALUE Database_initialize(int argc, VALUE *argv, VALUE self) {
   }
 #endif
 
-  db->trace_block = Qnil;
+  db->trace_proc = Qnil;
+  db->progress_handler_proc = Qnil;
   db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
 
   if (!NIL_P(opts)) Database_apply_opts(self, db, opts);
@@ -207,6 +214,10 @@ VALUE Database_closed_p(VALUE self) {
   return db->sqlite3_db ? Qfalse : Qtrue;
 }
 
+inline enum gvl_mode Database_prepare_gvl_mode(Database_t *db) {
+  return db->gvl_release_threshold < 0 ? GVL_HOLD : GVL_RELEASE;
+}
+
 static inline VALUE Database_perform_query(int argc, VALUE *argv, VALUE self, VALUE (*call)(query_ctx *)) {
   Database_t *db = self_to_open_database(self);
   sqlite3_stmt *stmt;
@@ -217,8 +228,8 @@ 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;
 
-  if (db->trace_block != Qnil) rb_funcall(db->trace_block, ID_call, 1, sql);
-  prepare_multi_stmt(db->sqlite3_db, &stmt, sql);
+  TRACE_SQL(db, sql);
+  prepare_multi_stmt(DB_GVL_MODE(db), db->sqlite3_db, &stmt, sql);
   RB_GC_GUARD(sql);
 
   bind_all_parameters(stmt, argc - 1, argv + 1);
@@ -413,7 +424,7 @@ VALUE Database_batch_execute(VALUE self, VALUE sql, VALUE parameters) {
 
   if (RSTRING_LEN(sql) == 0) return Qnil;
 
-  prepare_single_stmt(db->sqlite3_db, &stmt, sql);
+  prepare_single_stmt(DB_GVL_MODE(db), 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_execute), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
@@ -448,7 +459,7 @@ 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);
+  prepare_single_stmt(DB_GVL_MODE(db), 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);
@@ -483,7 +494,7 @@ 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);
+  prepare_single_stmt(DB_GVL_MODE(db), 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_ary), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
@@ -518,7 +529,7 @@ 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);
+  prepare_single_stmt(DB_GVL_MODE(db), 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);
@@ -855,7 +866,127 @@ VALUE Database_total_changes(VALUE self) {
 VALUE Database_trace(VALUE self) {
   Database_t *db = self_to_open_database(self);
 
-  RB_OBJ_WRITE(self, &db->trace_block, rb_block_given_p() ? rb_block_proc() : Qnil);
+  RB_OBJ_WRITE(self, &db->trace_proc, rb_block_given_p() ? rb_block_proc() : Qnil);
+  return self;
+}
+
+#ifdef EXTRALITE_ENABLE_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.
+ * 
+ *   changeset = db.track_changes(:foo, :bar) do
+ *     perform_a_bunch_of_queries
+ *   end
+ * 
+ *   File.open('my.changes', 'w+') { |f| f << changeset.to_blob }
+ * 
+ * @param table [String, Symbol] table to track
+ * @return [Extralite::Changeset] changeset
+*/
+VALUE Database_track_changes(int argc, VALUE *argv, VALUE self) {
+  self_to_open_database(self);
+
+  VALUE changeset = rb_funcall(cChangeset, ID_new, 0);
+  VALUE tables = rb_ary_new_from_values(argc, argv);
+
+  rb_funcall(changeset, ID_track, 2, self, tables);
+
+  RB_GC_GUARD(changeset);
+  RB_GC_GUARD(tables);
+  return changeset;
+}
+#endif
+
+int Database_progress_handler(void *ptr) {
+  Database_t *db = (Database_t *)ptr;
+  rb_funcall(db->progress_handler_proc, ID_call, 0);
+  return 0;
+}
+
+int Database_busy_handler(void *ptr, int v) {
+  Database_t *db = (Database_t *)ptr;
+  rb_funcall(db->progress_handler_proc, ID_call, 0);
+  return 1;
+}
+
+void Database_reset_progress_handler(VALUE self, Database_t *db) {
+  RB_OBJ_WRITE(self, &db->progress_handler_proc, Qnil);
+  sqlite3_progress_handler(db->sqlite3_db, 0, NULL, NULL);
+  sqlite3_busy_handler(db->sqlite3_db, NULL, NULL);
+}
+
+/* call-seq:
+ *   db.on_progress(period) { } -> db
+ *   db.on_progress(0) -> db
+ *
+ * Installs or removes a 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.
+ *
+ * The given period parameter specifies the approximate number of SQLite virtual
+ * machine instructions that are evaluated between successive invocations of the
+ * progress handler. A period of less than 1 removes the progress handler.
+ *
+ * The progress handler is called also when the database is busy. This lets the
+ * application perform work while waiting for the database to become unlocked,
+ * or implement a timeout. Note that setting the database's busy_timeout _after_
+ * setting a progress handler may lead to undefined behaviour in a concurrent
+ * application.
+ *
+ * When the progress handler is set, the gvl release threshold value is set to
+ * -1, which means that the GVL will not be released at all when preparing or
+ * running queries. It is the application's responsibility to let other threads
+ * or fibers run by calling e.g. Thread.pass:
+ * 
+ *     db.on_progress(1000) do
+ *       do_something_interesting
+ *       Thread.pass # let other threads run
+ *     end
+ * 
+ * Note that the progress handler is set globally for the database and that 
+ * Extralite does provide any hooks for telling which queries are currently
+ * running or at what time they were started. This means that you'll need
+ * to wrap the stock #query_xxx and #execute methods with your own code that
+ * calculates timeouts, for example:
+ * 
+ *     def setup_progress_handler
+ *       @db.on_progress(1000) do
+ *         raise TimeoutError if Time.now - @t0 >= @timeout
+ *         Thread.pass
+ *       end
+ *     end
+ * 
+ *     def query(sql, *)
+ *       @t0 = Time.now
+ *       @db.query(sql, *)
+ *     end
+ * 
+ * If the gvl release threshold is set to a value equal to or larger than 0
+ * after setting the progress handler, the progress handler will be reset.
+ *
+ * @param period [Integer] progress handler period
+ * @returns [Extralite::Database] database
+ */
+VALUE Database_on_progress(VALUE self, VALUE period) {
+  Database_t *db = self_to_open_database(self);
+  int period_int = NUM2INT(period);
+
+  if (period_int > 0 && rb_block_given_p()) {
+    RB_OBJ_WRITE(self, &db->progress_handler_proc, rb_block_proc());
+    db->gvl_release_threshold = -1;
+
+    sqlite3_progress_handler(db->sqlite3_db, period_int, &Database_progress_handler, db);
+    sqlite3_busy_handler(db->sqlite3_db, &Database_busy_handler, db);
+  }
+  else {
+    RB_OBJ_WRITE(self, &db->progress_handler_proc, Qnil);
+    db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
+    sqlite3_progress_handler(db->sqlite3_db, 0, NULL, NULL);
+    sqlite3_busy_handler(db->sqlite3_db, NULL, NULL);
+  }
+
   return self;
 }
 
@@ -935,8 +1066,16 @@ VALUE Database_gvl_release_threshold_set(VALUE self, VALUE value) {
 
   switch (TYPE(value)) {
     case T_FIXNUM:
-      db->gvl_release_threshold = NUM2INT(value);
-      break;
+      {
+        int value_int = NUM2INT(value);
+        if (value_int < -1)
+          rb_raise(eArgumentError, "Invalid GVL release threshold value (expect integer >= -1)");
+
+        if (value_int > -1 && !NIL_P(db->progress_handler_proc))
+          Database_reset_progress_handler(self, db);
+        db->gvl_release_threshold = value_int;
+        break;
+      }
     case T_NIL:
       db->gvl_release_threshold = DEFAULT_GVL_RELEASE_THRESHOLD;
       break;
@@ -981,6 +1120,7 @@ void Init_ExtraliteDatabase(void) {
   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);
+  rb_define_method(cDatabase, "on_progress", Database_on_progress, 1);
   rb_define_method(cDatabase, "prepare", Database_prepare, -1);
   rb_define_method(cDatabase, "query", Database_query_hash, -1);
   rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
@@ -992,6 +1132,11 @@ void Init_ExtraliteDatabase(void) {
   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);
+
+  #ifdef EXTRALITE_ENABLE_CHANGESET
+  rb_define_method(cDatabase, "track_changes", Database_track_changes, -1);
+  #endif
+  
   rb_define_method(cDatabase, "transaction_active?", Database_transaction_active_p, 0);
 
 #ifdef HAVE_SQLITE3_LOAD_EXTENSION
@@ -1014,6 +1159,8 @@ void Init_ExtraliteDatabase(void) {
   ID_keys   = rb_intern("keys");
   ID_new    = rb_intern("new");
   ID_strip  = rb_intern("strip");
+  ID_to_s   = rb_intern("to_s");
+  ID_track  = rb_intern("track");
 
   SYM_gvl_release_threshold = ID2SYM(rb_intern("gvl_release_threshold"));
   SYM_read_only             = ID2SYM(rb_intern("read_only"));

data/ext/extralite/extconf-bundle.rb

@@ -6,11 +6,17 @@ $CFLAGS << ' -Wno-undef'
 $CFLAGS << ' -Wno-discarded-qualifiers'
 $CFLAGS << ' -Wno-unused-function'
 
-$defs << "-DHAVE_SQLITE3_ENABLE_LOAD_EXTENSION"
-$defs << "-DHAVE_SQLITE3_LOAD_EXTENSION"
-$defs << "-DHAVE_SQLITE3_ERROR_OFFSET"
+# enable the session extension
+$defs << '-DSQLITE_ENABLE_SESSION'
+$defs << '-DSQLITE_ENABLE_PREUPDATE_HOOK'
+$defs << '-DEXTRALITE_ENABLE_CHANGESET'
 
-have_func('usleep')
+$defs << '-DHAVE_SQLITE3_ENABLE_LOAD_EXTENSION'
+$defs << '-DHAVE_SQLITE3_LOAD_EXTENSION'
+$defs << '-DHAVE_SQLITE3_PREPARE_V2'
+$defs << '-DHAVE_SQLITE3_ERROR_OFFSET'
+$defs << '-DHAVE_SQLITE3SESSION_CHANGESET'
 
+have_func('usleep')
 dir_config('extralite_ext')
 create_makefile('extralite_ext')

data/ext/extralite/extconf.rb

@@ -52,43 +52,47 @@ else
     $CFLAGS << ' -W3'
   end
 
-  if RUBY_VERSION < '2.7'
-    $CFLAGS << ' -DTAINTING_SUPPORT'
-  end
-
   # @!visibility private
   def asplode missing
     if RUBY_PLATFORM =~ /mingw|mswin/
       abort "#{missing} is missing. Install SQLite3 from " +
       "http://www.sqlite.org/ first."
     else
-      abort <<-error
-      #{missing} is missing. Try 'brew install sqlite3',
-      'yum install sqlite-devel' or 'apt-get install libsqlite3-dev'
-      and check your shared library search path (the
-        location where your sqlite3 shared library is located).
-        error
-      end
+      abort <<~error
+        #{missing} is missing. Try 'brew install sqlite3',
+        'yum install sqlite-devel' or 'apt-get install libsqlite3-dev'
+        and check your shared library search path (the location where
+        your sqlite3 shared library is located).
+      error
     end
+  end
 
-    asplode('sqlite3.h')  unless find_header  'sqlite3.h'
-    find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
+  asplode('sqlite3.h') unless find_header('sqlite3.h')
+  # find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
 
-    have_library 'dl' # for static builds
+  have_library 'dl' # for static builds
 
-    if with_config('sqlcipher')
-      asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
-    else
-      asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
-    end
+  if with_config('sqlcipher')
+    asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
+  else
+    asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
+  end
+
+  have_func('sqlite3_enable_load_extension')
+  have_func('sqlite3_load_extension')
+  have_func('sqlite3_prepare_v2')
+  have_func('sqlite3_error_offset')
+  have_func('sqlite3session_changeset')
+
+  if have_type('sqlite3_session', 'sqlite.h')
+    $defs << '-DEXTRALITE_ENABLE_CHANGESET'
+  end
+  # have_macro('__SQLITESESSION_H_')
+  # have_macro('SQLITE3_H')
 
-    have_func('sqlite3_enable_load_extension')
-    have_func('sqlite3_load_extension')
-    have_func('sqlite3_prepare_v2')
-    have_func('sqlite3_error_offset')
 
-    $defs << "-DEXTRALITE_NO_BUNDLE"
+  $defs << "-DEXTRALITE_NO_BUNDLE"
 
-    dir_config('extralite_ext')
-    create_makefile('extralite_ext')
-  end
+  dir_config('extralite_ext')
+  create_makefile('extralite_ext')
+end

data/ext/extralite/extralite.h

@@ -23,6 +23,7 @@
 extern VALUE cDatabase;
 extern VALUE cQuery;
 extern VALUE cIterator;
+extern VALUE cChangeset;
 extern VALUE cBlob;
 
 extern VALUE cError;
@@ -36,14 +37,17 @@ extern ID ID_each;
 extern ID ID_keys;
 extern ID ID_new;
 extern ID ID_strip;
+extern ID ID_to_s;
+extern ID ID_track;
 
-extern VALUE SYM_hash;
 extern VALUE SYM_ary;
+extern VALUE SYM_hash;
 extern VALUE SYM_single_column;
 
 typedef struct {
   sqlite3 *sqlite3_db;
-  VALUE   trace_block;
+  VALUE   trace_proc;
+  VALUE   progress_handler_proc;
   int     gvl_release_threshold;
 } Database_t;
 
@@ -68,6 +72,13 @@ typedef struct {
   enum iterator_mode  mode;
 } Iterator_t;
 
+#ifdef EXTRALITE_ENABLE_CHANGESET
+typedef struct {
+  int             changeset_len;
+  void            *changeset_ptr;
+} Changeset_t;
+#endif
+
 enum query_mode {
   QUERY_YIELD,
   QUERY_MULTI_ROW,
@@ -97,8 +108,12 @@ enum gvl_mode {
 #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 TRACE_SQL(db, sql) \
+    if (db->trace_proc != Qnil) rb_funcall(db->trace_proc, ID_call, 1, sql);
+
 #define DEFAULT_GVL_RELEASE_THRESHOLD 1000
 
+
 extern rb_encoding *UTF8_ENCODING;
 
 VALUE safe_batch_execute(query_ctx *ctx);
@@ -125,14 +140,15 @@ VALUE Query_to_a_hash(VALUE self);
 VALUE Query_to_a_ary(VALUE self);
 VALUE Query_to_a_single_column(VALUE self);
 
-void prepare_single_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
-void prepare_multi_stmt(sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
+void prepare_single_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
+void prepare_multi_stmt(enum gvl_mode mode, sqlite3 *db, sqlite3_stmt **stmt, VALUE sql);
 void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv);
 void bind_all_parameters_from_object(sqlite3_stmt *stmt, VALUE obj);
 int stmt_iterate(query_ctx *ctx);
 VALUE cleanup_stmt(query_ctx *ctx);
 
 sqlite3 *Database_sqlite3_db(VALUE self);
+enum gvl_mode Database_prepare_gvl_mode(Database_t *db);
 Database_t *self_to_database(VALUE self);
 
 void *gvl_call(enum gvl_mode mode, void *(*fn)(void *), void *data);

data/ext/extralite/extralite_ext.c

@@ -3,6 +3,9 @@
 void Init_ExtraliteDatabase();
 void Init_ExtraliteQuery();
 void Init_ExtraliteIterator();
+#ifdef EXTRALITE_ENABLE_CHANGESET
+void Init_ExtraliteChangeset();
+#endif
 
 void Init_extralite_ext(void) {
   rb_ext_ractor_safe(true);
@@ -10,4 +13,7 @@ void Init_extralite_ext(void) {
   Init_ExtraliteDatabase();
   Init_ExtraliteQuery();
   Init_ExtraliteIterator();
+#ifdef EXTRALITE_ENABLE_CHANGESET
+  Init_ExtraliteChangeset();
+#endif
 }

data/ext/extralite/iterator.c

@@ -19,13 +19,18 @@ static size_t Iterator_size(const void *ptr) {
 
 static void Iterator_mark(void *ptr) {
   Iterator_t *iterator = ptr;
-  rb_gc_mark(iterator->query);
+  rb_gc_mark_movable(iterator->query);
+}
+
+static void Iterator_compact(void *ptr) {
+  Iterator_t *iterator = ptr;
+  iterator->query = rb_gc_location(iterator->query);
 }
 
 static const rb_data_type_t Iterator_type = {
     "Iterator",
-    {Iterator_mark, free, Iterator_size,},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+    {Iterator_mark, free, Iterator_size, Iterator_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE Iterator_allocate(VALUE klass) {

data/ext/extralite/query.c

@@ -14,6 +14,8 @@ VALUE cQuery;
 ID ID_inspect;
 ID ID_slice;
 
+#define DB_GVL_MODE(query) Database_prepare_gvl_mode(query->db_struct)
+
 static size_t Query_size(const void *ptr) {
   return sizeof(Query_t);
 }
@@ -88,19 +90,17 @@ VALUE Query_initialize(VALUE self, VALUE db, VALUE sql) {
 
 static inline void query_reset(Query_t *query) {
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
   sqlite3_reset(query->stmt);
   query->eof = 0;
 }
 
 static inline void query_reset_and_bind(Query_t *query, int argc, VALUE * argv) {
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
 
   sqlite3_reset(query->stmt);
   query->eof = 0;
@@ -128,8 +128,7 @@ VALUE Query_reset(VALUE self) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   query_reset(query);
-  if (query->db_struct->trace_block != Qnil)
-    rb_funcall(query->db_struct->trace_block, ID_call, 1, query->sql);
+  TRACE_SQL(query->db_struct, query->sql);
 
   return self;
 }
@@ -437,7 +436,7 @@ VALUE Query_batch_execute(VALUE self, VALUE parameters) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -481,7 +480,7 @@ VALUE Query_batch_query(VALUE self, VALUE parameters) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -525,7 +524,7 @@ VALUE Query_batch_query_ary(VALUE self, VALUE parameters) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -569,7 +568,7 @@ VALUE Query_batch_query_single_column(VALUE self, VALUE parameters) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   query_ctx ctx = QUERY_CTX(
     self,
@@ -670,7 +669,7 @@ VALUE Query_status(int argc, VALUE* argv, VALUE self) {
   if (query->closed) rb_raise(cError, "Query is closed");
 
   if (!query->stmt)
-    prepare_single_stmt(query->sqlite3_db, &query->stmt, query->sql);
+    prepare_single_stmt(DB_GVL_MODE(query), query->sqlite3_db, &query->stmt, query->sql);
 
   int value = sqlite3_stmt_status(query->stmt, NUM2INT(op), RTEST(reset) ? 1 : 0);
   return INT2NUM(value);

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.5'
+  VERSION = '2.6'
 end

data/lib/extralite.rb

@@ -60,6 +60,11 @@ module Extralite
       value.is_a?(Hash) ? pragma_set(value) : pragma_get(value)
     end
 
+    # Error class used to roll back a transaction without propagating an
+    # exception.
+    class Rollback < Error
+    end
+
     # Starts a transaction and runs the given block. If an exception is raised
     # in the block, the transaction is rolled back. Otherwise, the transaction
     # is commited after running the block.
@@ -76,13 +81,56 @@ module Extralite
     
       abort = false
       yield self
-    rescue
+    rescue => e
       abort = true
-      raise
+      raise unless e.is_a?(Rollback)
     ensure
       execute(abort ? 'rollback' : 'commit')
     end
 
+    # Creates a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def savepoint(name)
+      execute "savepoint #{name}"
+      self
+    end
+
+    # Release a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def release(name)
+      execute "release #{name}"
+      self
+    end
+
+    # Rolls back changes to a savepoint with the given name.
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def rollback_to(name)
+      execute "rollback to #{name}"
+      self
+    end
+
+    # Rolls back the currently active transaction. This method should only be
+    # called from within a block passed to Database#transaction. This method
+    # raises a Extralite::Rollback exception, which will stop execution of the
+    # transaction block without propagating the exception.
+    #
+    #   db.transaction do
+    #     db.execute('insert into foo (42)')
+    #     db.rollback!
+    #   end
+    #
+    # @param name [String, Symbol] savepoint name
+    # @return [Extralite::Database] database
+    def rollback!
+      raise Rollback
+    end
+
     private
 
     def pragma_set(values)

data/test/helper.rb

@@ -7,4 +7,11 @@ require 'minitest/autorun'
 puts "sqlite3 version: #{Extralite.sqlite3_version}"
 
 IS_LINUX = RUBY_PLATFORM =~ /linux/
-SKIP_RACTOR_TESTS = !IS_LINUX || (RUBY_VERSION =~ /^3\.0/)
+SKIP_RACTOR_TESTS = !IS_LINUX || (RUBY_VERSION =~ /^3\.[01]/)
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end