sqlite3-ffi 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0099c7235d3e7b13c26861041a474d279952101488139c9b11c40053658bb095'
-  data.tar.gz: e809f4772c73162b7417c79ae56674606c689e2a1fddb3181ac637d958066f04
+  metadata.gz: 402ba8b0d0f49fd0f6229dba55575c8c5c22e460a2c2883095782f7f0f370ae6
+  data.tar.gz: 22c9aad92904a410a4a697aa8dddcb84519e4669cb8976c57ba6d1f2c04c37d4
 SHA512:
-  metadata.gz: 916507cb952494f227d6182cf92d9e910cf3534f01995706efff64523eb86750fe7601238b9e4d6c32813cff3a097a073b541bad0632dc74f87e2b35e589ccca
-  data.tar.gz: 78586b3eb030fdcb58e4afbcace803efcf78c3e02d3939d73524186148f55cc6b7699c5f15b42df774f6007681ac22bbf82a434887874b1092b3a72ec66efadf
+  metadata.gz: 9ef8d936ee00247132f2d0c632491bffc4802915b539267ffc8131c13dfcee6cb85eb568d68d439894eed3a511813cb9e7f19baf82cbeff9fd7d896bdc4b8845
+  data.tar.gz: 0a454150d3d90edbf20cd59f3eb69c75d0825bb406efb290aded8b4376e32ea14e45e6317252134c691fddbb1e065a00f9ae8981d852861131ad1a4c80e0bf16

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.2.0 (2026-10-13)
+
+- Synced with sqlite3-ruby 2.10.0
+- Dropped support for Ruby < 3.2
+
+## 0.1.8 (2026-08-11)
+
+- Synced with sqlite3-ruby 2.9.6
+
 ## 0.1.7 (2026-06-07)
 
 - Synced with sqlite3-ruby 2.9.5

data/lib/sqlite3/database.rb

@@ -171,8 +171,6 @@ module SQLite3
         end
       end
 
-      @tracefunc = nil
-      @authorizer = nil
       @progress_handler = nil
       @collations = {}
       @functions = []
@@ -458,9 +456,7 @@ module SQLite3
     #
     # See also #create_aggregate_handler for a more object-oriented approach to
     # aggregate functions.
-    def create_aggregate(name, arity, step = nil, finalize = nil,
-      text_rep = Constants::TextRep::ANY, &block)
-
+    def create_aggregate(name, arity, step = nil, finalize = nil, text_rep = Constants::TextRep::ANY, &block)
       proxy = Class.new do
         def self.step(&block)
           define_method(:step_with_ctx, &block)

data/lib/sqlite3/ffi/c_api.rb

@@ -90,6 +90,9 @@ module SQLite3
       SQLITE_DBCONFIG_ENABLE_COMMENTS       = 1022
       SQLITE_DBCONFIG_MAX                   = 1022
 
+      SQLITE_DESERIALIZE_FREEONCLOSE = 1
+      SQLITE_DESERIALIZE_RESIZEABLE  = 2
+
       SQLITE_OPEN_READONLY       = 0x00000001
       SQLITE_OPEN_READWRITE      = 0x00000002
       SQLITE_OPEN_CREATE         = 0x00000004
@@ -145,7 +148,7 @@ module SQLite3
       attach_function :sqlite3_bind_parameter_count, [:pointer], :int
       attach_function :sqlite3_bind_parameter_index, [:pointer, :string], :int
       attach_function :sqlite3_bind_parameter_name, [:pointer, :int], :string
-      attach_function :sqlite3_bind_text, [:pointer, :int, :string, :int, :pointer], :int
+      attach_function :sqlite3_bind_text, [:pointer, :int, :pointer, :int, :pointer], :int
       attach_function :sqlite3_bind_text16, [:pointer, :int, :pointer, :int, :pointer], :int
       attach_function :sqlite3_busy_handler, [:pointer, :pointer, :pointer], :int
       attach_function :sqlite3_busy_timeout, [:pointer, :int], :int
@@ -182,8 +185,10 @@ module SQLite3
       attach_function :sqlite3_last_insert_rowid, [:pointer], :int64
       attach_function :sqlite3_libversion, [], :string
       attach_function :sqlite3_libversion_number, [], :int
+      attach_function :sqlite3_malloc64, [:int64], :pointer
+      attach_function :sqlite3_mprintf, [:string, :varargs], :pointer
       attach_function :sqlite3_open16, [:pointer, :pointer], :int
-      attach_function :sqlite3_open_v2, [:string, :pointer, :int, :pointer], :int
+      attach_function :sqlite3_open_v2, [:string, :pointer, :int, :string], :int
       attach_function :sqlite3_prepare_v2, [:pointer, :string, :int, :pointer, :pointer], :int
       attach_function :sqlite3_progress_handler, [:pointer, :int, :pointer, :pointer], :void
       attach_function :sqlite3_reset, [:pointer], :int
@@ -196,6 +201,7 @@ module SQLite3
       attach_function :sqlite3_sql, [:pointer], :string
       attach_function :sqlite3_status64, [:int, :pointer, :pointer, :int], :int
       attach_function :sqlite3_step, [:pointer], :int
+      attach_function :sqlite3_stmt_busy, [:pointer], :int
       attach_function :sqlite3_stmt_status, [:pointer, :int, :int], :int
       attach_function :sqlite3_threadsafe, [], :int
       attach_function :sqlite3_total_changes, [:pointer], :int
@@ -215,6 +221,13 @@ module SQLite3
         false
       end
 
+      HAVE_SQLITE3_DESERIALIZE = begin
+        attach_function :sqlite3_deserialize, [:pointer, :string, :pointer, :int64, :int64, :uint], :int
+        true
+      rescue ::FFI::NotFoundError
+        false
+      end
+
       HAVE_SQLITE3_ENABLE_LOAD_EXTENSION = begin
         attach_function :sqlite3_enable_load_extension, [:pointer, :int], :int
         true
@@ -228,6 +241,13 @@ module SQLite3
       rescue ::FFI::NotFoundError
         false
       end
+
+      HAVE_SQLITE3_SERIALIZE = begin
+        attach_function :sqlite3_serialize, [:pointer, :string, :pointer, :uint], :pointer
+        true
+      rescue ::FFI::NotFoundError
+        false
+      end
     end
   end
 end

data/lib/sqlite3/ffi/database.rb

@@ -144,6 +144,8 @@ module SQLite3
     def exec_batch(sql, results_as_hash)
       require_open_db
 
+      @stmt_deadline = nil
+
       callback_ary = []
       err_msg = ::FFI::MemoryPointer.new(:pointer)
       callback = results_as_hash == true ? FFI::HASH_CALLBACK : FFI::REGULAR_CALLBACK
@@ -159,6 +161,52 @@ module SQLite3
       fname.null? ? nil : fname.read_string.force_encoding(Encoding::UTF_8)
     end
 
+    if FFI::CApi::HAVE_SQLITE3_SERIALIZE
+      def serialize(db_name = nil)
+        require_open_db
+
+        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)
+        size = size.read_int64
+
+        if data.null? && size < 0
+          raise SQLite3::Exception, "unable to serialize database \"%s\"" % [z_schema || "main"]
+        end
+        if data.null? && size > 0
+          raise NoMemoryError, "failed to allocate %d bytes for serialization" % [size]
+        end
+
+        result = data.read_bytes(size)
+        FFI::CApi.sqlite3_free(data)
+        result
+      end
+    end
+
+    if FFI::CApi::HAVE_SQLITE3_DESERIALIZE && FFI::CApi.sqlite3_libversion_number >= 3054000
+      def deserialize(data, db_name = nil)
+        require_open_db
+
+        data = FFI.string_value(data)
+        z_schema = db_name.nil? ? nil : FFI.string_value_cstr(db_name)
+        sz_db = data.bytesize
+
+        sz_buf = sz_db + 20
+        p_data = FFI::CApi.sqlite3_malloc64(sz_buf)
+        if p_data.null?
+          raise NoMemoryError, "failed to allocate %d bytes for deserialization" % [sz_buf]
+        end
+        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)
+
+        FFI.check(@db, status)
+        self
+      end
+    end
+
     private
 
     def require_open_db
@@ -167,6 +215,12 @@ module SQLite3
       end
     end
 
+    def require_closed_db
+      if !@db.nil?
+        raise SQLite3::Exception, "cannot open a database that is already open"
+      end
+    end
+
     def discard_db
       sfile = ::FFI::MemoryPointer.new(:pointer)
 
@@ -209,13 +263,28 @@ module SQLite3
     end
 
     def utf16_string_value_ptr(str)
-      str + "\x00\x00".encode(Encoding::UTF_16LE)
+      str = FFI.string_value(str)
+
+      utf16str = str.dup
+      if utf16str.encoding != Encoding::UTF_16LE && utf16str.encoding != Encoding::UTF_16BE
+        utf16str.force_encoding(Encoding::UTF_16LE)
+      end
+      codepoints = utf16str.codepoints
+      if codepoints.include?(0)
+        raise ArgumentError, "string contains null char"
+      end
+
+      str = str.dup
+      str << 0
+      str << 0
+      str
     end
 
     def open_v2(file, flags, zvfs)
+      require_closed_db
       @owner = Process.pid
       db = ::FFI::MemoryPointer.new(:pointer)
-      status = FFI::CApi.sqlite3_open_v2(FFI.string_value(file), db, flags, zvfs)
+      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)
@@ -250,11 +319,20 @@ module SQLite3
     end
 
     def open16(file)
+      require_closed_db
       @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))
-      FFI.check(@db, status)
+      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::MemoryPointer.new(:pointer).write_pointer(msg)
+        msg = FFI::CApi.sqlite3_errmsg(@db)
+        @db.free
+        @db = nil
+        FFI.check_msg(@db, status, msg)
+      end
       status
     end
 

data/lib/sqlite3/ffi/exception.rb

@@ -87,9 +87,9 @@ module SQLite3
       klass = status2klass(status)
       return if klass.nil?
 
-      exception = klass.new(msg.read_pointer.read_string)
+      exception = klass.new(msg.is_a?(String) ? msg : msg.read_pointer.read_string)
       exception.instance_variable_set(:@code, status)
-      CApi.sqlite3_free(msg.read_pointer)
+      CApi.sqlite3_free(msg.read_pointer) unless msg.is_a?(String)
 
       raise exception
     end

data/lib/sqlite3/ffi/functions.rb

@@ -55,7 +55,7 @@ module SQLite3
       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_set(:@stmt_deadline, current_time + ctx.instance_variable_get(:@stmt_timeout).to_i / 1000.0)
         0
       elsif current_time >= ctx.instance_variable_get(:@stmt_deadline)
         1

data/lib/sqlite3/ffi/sqlite3.rb

@@ -37,7 +37,7 @@ module SQLite3
   end
 
   def self.libversion
-    FFI::CApi.sqlite3_libversion
+    FFI::CApi.sqlite3_libversion_number
   end
 
   def self.status(parameter, reset_flag = false)

data/lib/sqlite3/ffi/statement.rb

@@ -4,6 +4,7 @@ module SQLite3
       sql = FFI.string_value(sql)
 
       @db = db # so can check if discarded
+      @db.instance_variable_set(:@stmt_deadline, nil)
       db = db.instance_variable_get(:@db)
       stmt = ::FFI::MemoryPointer.new(:pointer)
       tail = ::FFI::MemoryPointer.new(:pointer)
@@ -11,7 +12,6 @@ module SQLite3
       FFI.check_prepare(db, status, sql)
 
       @stmt = ::FFI::AutoPointer.new(stmt.read_pointer, FFI::CApi.method(:sqlite3_finalize))
-      @db.instance_variable_set(:@stmt_deadline, nil)
 
       tail.read_pointer.read_string.force_encoding(Encoding::UTF_8)
     end
@@ -35,6 +35,10 @@ module SQLite3
 
       stmt = @stmt
 
+      if FFI::CApi.sqlite3_stmt_busy(stmt) == 0
+        @db.instance_variable_set(:@stmt_deadline, nil)
+      end
+
       value = FFI::CApi.sqlite3_step(stmt)
       if FFI.rb_errinfo
         exception = FFI.rb_errinfo
@@ -111,7 +115,7 @@ module SQLite3
           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, value.bytesize, FFI::CApi::SQLITE_TRANSIENT)
         end
       when Float
         status = FFI::CApi.sqlite3_bind_double(@stmt, index, value)
@@ -168,7 +172,16 @@ module SQLite3
       require_live_db
       require_open_stmt
 
-      FFI::CApi.sqlite3_column_decltype(@stmt, index)
+      name = FFI::CApi.sqlite3_column_decltype(@stmt, index)
+      name ? name.force_encoding(Encoding::UTF_8) : nil
+    end
+
+    def column_decltype_downcased(index)
+      require_live_db
+      require_open_stmt
+
+      name = FFI::CApi.sqlite3_column_decltype(@stmt, index)
+      name ? FFI.interned_downcased_utf8_cstr(name) : nil
     end
 
     def bind_parameter_count

data/lib/sqlite3/ffi/utils.rb

@@ -39,7 +39,11 @@ module SQLite3
     end
 
     def self.interned_utf8_cstr(str)
-      -str
+      -str.force_encoding(Encoding::UTF_8)
+    end
+
+    def self.interned_downcased_utf8_cstr(str)
+      -str.force_encoding(Encoding::UTF_8).downcase(:ascii)
     end
 
     def self.string_value(obj)
@@ -58,6 +62,14 @@ module SQLite3
       obj.to_str
     end
 
+    def self.string_value_cstr(obj)
+      obj = string_value(obj)
+      if obj.include?("\x00")
+        raise ArgumentError, "string contains null byte"
+      end
+      obj
+    end
+
     RB_ERRINFO = :sqlite3_ffi_rb_errinfo
 
     def self.rb_errinfo

data/lib/sqlite3/ffi/version.rb

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

data/lib/sqlite3/resultset.rb

@@ -43,20 +43,26 @@ module SQLite3
       @stmt.step
     end
 
-    # Required by the Enumerable mixin. Provides an internal iterator over the
-    # rows of the result set.
+    # With a block given, iterates over the rows of the result set, passing each
+    # to the block. Returns self.
+    # With no block given, returns a new Enumerator.
     def each
+      return enum_for(__method__) unless block_given?
       while (node = self.next)
         yield node
       end
+      self
     end
 
-    # Provides an internal iterator over the rows of the result set where
-    # each row is yielded as a hash.
+    # With a block given, iterates over the rows of the result set, passing each
+    # to the block as a hash. Returns self.
+    # With no block given, returns a new Enumerator.
     def each_hash
+      return enum_for(__method__) unless block_given?
       while (node = next_hash)
         yield node
       end
+      self
     end
 
     # Closes the statement that spawned this result set.

data/lib/sqlite3/statement.rb

@@ -42,6 +42,24 @@ module SQLite3
     # See Database#execute for a description of the valid placeholder
     # syntaxes.
     #
+    # Type mapping from Ruby to SQLite3:
+    # - +nil+                            → NULL
+    # - Integer                          → INTEGER (or REAL when outside the signed int64 range)
+    # - Float                            → REAL
+    # - SQLite3::Blob                    → BLOB
+    # - String with Encoding::ASCII_8BIT
+    #   (a.k.a. BINARY)                  → BLOB
+    # - String with Encoding::UTF_16LE
+    #   or Encoding::UTF_16BE            → TEXT (bound as UTF-16)
+    # - String (all other encodings)     → TEXT (re-encoded to UTF-8 if needed)
+    # - Any other type                   → raises RuntimeError
+    #
+    # Note: a String with Encoding::ASCII_8BIT (BINARY) is always bound as a
+    # BLOB, even when its bytes are all valid ASCII. If you want such a string
+    # compared or stored as TEXT, re-encode it before binding:
+    #
+    #   stmt.bind_params(my_binary_str.encode(Encoding::UTF_8))
+    #
     # Example:
     #
     #   stmt = db.prepare( "select * from table where a=? and b=?" )
@@ -112,9 +130,9 @@ module SQLite3
       !done?
     end
 
-    # Return an array of the column names for this statement. Note that this
-    # may execute the statement in order to obtain the metadata; this makes it
-    # a (potentially) expensive operation.
+    # Return a frozen array of the column names for this statement, as frozen
+    # UTF-8 strings. Note that this may execute the statement in order to
+    # obtain the metadata; this makes it a (potentially) expensive operation.
     def columns
       get_metadata unless @columns
       @columns
@@ -128,9 +146,11 @@ module SQLite3
       end
     end
 
-    # Return an array of the data types for each column in this statement. Note
-    # that this may execute the statement in order to obtain the metadata; this
-    # makes it a (potentially) expensive operation.
+    # Return a frozen array of the declared types of the columns in this
+    # statement, as frozen UTF-8 strings with ASCII letters downcased. A column
+    # with no declared type, such as an expression, has a +nil+ type. Note that
+    # this may execute the statement in order to obtain the metadata; this makes
+    # it a (potentially) expensive operation.
     def types
       must_be_open!
       get_metadata unless @types
@@ -180,11 +200,10 @@ module SQLite3
     def get_metadata
       @columns = Array.new(column_count) do |column|
         column_name column
-      end
+      end.freeze
       @types = Array.new(column_count) do |column|
-        val = column_decltype(column)
-        val&.downcase
-      end
+        column_decltype_downcased(column)
+      end.freeze
     end
   end
 end

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.9.5"
+  VERSION = "2.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite3-ffi
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Jamis Buck
@@ -70,14 +70,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A drop-in replacement for the sqlite3 gem for JRuby
 test_files: []