sqlite3-ffi 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 402ba8b0d0f49fd0f6229dba55575c8c5c22e460a2c2883095782f7f0f370ae6
-  data.tar.gz: 22c9aad92904a410a4a697aa8dddcb84519e4669cb8976c57ba6d1f2c04c37d4
+  metadata.gz: 88fbf37c663c6a41c1f491c411813c2dec850f22a00bb04fb970876c0b00cf94
+  data.tar.gz: 04327ad75659e1ca926446b21f72ecc974aec0dea1fe4c1176adab29e1d0c63e
 SHA512:
-  metadata.gz: 9ef8d936ee00247132f2d0c632491bffc4802915b539267ffc8131c13dfcee6cb85eb568d68d439894eed3a511813cb9e7f19baf82cbeff9fd7d896bdc4b8845
-  data.tar.gz: 0a454150d3d90edbf20cd59f3eb69c75d0825bb406efb290aded8b4376e32ea14e45e6317252134c691fddbb1e065a00f9ae8981d852861131ad1a4c80e0bf16
+  metadata.gz: '0584a32cb0eff8e49cd76ffaa48756951f83cbaa897360289ab2c92e7a96adcb8ae3bda2b2558145a3fb788f3358e2e4834fed00134a2635e8a49b89c6ecaf81'
+  data.tar.gz: 0d9fcea2a566d141dc167b1ba760dbbc313e0a9ff9865cb761d1e9e803c5119807ce2055d5976618a818a9561ff8c97bfa7d792ccec9ed49df679f8db7c0a94b

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.1 (2026-10-27)
+
+- Synced with sqlite3-ruby 2.10.2
+
 ## 0.2.0 (2026-10-13)
 
 - Synced with sqlite3-ruby 2.10.0

data/lib/sqlite3/database.rb

@@ -579,6 +579,25 @@ module SQLite3
       self
     end
 
+    # The "handler" that #define_aggregator hands to define_aggregator2, which
+    # only needs something that responds to +new+ (a fresh aggregator for each
+    # aggregate invocation) and +arity+.
+    class AggregatorFactory # :nodoc:
+      def initialize(template)
+        @template = template
+      end
+
+      def new
+        @template.clone
+      end
+
+      # this is what sqlite3_obj_method_arity did before
+      def arity
+        @template.method(:step).arity
+      end
+    end
+    private_constant :AggregatorFactory
+
     # Define an aggregate function named +name+ using a object template
     # object +aggregator+. +aggregator+ must respond to +step+ and +finalize+.
     # +step+ will be called with row information and +finalize+ must return the
@@ -592,36 +611,7 @@ module SQLite3
     def define_aggregator(name, aggregator)
       # Previously, this has been implemented in C. Now this is just yet
       # another compatibility shim
-      proxy = Class.new do
-        @template = aggregator
-        @name = name
-
-        def self.template
-          @template
-        end
-
-        def self.name
-          @name
-        end
-
-        def self.arity
-          # this is what sqlite3_obj_method_arity did before
-          @template.method(:step).arity
-        end
-
-        def initialize
-          @klass = self.class.template.clone
-        end
-
-        def step(*args)
-          @klass.step(*args)
-        end
-
-        def finalize
-          @klass.finalize
-        end
-      end
-      define_aggregator2(proxy, name)
+      define_aggregator2(AggregatorFactory.new(aggregator), name)
       self
     end
 

data/lib/sqlite3/ffi/aggregator.rb

@@ -1,17 +1,8 @@
 module SQLite3
   module FFI
-    class AggregatorWrapper
-      attr_reader :handler_klass, :instances
+    AggregatorWrapper = Struct.new(:handler_klass, :instances)
 
-      def initialize(handler_klass)
-        @handler_klass = handler_klass
-        @instances = []
-      end
-    end
-
-    class AggregatorInstance
-      attr_accessor :handler_instance
-    end
+    AggregatorInstance = Struct.new(:handler_instance)
 
     def self.aggregate_instance(ctx)
       aw = FFI.unwrap(CApi.sqlite3_user_data(ctx))
@@ -64,26 +55,22 @@ module SQLite3
     end
 
     AGGREGATOR_STEP = ::FFI::Function.new(:void, [:pointer, :int, :pointer]) do |ctx, argc, argv|
-      begin
+      FFI.protect_callback do
         inst = aggregate_instance(ctx)
         handler_instance = inst.handler_instance
         params = argv.read_array_of_pointer(argc).map { |v| FFI.sqlite3val2rb(v) }
         handler_instance.step(*params)
-      rescue => e
-        FFI.rb_errinfo = e
       end
     end
 
     AGGREGATOR_FINAL = ::FFI::Function.new(:void, [:pointer]) do |ctx|
-      begin
+      FFI.protect_callback do
         inst = aggregate_instance(ctx)
         handler_instance = inst.handler_instance
         result = handler_instance.finalize
         FFI.set_sqlite3_func_result(ctx, result)
-        aggregate_instance_destroy(ctx)
-      rescue => e
-        FFI.rb_errinfo = e
       end
+      aggregate_instance_destroy(ctx)
     end
   end
 end

data/lib/sqlite3/ffi/backup.rb

@@ -8,12 +8,12 @@ module SQLite3
         raise ArgumentError, "cannot backup to a closed database"
       end
 
-      ddb = dstdb.instance_variable_get(:@db)
+      ddb = dstdb.instance_variable_get(:@ctx).db
       @p =
         FFI::CApi.sqlite3_backup_init(
           ddb,
           FFI.string_value(dstname),
-          srcdb.instance_variable_get(:@db),
+          srcdb.instance_variable_get(:@ctx).db,
           FFI.string_value(srcname)
         )
 
@@ -24,8 +24,15 @@ module SQLite3
 
     def step(n_page)
       require_open_backup
+      pages = n_page.to_i
 
-      FFI::CApi.sqlite3_backup_step(@p, n_page)
+      frame = FFI::CallbackFrame.new
+      FFI.push_callback_frame(frame)
+      status = FFI::CApi.sqlite3_backup_step(@p, pages)
+      if (callback_state = FFI.pop_callback_frame(frame))
+        raise callback_state
+      end
+      status
     end
 
     def finish

data/lib/sqlite3/ffi/database.rb

@@ -6,21 +6,21 @@ module SQLite3
     end
 
     def closed?
-      @db.nil?
+      @ctx&.db.nil?
     end
 
     def total_changes
       require_open_db
 
-      FFI::CApi.sqlite3_total_changes(@db)
+      FFI::CApi.sqlite3_total_changes(@ctx.db)
     end
 
     def trace(blk = nil, &block)
       require_open_db
 
       blk ||= block
-      @tracefunc = blk
-      FFI::CApi.sqlite3_trace_v2(@db, FFI::CApi::SQLITE_TRACE_STMT, blk.nil? ? nil : FFI::TRACE, FFI.wrap(blk))
+      @ctx.trace_handler = blk
+      FFI::CApi.sqlite3_trace_v2(@ctx.db, FFI::CApi::SQLITE_TRACE_STMT, blk.nil? ? nil : FFI::TRACE, FFI.wrap(@ctx))
       self
     end
 
@@ -28,31 +28,32 @@ module SQLite3
       require_open_db
 
       blk ||= block
-      @busy_handler = blk
-      status = FFI::CApi.sqlite3_busy_handler(@db, FFI::BUSY_HANDLER, FFI.wrap(self))
-      FFI.check(@db, status)
+      @ctx.busy_handler = blk
+      status = FFI::CApi.sqlite3_busy_handler(@ctx.db, FFI::BUSY_HANDLER, FFI.wrap(@ctx))
+      FFI.check(@ctx.db, status)
       self
     end
 
     def statement_timeout=(milliseconds)
-      @stmt_timeout = milliseconds.to_i
+      @ctx.stmt_timeout = milliseconds.to_i
       n = milliseconds.to_i == 0 ? -1 : 1000
-      FFI::CApi.sqlite3_progress_handler(@db, n, FFI::STATEMENT_TIMEOUT, FFI.wrap(self))
+      FFI::CApi.sqlite3_progress_handler(@ctx.db, n, FFI::STATEMENT_TIMEOUT, FFI.wrap(@ctx))
       self
     end
 
     def last_insert_row_id
       require_open_db
 
-      FFI::CApi.sqlite3_last_insert_rowid(@db)
+      FFI::CApi.sqlite3_last_insert_rowid(@ctx.db)
     end
 
     def define_function_with_flags(name, flags, &block)
       require_open_db
 
-      status = FFI::CApi.sqlite3_create_function(@db, FFI.string_value(name), block.arity, flags, FFI.wrap(block), FFI::FUNC, nil, nil)
-      FFI.check(@db, status)
+      status = FFI::CApi.sqlite3_create_function(@ctx.db, FFI.string_value(name), block.arity, flags, FFI.wrap(block), FFI::FUNC, nil, nil)
+      FFI.check(@ctx.db, status)
       @functions << block
+      @ctx.functions = @functions
       self
     end
 
@@ -63,20 +64,20 @@ module SQLite3
     def interrupt
       require_open_db
 
-      FFI::CApi.sqlite3_interrupt(@db)
+      FFI::CApi.sqlite3_interrupt(@ctx.db)
       self
     end
 
     def errmsg
       require_open_db
 
-      FFI::CApi.sqlite3_errmsg(@db)
+      FFI::CApi.sqlite3_errmsg(@ctx.db)
     end
 
     def errcode
       require_open_db
 
-      FFI::CApi.sqlite3_errcode(@db)
+      FFI::CApi.sqlite3_errcode(@ctx.db)
     end
 
     def complete?(sql)
@@ -86,35 +87,52 @@ module SQLite3
     def changes
       require_open_db
 
-      FFI::CApi.sqlite3_changes(@db)
+      FFI::CApi.sqlite3_changes(@ctx.db)
     end
 
     def authorizer=(authorizer)
       require_open_db
 
-      status = FFI::CApi.sqlite3_set_authorizer(@db, authorizer.nil? ? nil : FFI::AUTH, FFI.wrap(authorizer))
-      FFI.check(@db, status)
-      @authorizer = authorizer
+      status = FFI::CApi.sqlite3_set_authorizer(@ctx.db, authorizer.nil? ? nil : FFI::AUTH, FFI.wrap(@ctx))
+      FFI.check(@ctx.db, status)
+      @ctx.authorizer = authorizer
     end
 
     def busy_timeout=(timeout)
       require_open_db
 
-      FFI.check(@db, FFI::CApi.sqlite3_busy_timeout(@db, timeout))
+      FFI.check(@ctx.db, FFI::CApi.sqlite3_busy_timeout(@ctx.db, timeout))
     end
 
     def extended_result_codes=(enable)
       require_open_db
 
-      FFI::CApi.sqlite3_extended_result_codes(@db, enable ? 1 : 0)
+      FFI::CApi.sqlite3_extended_result_codes(@ctx.db, enable ? 1 : 0)
       self
     end
 
     def collation(name, comparator)
       require_open_db
 
-      status = FFI::CApi.sqlite3_create_collation(@db, name, FFI::CApi::SQLITE_UTF8, FFI.wrap(comparator), comparator.nil? ? nil : FFI::COMPARATOR)
-      FFI.check(@db, status)
+      name = FFI.string_value(name)
+      key = name.dup
+      key.each_byte.with_index do |v, i|
+        if v >= 65 && v <= 90 # 'A' and 'Z'
+          key.setbyte(i, v + 32) # 'a' - 'A'
+        end
+      end
+
+      @_collations ||= {}
+      registry = @_collations
+
+      status = FFI::CApi.sqlite3_create_collation(@ctx.db, name, FFI::CApi::SQLITE_UTF8, FFI.wrap(comparator), comparator.nil? ? nil : FFI::COMPARATOR)
+      FFI.check(@ctx.db, status)
+
+      registry[key] = comparator
+      comparators = []
+      comparators += registry.values
+      @ctx.collations = comparators
+
       @collations[name] = comparator
       self
     end
@@ -130,7 +148,7 @@ module SQLite3
         else
           onoffparam = onoff.to_i
         end
-        FFI.check(@db, FFI::CApi.sqlite3_enable_load_extension(@db, onoffparam))
+        FFI.check(@ctx.db, FFI::CApi.sqlite3_enable_load_extension(@ctx.db, onoffparam))
         self
       end
     end
@@ -138,26 +156,33 @@ module SQLite3
     def transaction_active?
       require_open_db
 
-      FFI::CApi.sqlite3_get_autocommit(@db).zero?
+      FFI::CApi.sqlite3_get_autocommit(@ctx.db).zero?
     end
 
     def exec_batch(sql, results_as_hash)
       require_open_db
 
-      @stmt_deadline = nil
+      sql_cstr = FFI.string_value(sql)
+      @ctx.stmt_deadline = nil
 
       callback_ary = []
       err_msg = ::FFI::MemoryPointer.new(:pointer)
       callback = results_as_hash == true ? FFI::HASH_CALLBACK : FFI::REGULAR_CALLBACK
-      status = FFI::CApi.sqlite3_exec(@db, FFI.string_value(sql), callback, FFI.wrap(callback_ary), err_msg)
-      FFI.check_msg(@db, status, err_msg)
+      frame = FFI::CallbackFrame.new
+      FFI.push_callback_frame(frame)
+      status = FFI::CApi.sqlite3_exec(@ctx.db, sql_cstr, callback, FFI.wrap(callback_ary), err_msg)
+      if (state = FFI.pop_callback_frame(frame))
+        FFI::CApi.sqlite3_free(err_msg.read_pointer)
+        raise state
+      end
+      FFI.check_msg(@ctx.db, status, err_msg)
       callback_ary
     end
 
     def db_filename(db_name)
       require_open_db
 
-      fname = FFI::CApi.sqlite3_db_filename(@db, db_name)
+      fname = FFI::CApi.sqlite3_db_filename(@ctx.db, db_name)
       fname.null? ? nil : fname.read_string.force_encoding(Encoding::UTF_8)
     end
 
@@ -168,7 +193,7 @@ module SQLite3
         z_schema = db_name.nil? ? nil : FFI.string_value_cstr(db_name)
 
         size = ::FFI::MemoryPointer.new(:int64)
-        data = FFI::CApi.sqlite3_serialize(@db, z_schema, size, 0)
+        data = FFI::CApi.sqlite3_serialize(@ctx.db, z_schema, size, 0)
         size = size.read_int64
 
         if data.null? && size < 0
@@ -200,9 +225,9 @@ module SQLite3
         p_data.put_bytes(0, data)
         p_data.put_bytes(sz_db, "\x00"*(sz_buf - sz_db))
 
-        status = FFI::CApi.sqlite3_deserialize(@db, z_schema, p_data, sz_db, sz_db, FFI::CApi::SQLITE_DESERIALIZE_FREEONCLOSE | FFI::CApi::SQLITE_DESERIALIZE_RESIZEABLE)
+        status = FFI::CApi.sqlite3_deserialize(@ctx.db, z_schema, p_data, sz_db, sz_db, FFI::CApi::SQLITE_DESERIALIZE_FREEONCLOSE | FFI::CApi::SQLITE_DESERIALIZE_RESIZEABLE)
 
-        FFI.check(@db, status)
+        FFI.check(@ctx.db, status)
         self
       end
     end
@@ -210,13 +235,13 @@ module SQLite3
     private
 
     def require_open_db
-      if @db.nil?
+      if @ctx&.db.nil?
         raise SQLite3::Exception, "cannot use a closed database"
       end
     end
 
     def require_closed_db
-      if !@db.nil?
+      if !@ctx&.db.nil?
         raise SQLite3::Exception, "cannot open a database that is already open"
       end
     end
@@ -224,38 +249,38 @@ module SQLite3
     def discard_db
       sfile = ::FFI::MemoryPointer.new(:pointer)
 
-      FFI::CApi.sqlite3_db_release_memory(@db)
+      FFI::CApi.sqlite3_db_release_memory(@ctx.db)
 
       if FFI::CApi::HAVE_SQLITE3_DB_NAME
         j_db = 0
-        while !(db_name = FFI::CApi.sqlite3_db_name(@db, j_db)).null?
-          status = FFI::CApi.sqlite3_file_control(@db, db_name, FFI::CApi::SQLITE_FCNTL_FILE_POINTER, sfile)
+        while !(db_name = FFI::CApi.sqlite3_db_name(@ctx.db, j_db)).null?
+          status = FFI::CApi.sqlite3_file_control(@ctx.db, db_name, FFI::CApi::SQLITE_FCNTL_FILE_POINTER, sfile)
           if status == 0
             # TODO
           end
           j_db += 1
         end
       else
-        status = FFI::CApi.sqlite3_file_control(@db, nil, FFI::CApi::SQLITE_FCNTL_FILE_POINTER, sfile)
+        status = FFI::CApi.sqlite3_file_control(@ctx.db, nil, FFI::CApi::SQLITE_FCNTL_FILE_POINTER, sfile)
         if status == 0
           # TODO
         end
       end
 
-      status = FFI::CApi.sqlite3_file_control(@db, nil, FFI::CApi::SQLITE_FCNTL_JOURNAL_POINTER, sfile)
+      status = FFI::CApi.sqlite3_file_control(@ctx.db, nil, FFI::CApi::SQLITE_FCNTL_JOURNAL_POINTER, sfile)
       if status == 0
         # TODO
       end
 
-      @db = nil
-      @discarded = true
+      @ctx.db = nil
+      @ctx.discarded = true
     end
 
     def close_or_discard_db
-      unless @db.nil?
-        if @readonly || @owner == Process.pid
-          @db.free
-          @db = nil
+      unless @ctx&.db.nil?
+        if @ctx.readonly || @ctx.owner == Process.pid
+          @ctx.db.free
+          @ctx.db = nil
         else
           discard_db
         end
@@ -282,23 +307,23 @@ module SQLite3
 
     def open_v2(file, flags, zvfs)
       require_closed_db
-      @owner = Process.pid
+      @ctx = FFI::Context.new
+      @ctx.owner = Process.pid
       db = ::FFI::MemoryPointer.new(:pointer)
       status = FFI::CApi.sqlite3_open_v2(FFI.string_value_cstr(file), db, flags, zvfs.nil? ? nil : FFI.string_value_cstr(zvfs))
-      @db = db.read_pointer
-      @db = ::FFI::AutoPointer.new(db.read_pointer, FFI::CApi.method(:sqlite3_close_v2))
-      FFI.check(@db, status)
+      @ctx.db = ::FFI::AutoPointer.new(db.read_pointer, FFI::CApi.method(:sqlite3_close_v2))
+      FFI.check(@ctx.db, status)
       if (flags & FFI::CApi::SQLITE_OPEN_READONLY) != 0
-        @readonly = true
+        @ctx.readonly = true
       end
       self
     end
 
     def disable_quirk_mode
-      return false if @db.nil?
+      return false if @ctx&.db.nil?
 
-      FFI::CApi.sqlite3_db_config(@db, FFI::CApi::SQLITE_DBCONFIG_DQS_DDL, :int, 0, :pointer, nil)
-      FFI::CApi.sqlite3_db_config(@db, FFI::CApi::SQLITE_DBCONFIG_DQS_DML, :int, 0, :pointer, nil)
+      FFI::CApi.sqlite3_db_config(@ctx.db, FFI::CApi::SQLITE_DBCONFIG_DQS_DDL, :int, 0, :pointer, nil)
+      FFI::CApi.sqlite3_db_config(@ctx.db, FFI::CApi::SQLITE_DBCONFIG_DQS_DML, :int, 0, :pointer, nil)
       true
     end
 
@@ -312,26 +337,27 @@ module SQLite3
         require_open_db
 
         err_msg = ::FFI::MemoryPointer.new(:pointer)
-        status = FFI::CApi.sqlite3_load_extension(@db, FFI.string_value(file), nil, err_msg)
-        FFI.check_msg(@db, status, err_msg)
+        status = FFI::CApi.sqlite3_load_extension(@ctx.db, FFI.string_value(file), nil, err_msg)
+        FFI.check_msg(@ctx.db, status, err_msg)
         self
       end
     end
 
     def open16(file)
       require_closed_db
-      @owner = Process.pid
+      @ctx = FFI::Context.new
+      @ctx.owner = Process.pid
       db = ::FFI::MemoryPointer.new(:pointer)
       status = FFI::CApi.sqlite3_open16(utf16_string_value_ptr(file), db)
-      @db = ::FFI::AutoPointer.new(db.read_pointer, FFI::CApi.method(:sqlite3_close_v2))
+      @ctx.db = ::FFI::AutoPointer.new(db.read_pointer, FFI::CApi.method(:sqlite3_close_v2))
       if status != FFI::CApi::SQLITE_OK
         # https://github.com/ffi/ffi/issues/1121
-        # msg = FFI::CApi.sqlite3_mprintf("%s", :string, FFI::CApi.sqlite3_errmsg(@db))
+        # msg = FFI::CApi.sqlite3_mprintf("%s", :string, FFI::CApi.sqlite3_errmsg(@ctx.db))
         # msg = ::FFI::MemoryPointer.new(:pointer).write_pointer(msg)
-        msg = FFI::CApi.sqlite3_errmsg(@db)
-        @db.free
-        @db = nil
-        FFI.check_msg(@db, status, msg)
+        msg = FFI::CApi.sqlite3_errmsg(@ctx.db)
+        @ctx.db.free
+        @ctx.db = nil
+        FFI.check_msg(@ctx.db, status, msg)
       end
       status
     end
@@ -349,12 +375,18 @@ module SQLite3
         raise ArgumentError, "Aggregator arity=#{arity} out of range -1..127"
       end
 
-      aw = FFI::AggregatorWrapper.new(aggregator)
-      status = FFI::CApi.sqlite3_create_function(@db, FFI.string_value(ruby_name), arity, FFI::CApi::SQLITE_UTF8, FFI.wrap(aw), nil, FFI::AGGREGATOR_STEP, FFI::AGGREGATOR_FINAL)
-      FFI.check(@db, status)
+      @_aggregators ||= []
+      aggregators = @_aggregators
+
+      aw = FFI::AggregatorWrapper.new
+      aw.handler_klass = aggregator
+      aw.instances = []
+
+      status = FFI::CApi.sqlite3_create_function(@ctx.db, FFI.string_value(ruby_name), arity, FFI::CApi::SQLITE_UTF8, FFI.wrap(aw), nil, FFI::AGGREGATOR_STEP, FFI::AGGREGATOR_FINAL)
+      FFI.check(@ctx.db, status)
 
-      @aggregators ||= []
-      @aggregators << aw
+      aggregators << aw
+      @ctx.aggregators = aggregators
 
       self
     end

data/lib/sqlite3/ffi/exception.rb

@@ -107,5 +107,64 @@ module SQLite3
 
       raise exception
     end
+
+    CallbackFrame = Struct.new(:state, :prev, :holder)
+
+    CallbackFrames = Struct.new(:top)
+
+    def self.current_callback_frames_holder
+      holder = Thread.current[:__sqlite3_callback_frames__]
+      holder.is_a?(CallbackFrames) ? holder : nil
+    end
+
+    def self.current_callback_frames
+      holder = current_callback_frames_holder
+      holder.nil? ? nil : holder
+    end
+
+    def self.push_callback_frame(frame)
+      holder = current_callback_frames_holder
+
+      if holder.nil?
+        holder = CallbackFrames.new
+        Thread.current[:__sqlite3_callback_frames__] = holder
+      end
+      frames = holder
+
+      frame.state = nil
+      frame.prev = frames.top
+      frame.holder = holder
+      frames.top = frame
+    end
+
+    def self.pop_callback_frame(frame)
+      frame.holder.top = frame.prev
+      frame.state
+    end
+
+    def self.protect_callback
+      frames = current_callback_frames
+      frame = frames ? frames.top : nil
+      result = nil
+      state = nil
+
+      if frame && frame.state
+        failed = true
+        return [nil, failed]
+      end
+
+      begin
+        result = yield
+      rescue => e
+        state = e
+      end
+      failed = !state.nil?
+
+      if frame
+        frame.state = state
+      end
+
+      [result, failed]
+    end
   end
 end

data/lib/sqlite3/ffi/functions.rb

@@ -1,63 +1,85 @@
 module SQLite3
   module FFI
     COMPARATOR = ::FFI::Function.new(:int, [:pointer, :int, :pointer, :int, :pointer]) do |ctx, a_len, a, b_len, b|
-      comparator = unwrap(ctx)
-      a_str = a.read_bytes(a_len).force_encoding(Encoding::UTF_8)
-      b_str = b.read_bytes(b_len).force_encoding(Encoding::UTF_8)
+      result, failed =
+        protect_callback do
+          comparator = unwrap(ctx)
+          a_str = a.read_bytes(a_len).force_encoding(Encoding::UTF_8)
+          b_str = b.read_bytes(b_len).force_encoding(Encoding::UTF_8)
 
-      if Encoding.default_internal
-        a_str = a_str.encode(Encoding.default_internal)
-        b_str = b_str.encode(Encoding.default_internal)
-      end
+          if Encoding.default_internal
+            a_str = a_str.encode(Encoding.default_internal)
+            b_str = b_str.encode(Encoding.default_internal)
+          end
+
+          comparator.compare(a_str, b_str)
+        end
 
-      comparator.compare(a_str, b_str)
+      failed ? 0 : result
     end
 
     TRACE = ::FFI::Function.new(:int, [:uint, :pointer, :pointer, :pointer]) do |_, ctx, _, x|
-      unwrap(ctx).call(x.read_string)
+      protect_callback do
+        unwrap(ctx).trace_handler.call(x.read_string)
+      end
       0
     end
 
     AUTH = ::FFI::Function.new(:int, [:pointer, :int, :string, :string, :string, :string]) do |ctx, op_id, s1, s2, s3, s4|
-      result = unwrap(ctx).call(op_id, s1, s2, s3, s4)
-      if result.is_a?(Integer)
-        result
-      elsif result == true
-        CApi::SQLITE_OK
-      elsif result == false
-        CApi::SQLITE_DENY
-      else
-        CApi::SQLITE_IGNORE
-      end
+      result, failed =
+        protect_callback do
+          result = unwrap(ctx).authorizer.call(op_id, s1, s2, s3, s4)
+          if result.is_a?(Integer)
+            result
+          elsif result == true
+            CApi::SQLITE_OK
+          elsif result == false
+            CApi::SQLITE_DENY
+          else
+            CApi::SQLITE_IGNORE
+          end
+        end
+
+      failed ? CApi::SQLITE_DENY : result
     end
 
     HASH_CALLBACK = ::FFI::Function.new(:int, [:pointer, :int, :pointer, :pointer]) do |ctx, count, data, columns|
-      callback_ary = unwrap(ctx)
-      new_hash = {}
-      data.read_array_of_pointer(count).zip(columns.read_array_of_pointer(count)) do |value, column|
-        new_hash[column.read_string] = value.null? ? nil : value.read_string
-      end
-      callback_ary << new_hash
-      0
+      _, failed =
+        protect_callback do
+          callback_ary = unwrap(ctx)
+          new_hash = {}
+          data.read_array_of_pointer(count).zip(columns.read_array_of_pointer(count)) do |value, column|
+            new_hash[column.read_string] = value.null? ? nil : value.read_string
+          end
+          callback_ary << new_hash
+          nil
+        end
+
+      failed ? 1 : 0
     end
 
     REGULAR_CALLBACK = ::FFI::Function.new(:int, [:pointer, :int, :pointer, :pointer]) do |ctx, count, data, columns|
-      callback_ary = unwrap(ctx)
-      new_ary = []
-      data.read_array_of_pointer(count).each do |value|
-        new_ary << (value.null? ? nil : value.read_string)
-      end
-      callback_ary << new_ary
-      0
+      _, failed =
+        protect_callback do
+          callback_ary = unwrap(ctx)
+          new_ary = []
+          data.read_array_of_pointer(count).each do |value|
+            new_ary << (value.null? ? nil : value.read_string)
+          end
+          callback_ary << new_ary
+          nil
+        end
+
+      failed ? 1 : 0
     end
 
     STATEMENT_TIMEOUT = ::FFI::Function.new(:int, [:pointer]) do |ctx|
       ctx = unwrap(ctx)
       current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      if ctx.instance_variable_get(:@stmt_deadline).nil?
-        ctx.instance_variable_set(:@stmt_deadline, current_time + ctx.instance_variable_get(:@stmt_timeout).to_i / 1000.0)
+      if ctx.stmt_deadline.nil?
+        ctx.stmt_deadline = current_time + ctx.stmt_timeout.to_i / 1000.0
         0
-      elsif current_time >= ctx.instance_variable_get(:@stmt_deadline)
+      elsif current_time >= ctx.stmt_deadline
         1
       else
         0
@@ -65,16 +87,27 @@ module SQLite3
     end
 
     BUSY_HANDLER = ::FFI::Function.new(:int, [:pointer, :int]) do |ctx, count|
-      handler = unwrap(ctx).instance_variable_get(:@busy_handler)
-      result = handler.(count)
-      result == false ? 0 : 1
+      result, failed =
+        protect_callback do
+          handler = unwrap(ctx).busy_handler
+          handler.(count)
+        end
+
+      if failed || result == false
+        0
+      else
+        1
+      end
     end
 
     FUNC = ::FFI::Function.new(:void, [:pointer, :int, :pointer]) do |ctx, argc, argv|
-      callable = unwrap(CApi.sqlite3_user_data(ctx))
-      params = argv.read_array_of_pointer(argc).map { |v| FFI.sqlite3val2rb(v) }
-      result = callable.(*params)
-      FFI.set_sqlite3_func_result(ctx, result)
+      protect_callback do
+        callable = unwrap(CApi.sqlite3_user_data(ctx))
+        params = argv.read_array_of_pointer(argc).map { |v| FFI.sqlite3val2rb(v) }
+        result = callable.(*params)
+        FFI.set_sqlite3_func_result(ctx, result)
+        nil
+      end
     end
   end
 end

data/lib/sqlite3/ffi/statement.rb

@@ -1,17 +1,25 @@
 module SQLite3
   class Statement
     def prepare(db, sql)
-      sql = FFI.string_value(sql)
+      @db_ctx = db.instance_variable_get(:@ctx)
+      @db_ctx.stmt_deadline = nil
 
-      @db = db # so can check if discarded
-      @db.instance_variable_set(:@stmt_deadline, nil)
-      db = db.instance_variable_get(:@db)
+      sql_cstr = FFI.string_value(sql)
+      sql_len = FFI.rstring_lenint(sql)
+
+      db = @db_ctx.db
       stmt = ::FFI::MemoryPointer.new(:pointer)
       tail = ::FFI::MemoryPointer.new(:pointer)
-      status = FFI::CApi.sqlite3_prepare_v2(db, sql, sql.bytesize, stmt, tail)
-      FFI.check_prepare(db, status, sql)
-
+      frame = FFI::CallbackFrame.new
+      FFI.push_callback_frame(frame)
+      status = FFI::CApi.sqlite3_prepare_v2(db, sql_cstr, sql_len, stmt, tail)
+      # sqlite3_finalize is no-op on NULL pointer
       @stmt = ::FFI::AutoPointer.new(stmt.read_pointer, FFI::CApi.method(:sqlite3_finalize))
+      if (callback_state = FFI.pop_callback_frame(frame))
+        raise callback_state
+      end
+
+      FFI.check_prepare(db, status, sql)
 
       tail.read_pointer.read_string.force_encoding(Encoding::UTF_8)
     end
@@ -36,14 +44,19 @@ module SQLite3
       stmt = @stmt
 
       if FFI::CApi.sqlite3_stmt_busy(stmt) == 0
-        @db.instance_variable_set(:@stmt_deadline, nil)
+        @db_ctx.stmt_deadline = nil
       end
 
+      frame = FFI::CallbackFrame.new
+      FFI.push_callback_frame(frame)
       value = FFI::CApi.sqlite3_step(stmt)
-      if FFI.rb_errinfo
-        exception = FFI.rb_errinfo
-        FFI.rb_errinfo = nil
-        raise exception
+      if (callback_state = FFI.pop_callback_frame(frame))
+        raise callback_state
+      end
+
+      if value == FFI::CApi::SQLITE_DONE
+        @done = true
+        return nil
       end
 
       length = FFI::CApi.sqlite3_column_count(stmt)
@@ -75,9 +88,6 @@ module SQLite3
           end
           list << val
         end
-      when FFI::CApi::SQLITE_DONE
-        @done = true
-        return nil
       else
         FFI::CApi.sqlite3_reset(stmt)
         @done = false
@@ -108,14 +118,14 @@ module SQLite3
       case value
       when String
         if value.is_a?(Blob) || value.encoding == Encoding::BINARY
-          status = FFI::CApi.sqlite3_bind_blob(@stmt, index, value, value.bytesize, FFI::CApi::SQLITE_TRANSIENT)
+          status = FFI::CApi.sqlite3_bind_blob(@stmt, index, value, FFI.rstring_lenint(value), FFI::CApi::SQLITE_TRANSIENT)
         elsif value.encoding == Encoding::UTF_16LE || value.encoding == Encoding::UTF_16BE
-          status = FFI::CApi.sqlite3_bind_text16(@stmt, index, value, value.bytesize, FFI::CApi::SQLITE_TRANSIENT)
+          status = FFI::CApi.sqlite3_bind_text16(@stmt, index, value, FFI.rstring_lenint(value), FFI::CApi::SQLITE_TRANSIENT)
         else
           if value.encoding != Encoding::UTF_8 && value.encoding != Encoding::US_ASCII
             value = value.encode(Encoding::UTF_8)
           end
-          status = FFI::CApi.sqlite3_bind_text(@stmt, index, +value, value.bytesize, FFI::CApi::SQLITE_TRANSIENT)
+          status = FFI::CApi.sqlite3_bind_text(@stmt, index, +value, FFI.rstring_lenint(value), FFI::CApi::SQLITE_TRANSIENT)
         end
       when Float
         status = FFI::CApi.sqlite3_bind_double(@stmt, index, value)
@@ -268,7 +278,7 @@ module SQLite3
     end
 
     def require_live_db
-      if @db.instance_variable_get(:@discarded)
+      if @db_ctx.discarded
         raise SQLite3::Exception, "cannot use a statement associated with a discarded database"
       end
     end

data/lib/sqlite3/ffi/utils.rb

@@ -1,5 +1,21 @@
 module SQLite3
   module FFI
+    Context =
+      Struct.new(
+        :db,
+        :busy_handler,
+        :functions,
+        :collations,
+        :aggregators,
+        :trace_handler,
+        :authorizer,
+        :stmt_timeout,
+        :stmt_deadline,
+        :owner,
+        :readonly,
+        :discarded
+      )
+
     def self.sqlite3val2rb(val)
       case CApi.sqlite3_value_type(val)
       when CApi::SQLITE_INTEGER
@@ -29,9 +45,9 @@ module SQLite3
         CApi.sqlite3_result_double(ctx, result)
       when String
         if result.is_a?(Blob) || result.encoding == Encoding::BINARY
-          CApi.sqlite3_result_blob(ctx, result, result.bytesize, CApi::SQLITE_TRANSIENT)
+          CApi.sqlite3_result_blob(ctx, result, rstring_lenint(result), CApi::SQLITE_TRANSIENT)
         else
-          CApi.sqlite3_result_text(ctx, result, result.bytesize, CApi::SQLITE_TRANSIENT)
+          CApi.sqlite3_result_text(ctx, result, rstring_lenint(result), CApi::SQLITE_TRANSIENT)
         end
       else
         raise RuntimeError, "can't return #{result.class.name}"
@@ -70,14 +86,14 @@ module SQLite3
       obj
     end
 
-    RB_ERRINFO = :sqlite3_ffi_rb_errinfo
-
-    def self.rb_errinfo
-      Thread.current[RB_ERRINFO]
-    end
+    INT_MAX = 2**31 - 1
 
-    def self.rb_errinfo=(e)
-      Thread.current[RB_ERRINFO] = e
+    def self.rstring_lenint(obj)
+      n = obj.bytesize
+      if n > INT_MAX
+        raise RangeError, "integer %p too big to convert to int" % [n]
+      end
+      n
     end
 
     OBJECT_REGISTRY = ObjectSpace::WeakMap.new

data/lib/sqlite3/ffi/version.rb

@@ -1,5 +1,5 @@
 module SQLite3
   module FFI
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/sqlite3/resultset.rb

@@ -16,8 +16,12 @@ module SQLite3
       @stmt = stmt
     end
 
-    # Reset the cursor, so that a result set which has reached end-of-file
-    # can be rewound and reiterated.
+    # Resets the cursor to the first row, so that you can iterate over the
+    # result set again after it reaches the end.
+    #
+    # This method binds each argument to the statement with
+    # Statement#bind_params. The values that you bound before stay bound
+    # unless you bind new values to the same parameters.
     def reset(*bind_params)
       @stmt.reset!
       @stmt.bind_params(*bind_params)

data/lib/sqlite3/statement.rb

@@ -65,6 +65,10 @@ module SQLite3
     #   stmt = db.prepare( "select * from table where a=? and b=?" )
     #   stmt.bind_params( 15, "hello" )
     #
+    # The values that this method binds stay bound when you execute or reset
+    # the statement. To change a value, bind a new value to the same
+    # parameter. To clear all values, call #clear_bindings!.
+    #
     # See also #execute, #bind_param, Statement#bind_param, and
     # Statement#bind_params.
     def bind_params(*bind_vars)
@@ -83,7 +87,17 @@ module SQLite3
     # statement's virtual machine. If a block was given, the new ResultSet will
     # be yielded to it; otherwise, the ResultSet will be returned.
     #
-    # Any parameters will be bound to the statement using #bind_params.
+    # This method binds each argument to the statement with #bind_params. The
+    # values stay bound after this method returns. If a later call to #execute
+    # does not give a value for a parameter, the statement uses the value from
+    # the earlier call. To set all parameters to NULL before you execute the
+    # statement again, call #clear_bindings!:
+    #
+    #   stmt = db.prepare( "select :a, :b" )
+    #   stmt.execute( a: 1, b: 2 ).to_a  # => [[1, 2]]
+    #   stmt.execute( a: 3 ).to_a        # => [[3, 2]]
+    #   stmt.clear_bindings!
+    #   stmt.execute( a: 3 ).to_a        # => [[3, nil]]
     #
     # Example:
     #
@@ -92,7 +106,7 @@ module SQLite3
     #     ...
     #   end
     #
-    # See also #bind_params, #execute!.
+    # See also #bind_params, #execute!, #clear_bindings!.
     def execute(*bind_vars)
       reset! if active? || done?
 
@@ -109,7 +123,9 @@ module SQLite3
     # rows returned by executing the statement. Otherwise, each row will be
     # yielded to the block.
     #
-    # Any parameters will be bound to the statement using #bind_params.
+    # This method binds each argument to the statement with #bind_params. The
+    # values stay bound after this method returns. For more information, see
+    # #execute.
     #
     # Example:
     #

data/lib/sqlite3/version.rb

@@ -1,4 +1,4 @@
 module SQLite3
   # (String) the version of the sqlite3 gem, e.g. "2.1.1"
-  VERSION = "2.10.0"
+  VERSION = "2.10.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3-ffi
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Jamis Buck