extralite 2.4 → 2.6

data/ext/extralite/database.c

@@ -13,11 +13,19 @@ VALUE eArgumentError;
 
 ID ID_bind;
 ID ID_call;
+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);
@@ -25,7 +33,14 @@ 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_proc);
+  rb_gc_mark_movable(db->progress_handler_proc);
+}
+
+static void Database_compact(void *ptr) {
+  Database_t *db = ptr;
+  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) {
@@ -36,7 +51,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 +100,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) {
@@ -124,9 +165,12 @@ 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);
+
   return Qnil;
 }
 
@@ -170,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;
@@ -180,9 +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;
 
-  // 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);
+  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);
@@ -342,30 +389,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);
+  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);
+}
+
+/* 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_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);
+}
+
+/* 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_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);
+}
+
+/* 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_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_execute_multi), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
+  return rb_ensure(SAFE(safe_batch_query_single_column), (VALUE)&ctx, SAFE(cleanup_stmt), (VALUE)&ctx);
 }
 
 /* call-seq:
@@ -449,8 +616,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);
@@ -697,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;
 }
 
@@ -777,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;
@@ -811,7 +1108,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);
@@ -820,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);
@@ -831,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
@@ -849,12 +1155,22 @@ 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");
+  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"));
+  SYM_synchronous           = ID2SYM(rb_intern("synchronous"));
+  SYM_wal_journal_mode      = ID2SYM(rb_intern("wal_journal_mode"));
 
-  SYM_read_only = ID2SYM(rb_intern("read_only"));
+  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/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;
@@ -32,17 +33,21 @@ 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 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;
 
@@ -67,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,
@@ -96,11 +108,18 @@ 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_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);
@@ -121,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);