extralite-bundle 2.5 → 2.7

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

@@ -35,60 +35,60 @@ else
   end
 
   if with_config('sqlcipher')
-    pkg_config("sqlcipher")
+    pkg_config('sqlcipher')
   else
-    pkg_config("sqlite3")
+    pkg_config('sqlite3')
   end
 
   # --with-sqlite3-{dir,include,lib}
   if with_config('sqlcipher')
     $CFLAGS << ' -DUSING_SQLCIPHER'
-    dir_config("sqlcipher", cppflags, ldflags)
+    dir_config('sqlcipher', cppflags, ldflags)
   else
-    dir_config("sqlite3", cppflags, ldflags)
+    dir_config('sqlite3', cppflags, ldflags)
   end
 
-  if RbConfig::CONFIG["host_os"] =~ /mswin/
+  if RbConfig::CONFIG['host_os'] =~ /mswin/
     $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."
+      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('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
 
-    $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

@@ -17,12 +17,15 @@
   VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); \
   printf(": %s\n", StringValueCStr(s)); \
 }
+#define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
+#define TRACE_CALLER() INSPECT("caller: ", CALLER())
 
 #define SAFE(f) (VALUE (*)(VALUE))(f)
 
 extern VALUE cDatabase;
 extern VALUE cQuery;
 extern VALUE cIterator;
+extern VALUE cChangeset;
 extern VALUE cBlob;
 
 extern VALUE cError;
@@ -36,54 +39,95 @@ 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_argv;
 extern VALUE SYM_ary;
-extern VALUE SYM_single_column;
+extern VALUE SYM_hash;
+
+enum progress_handler_mode {
+  PROGRESS_NONE,
+  PROGRESS_NORMAL,
+  PROGRESS_ONCE,
+  PROGRESS_AT_LEAST_ONCE,
+};
+
+struct progress_handler {
+  enum progress_handler_mode  mode;
+  VALUE                       proc;
+  int                         period;
+  int                         tick;
+  int                         tick_count;
+  int                         call_count;
+};
 
 typedef struct {
-  sqlite3 *sqlite3_db;
-  VALUE   trace_block;
-  int     gvl_release_threshold;
+  sqlite3                 *sqlite3_db;
+  VALUE                   trace_proc;
+  int                     gvl_release_threshold;
+  struct progress_handler progress_handler;
 } Database_t;
 
+enum query_mode {
+  QUERY_HASH,
+  QUERY_ARGV,
+  QUERY_ARY
+};
+
 typedef struct {
-  VALUE         db;
-  VALUE         sql;
-  Database_t    *db_struct;
-  sqlite3       *sqlite3_db;
-  sqlite3_stmt  *stmt;
-  int           eof;
-  int           closed;
+  VALUE               db;
+  VALUE               sql;
+  VALUE               transform_proc;
+  Database_t          *db_struct;
+  sqlite3             *sqlite3_db;
+  sqlite3_stmt        *stmt;
+  int                 eof;
+  int                 closed;
+  enum query_mode     query_mode;
 } Query_t;
 
 enum iterator_mode {
   ITERATOR_HASH,
+  ITERATOR_ARGV,
   ITERATOR_ARY,
   ITERATOR_SINGLE_COLUMN
 };
 
 typedef struct {
   VALUE               query;
-  enum iterator_mode  mode;
 } Iterator_t;
 
-enum query_mode {
-  QUERY_YIELD,
-  QUERY_MULTI_ROW,
-  QUERY_SINGLE_ROW
+#ifdef EXTRALITE_ENABLE_CHANGESET
+typedef struct {
+  int             changeset_len;
+  void            *changeset_ptr;
+} Changeset_t;
+#endif
+
+enum row_mode {
+  ROW_YIELD,
+  ROW_MULTI,
+  ROW_SINGLE
 };
 
 typedef struct {
-  VALUE           self;
-  sqlite3         *sqlite3_db;
-  sqlite3_stmt    *stmt;
-  VALUE           params;
-  enum query_mode mode;
-  int             max_rows;
-  int             eof;
-  int             gvl_release_threshold;
-  int             step_count;
+  VALUE               self;
+  VALUE               sql;
+  VALUE               params;
+  VALUE               transform_proc;
+
+  Database_t          *db;
+  sqlite3             *sqlite3_db;
+  sqlite3_stmt        *stmt;
+
+  int                 gvl_release_threshold;
+  enum query_mode     query_mode;
+  enum row_mode       row_mode;
+  int                 max_rows;
+
+  int                 eof;
+  int                 step_count;
 } query_ctx;
 
 enum gvl_mode {
@@ -93,46 +137,59 @@ enum gvl_mode {
 
 #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 ROW_YIELD_OR_MODE(default) (rb_block_given_p() ? ROW_YIELD : default)
+#define ROW_MULTI_P(mode) (mode == ROW_MULTI)
+#define QUERY_CTX(self, sql, db, stmt, params, transform_proc, query_mode, row_mode, max_rows) { \
+  self, \
+  sql, \
+  params, \
+  transform_proc, \
+  db, \
+  db->sqlite3_db, \
+  stmt, \
+  db->gvl_release_threshold, \
+  query_mode, \
+  row_mode, \
+  max_rows, \
+  0, \
+  0 \
+}
+
 #define DEFAULT_GVL_RELEASE_THRESHOLD 1000
+#define DEFAULT_PROGRESS_HANDLER_PERIOD 1000
+#define DEFAULT_PROGRESS_HANDLER_TICK 10
 
 extern rb_encoding *UTF8_ENCODING;
 
+typedef VALUE (*safe_query_impl)(query_ctx *);
+
 VALUE safe_batch_execute(query_ctx *ctx);
 VALUE safe_batch_query(query_ctx *ctx);
+VALUE safe_batch_query_argv(query_ctx *ctx);
 VALUE safe_batch_query_ary(query_ctx *ctx);
-VALUE safe_batch_query_single_column(query_ctx *ctx);
+VALUE safe_query_argv(query_ctx *ctx);
 VALUE safe_query_ary(query_ctx *ctx);
 VALUE safe_query_changes(query_ctx *ctx);
 VALUE safe_query_columns(query_ctx *ctx);
 VALUE safe_query_hash(query_ctx *ctx);
-VALUE safe_query_single_column(query_ctx *ctx);
-VALUE safe_query_single_row(query_ctx *ctx);
-VALUE safe_query_single_value(query_ctx *ctx);
-
-VALUE Query_each_hash(VALUE self);
-VALUE Query_each_ary(VALUE self);
-VALUE Query_each_single_column(VALUE self);
-
-VALUE Query_next_hash(int argc, VALUE *argv, VALUE self);
-VALUE Query_next_ary(int argc, VALUE *argv, VALUE self);
-VALUE Query_next_single_column(int argc, VALUE *argv, VALUE self);
+VALUE safe_query_single_row_hash(query_ctx *ctx);
+VALUE safe_query_single_row_argv(query_ctx *ctx);
+VALUE safe_query_single_row_ary(query_ctx *ctx);
 
-VALUE Query_to_a_hash(VALUE self);
-VALUE Query_to_a_ary(VALUE self);
-VALUE Query_to_a_single_column(VALUE self);
+VALUE Query_each(VALUE self);
+VALUE Query_next(int argc, VALUE *argv, VALUE self);
+VALUE Query_to_a(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);
 
+void Database_issue_query(Database_t *db, VALUE sql);
 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

@@ -9,23 +9,24 @@
 
 VALUE cIterator;
 
-VALUE SYM_hash;
-VALUE SYM_ary;
-VALUE SYM_single_column;
-
 static size_t Iterator_size(const void *ptr) {
   return sizeof(Iterator_t);
 }
 
 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) {
@@ -40,14 +41,6 @@ static inline Iterator_t *self_to_iterator(VALUE obj) {
   return iterator;
 }
 
-static inline enum iterator_mode symbol_to_mode(VALUE sym) {
-  if (sym == SYM_hash) return ITERATOR_HASH;
-  if (sym == SYM_ary) return ITERATOR_ARY;
-  if (sym == SYM_single_column) return ITERATOR_SINGLE_COLUMN;
-
-  rb_raise(cError, "Invalid iterator mode");
-}
-
 /* Initializes an iterator using the given query object and iteration mode. The
  * 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`,
@@ -60,28 +53,12 @@ static inline enum iterator_mode symbol_to_mode(VALUE sym) {
  * @param mode [Symbol] iteration mode
  * @return [void]
  */
-VALUE Iterator_initialize(VALUE self, VALUE query, VALUE mode) {
+VALUE Iterator_initialize(VALUE self, VALUE query) {
   Iterator_t *iterator = self_to_iterator(self);
-
   iterator->query = query;
-  iterator->mode = symbol_to_mode(mode);
-
   return Qnil;
 }
 
-typedef VALUE (*each_method)(VALUE);
-
-inline each_method mode_to_each_method(enum iterator_mode mode) {
-  switch (mode) {
-    case ITERATOR_ARY:
-      return Query_each_ary;
-    case ITERATOR_SINGLE_COLUMN:
-      return Query_each_single_column;
-    default:
-      return Query_each_hash;
-  }
-}
-
 /* Iterates through the associated query's result set using the iteration mode
  * set when initialized. Each row would be passed to the given block according
  * to the iteration mode, i.e. as a hash, an array, or a single value. In
@@ -93,26 +70,12 @@ inline each_method mode_to_each_method(enum iterator_mode mode) {
 VALUE Iterator_each(VALUE self) {
   if (rb_block_given_p()) {
     Iterator_t *iterator = self_to_iterator(self);
-    each_method method = mode_to_each_method(iterator->mode);
-    method(iterator->query);
+    Query_each(iterator->query);
   }
 
   return self;
 }
 
-typedef VALUE (*next_method)(int, VALUE *, VALUE);
-
-inline next_method mode_to_next_method(enum iterator_mode mode) {
-  switch (mode) {
-    case ITERATOR_ARY:
-      return Query_next_ary;
-    case ITERATOR_SINGLE_COLUMN:
-      return Query_next_single_column;
-    default:
-      return Query_next_hash;
-  }
-}
-
 /* 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.
  *
@@ -131,25 +94,11 @@ inline next_method mode_to_next_method(enum iterator_mode mode) {
  */
 VALUE Iterator_next(int argc, VALUE *argv, VALUE self) {
   Iterator_t *iterator = self_to_iterator(self);
-  next_method method = mode_to_next_method(iterator->mode);
-  VALUE result = method(argc, argv, iterator->query);
+  VALUE result = Query_next(argc, argv, iterator->query);
 
   return rb_block_given_p() ? self : result;
 }
 
-typedef VALUE (*to_a_method)(VALUE);
-
-inline to_a_method mode_to_to_a_method(enum iterator_mode mode) {
-  switch (mode) {
-    case ITERATOR_ARY:
-      return Query_to_a_ary;
-    case ITERATOR_SINGLE_COLUMN:
-      return Query_to_a_single_column;
-    default:
-      return Query_to_a_hash;
-  }
-}
-
 /* 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.
  *
@@ -157,19 +106,7 @@ inline to_a_method mode_to_to_a_method(enum iterator_mode mode) {
  */
 VALUE Iterator_to_a(VALUE self) {
   Iterator_t *iterator = self_to_iterator(self);
-  to_a_method method = mode_to_to_a_method(iterator->mode);
-  return method(iterator->query);
-}
-
-inline VALUE mode_to_symbol(Iterator_t *iterator) {
-  switch (iterator->mode) {
-    case ITERATOR_ARY:
-      return SYM_ary;
-    case ITERATOR_SINGLE_COLUMN:
-      return SYM_single_column;
-    default:
-      return SYM_hash;
-  }
+  return Query_to_a(iterator->query);
 }
 
 /* Returns a short string representation of the iterator instance, including the
@@ -179,9 +116,8 @@ 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);
+  return rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)self);
 }
 
 void Init_ExtraliteIterator(void) {
@@ -192,17 +128,9 @@ void Init_ExtraliteIterator(void) {
 
   rb_include_module(cIterator, rb_mEnumerable);
 
-  rb_define_method(cIterator, "initialize", Iterator_initialize, 2);
+  rb_define_method(cIterator, "initialize", Iterator_initialize, 1);
   rb_define_method(cIterator, "each", Iterator_each, 0);
   rb_define_method(cIterator, "inspect", Iterator_inspect, 0);
   rb_define_method(cIterator, "next", Iterator_next, -1);
   rb_define_method(cIterator, "to_a", Iterator_to_a, 0);
-
-  SYM_hash          = ID2SYM(rb_intern("hash"));
-  SYM_ary           = ID2SYM(rb_intern("ary"));
-  SYM_single_column = ID2SYM(rb_intern("single_column"));
-
-  rb_gc_register_mark_object(SYM_hash);
-  rb_gc_register_mark_object(SYM_ary);
-  rb_gc_register_mark_object(SYM_single_column);
 }