sqlite3-ffi 0.1.0

data/lib/sqlite3/ffi/database.rb

@@ -0,0 +1,261 @@
+module SQLite3
+  class Database
+    def close
+      close_or_discard_db
+      @aggregators = nil
+      self
+    end
+
+    def closed?
+      @db.nil?
+    end
+
+    def total_changes
+      require_open_db
+
+      FFI::CApi.sqlite3_total_changes(@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))
+      self
+    end
+
+    def busy_handler(blk = nil, &block)
+      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)
+      self
+    end
+
+    def statement_timeout=(milliseconds)
+      @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))
+      self
+    end
+
+    def last_insert_row_id
+      require_open_db
+
+      FFI::CApi.sqlite3_last_insert_rowid(@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)
+      @functions[name] = block
+      self
+    end
+
+    def define_function(name, &block)
+      define_function_with_flags(name, FFI::CApi::SQLITE_UTF8, &block)
+    end
+
+    def interrupt
+      require_open_db
+
+      FFI::CApi.sqlite3_interrupt(@db)
+      self
+    end
+
+    def errmsg
+      require_open_db
+
+      FFI::CApi.sqlite3_errmsg(@db)
+    end
+
+    def errcode
+      require_open_db
+
+      FFI::CApi.sqlite3_errcode(@db)
+    end
+
+    def complete?(sql)
+      FFI::CApi.sqlite3_complete(FFI.string_value(sql)) != 0
+    end
+
+    def changes
+      require_open_db
+
+      FFI::CApi.sqlite3_changes(@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
+    end
+
+    def busy_timeout=(timeout)
+      require_open_db
+
+      FFI.check(@db, FFI::CApi.sqlite3_busy_timeout(@db, timeout))
+    end
+
+    def extended_result_codes=(enable)
+      require_open_db
+
+      FFI::CApi.sqlite3_extended_result_codes(@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)
+      @collations[name] = comparator
+      self
+    end
+
+    if FFI::CApi::HAVE_SQLITE3_ENABLE_LOAD_EXTENSION && FFI::CApi::HAVE_SQLITE3_LOAD_EXTENSION
+      def enable_load_extension(onoff)
+        require_open_db
+
+        if onoff == true
+          onoffparam = 1
+        elsif onoff == false
+          onoffparam = 0
+        else
+          onoffparam = onoff.to_i
+        end
+        FFI.check(@db, FFI::CApi.sqlite3_enable_load_extension(@db, onoffparam))
+        self
+      end
+    end
+
+    def transaction_active?
+      require_open_db
+
+      FFI::CApi.sqlite3_get_autocommit(@db).zero?
+    end
+
+    def exec_batch(sql, results_as_hash)
+      require_open_db
+
+      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)
+      callback_ary
+    end
+
+    def db_filename(db_name)
+      require_open_db
+
+      fname = FFI::CApi.sqlite3_db_filename(@db, db_name)
+      fname.null? ? nil : fname.read_string.force_encoding(Encoding::UTF_8)
+    end
+
+    private
+
+    def require_open_db
+      if @db.nil?
+        raise SQLite3::Exception, "cannot use a closed database"
+      end
+    end
+
+    def discard_db(db)
+      FFI::CApi.sqlite3_db_release_memory(db)
+      # TODO sqlite3_file_control
+      @db = nil
+      @discarded = true
+    end
+
+    def close_or_discard_db
+      unless @db.nil?
+        if @readonly || @owner == Process.pid
+          FFI::CApi.sqlite3_close_v2(@db)
+          @db = nil
+        else
+          discard_db(@db)
+        end
+      end
+    end
+
+    def utf16_string_value_ptr(str)
+      str + "\x00\x00".encode(Encoding::UTF_16LE)
+    end
+
+    def open_v2(file, flags, zvfs)
+      db = ::FFI::MemoryPointer.new(:pointer)
+      status = FFI::CApi.sqlite3_open_v2(FFI.string_value(file), db, flags, zvfs)
+      @db = db.read_pointer
+      FFI.check(@db, status)
+      if (flags & FFI::CApi::SQLITE_OPEN_READONLY) != 0
+        @readonly = true
+      end
+      @owner = Process.pid
+      self
+    end
+
+    def disable_quirk_mode
+      return false if @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)
+      true
+    end
+
+    def discard
+      discard_db(@db)
+      @aggregators = nil
+      self
+    end
+
+    if FFI::CApi::HAVE_SQLITE3_LOAD_EXTENSION
+      def load_extension_internal(file)
+        require_open_db
+
+        err_msg = FFI::MemoryPointer.new(:pointer)
+        status = FFI::CApi.sqlite3_load_extension(@db, FFI.string_value(file), 0, err_msg)
+        FFI.check_msg(@db, status, err_msg)
+        self
+      end
+    end
+
+    def open16(file)
+      db = ::FFI::MemoryPointer.new(:pointer)
+      status = FFI::CApi.sqlite3_open16(utf16_string_value_ptr(file), db)
+      @db = db.read_pointer
+      FFI.check(@db, status)
+      status
+    end
+
+    def define_aggregator2(aggregator, ruby_name)
+      require_open_db
+
+      if aggregator.respond_to?(:arity)
+        arity = aggregator.arity
+      else
+        arity = -1
+      end
+
+      if arity < -1 || arity > 127
+        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 << aw
+
+      self
+    end
+  end
+end

data/lib/sqlite3/ffi/exception.rb

@@ -0,0 +1,111 @@
+module SQLite3
+  module FFI
+    def self.check(db, status)
+      raise_(db, status)
+    end
+
+    def self.check_msg(db, status, msg)
+      raise_msg(db, status, msg)
+    end
+
+    def self.check_prepare(db, status, sql)
+      raise_with_sql(db, status, sql)
+    end
+
+    def self.status2klass(status)
+      case status & 0xff
+      when 0
+        nil
+      when CApi::SQLITE_ERROR
+        SQLite3::SQLException
+      when CApi::SQLITE_INTERNAL
+        SQLite3::InternalException
+      when CApi::SQLITE_PERM
+        SQLite3::PermissionException
+      when CApi::SQLITE_ABORT
+        SQLite3::AbortException
+      when CApi::SQLITE_BUSY
+        SQLite3::BusyException
+      when CApi::SQLITE_LOCKED
+        SQLite3::LockedException
+      when CApi::SQLITE_NOMEM
+        SQLite3::MemoryException
+      when CApi::SQLITE_READONLY
+        SQLite3::ReadOnlyException
+      when CApi::SQLITE_INTERRUPT
+        SQLite3::InterruptException
+      when CApi::SQLITE_IOERR
+        SQLite3::IOException
+      when CApi::SQLITE_CORRUPT
+        SQLite3::CorruptException
+      when CApi::SQLITE_NOTFOUND
+        SQLite3::NotFoundException
+      when CApi::SQLITE_FULL
+        SQLite3::FullException
+      when CApi::SQLITE_CANTOPEN
+        SQLite3::CantOpenException
+      when CApi::SQLITE_PROTOCOL
+        SQLite3::ProtocolException
+      when CApi::SQLITE_EMPTY
+        SQLite3::EmptyException
+      when CApi::SQLITE_SCHEMA
+        SQLite3::SchemaChangedException
+      when CApi::SQLITE_TOOBIG
+        SQLite3::TooBigException
+      when CApi::SQLITE_CONSTRAINT
+        SQLite3::ConstraintException
+      when CApi::SQLITE_MISMATCH
+        SQLite3::MismatchException
+      when CApi::SQLITE_MISUSE
+        SQLite3::MisuseException
+      when CApi::SQLITE_NOLFS
+        SQLite3::UnsupportedException
+      when CApi::SQLITE_AUTH
+        SQLite3::AuthorizationException
+      when CApi::SQLITE_FORMAT
+        SQLite3::FormatException
+      when CApi::SQLITE_RANGE
+        SQLite3::RangeException
+      when CApi::SQLITE_NOTADB
+        SQLite3::NotADatabaseException
+      else
+        SQLite3::Exception
+      end
+    end
+
+    def self.raise_(db, status)
+      klass = status2klass(status)
+      return if klass.nil?
+
+      exception = klass.new(CApi.sqlite3_errmsg(db))
+      exception.instance_variable_set(:@code, status)
+
+      raise exception
+    end
+
+    def self.raise_msg(db, status, msg)
+      klass = status2klass(status)
+      return if klass.nil?
+
+      exception = klass.new(msg.read_pointer.read_string)
+      exception.instance_variable_set(:@code, status)
+      CApi.sqlite3_free(msg.read_pointer)
+
+      raise exception
+    end
+
+    def self.raise_with_sql(db, status, sql)
+      klass = status2klass(status)
+      return if klass.nil?
+
+      exception = klass.new(CApi.sqlite3_errmsg(db))
+      exception.instance_variable_set(:@code, status)
+      if sql
+        exception.instance_variable_set(:@sql, sql)
+        exception.instance_variable_set(:@sql_offset, CApi.sqlite3_error_offset(db))
+      end
+
+      raise exception
+    end
+  end
+end

data/lib/sqlite3/ffi/functions.rb

@@ -0,0 +1,79 @@
+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)
+
+      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
+
+    TRACE = ::FFI::Function.new(:int, [:uint, :pointer, :pointer, :pointer]) do |_, ctx, _, x|
+      unwrap(ctx).call(x.read_string)
+      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
+    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
+    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
+    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)
+      elsif current_time >= ctx.instance_variable_get(:@stmt_deadline)
+        1
+      else
+        0
+      end
+    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
+    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)
+    end
+  end
+end

data/lib/sqlite3/ffi/sqlite3.rb

@@ -0,0 +1,62 @@
+module SQLite3
+  class Blob < String
+  end
+
+  module Constants
+    module Open
+      READONLY       = FFI::CApi::SQLITE_OPEN_READONLY
+      READWRITE      = FFI::CApi::SQLITE_OPEN_READWRITE
+      CREATE         = FFI::CApi::SQLITE_OPEN_CREATE
+      DELETEONCLOSE  = FFI::CApi::SQLITE_OPEN_DELETEONCLOSE
+      EXCLUSIVE      = FFI::CApi::SQLITE_OPEN_EXCLUSIVE
+      MAIN_DB        = FFI::CApi::SQLITE_OPEN_MAIN_DB
+      TEMP_DB        = FFI::CApi::SQLITE_OPEN_TEMP_DB
+      TRANSIENT_DB   = FFI::CApi::SQLITE_OPEN_TRANSIENT_DB
+      MAIN_JOURNAL   = FFI::CApi::SQLITE_OPEN_MAIN_JOURNAL
+      TEMP_JOURNAL   = FFI::CApi::SQLITE_OPEN_TEMP_JOURNAL
+      SUBJOURNAL     = FFI::CApi::SQLITE_OPEN_SUBJOURNAL
+      MASTER_JOURNAL = FFI::CApi::SQLITE_OPEN_SUPER_JOURNAL
+      SUPER_JOURNAL  = FFI::CApi::SQLITE_OPEN_SUPER_JOURNAL
+      NOMUTEX        = FFI::CApi::SQLITE_OPEN_NOMUTEX
+      FULLMUTEX      = FFI::CApi::SQLITE_OPEN_FULLMUTEX
+      AUTOPROXY      = FFI::CApi::SQLITE_OPEN_AUTOPROXY
+      SHAREDCACHE    = FFI::CApi::SQLITE_OPEN_SHAREDCACHE
+      PRIVATECACHE   = FFI::CApi::SQLITE_OPEN_PRIVATECACHE
+      WAL            = FFI::CApi::SQLITE_OPEN_WAL
+      URI            = FFI::CApi::SQLITE_OPEN_URI
+      MEMORY         = FFI::CApi::SQLITE_OPEN_MEMORY
+    end
+  end
+
+  def self.threadsafe
+    FFI::CApi.sqlite3_threadsafe
+  end
+
+  def self.sqlcipher?
+    false
+  end
+
+  def self.libversion
+    FFI::CApi.sqlite3_libversion
+  end
+
+  def self.status(parameter, reset_flag = false)
+    op = parameter.to_i
+    reset = reset_flag ? 1 : 0
+
+    p_current = ::FFI::MemoryPointer.new(:int64)
+    p_highwater = ::FFI::MemoryPointer.new(:int64)
+    FFI::CApi.sqlite3_status64(op, p_current, p_highwater, reset)
+
+    {
+      current: p_current.read_int64,
+      highwater: p_highwater.read_int64
+    }
+  end
+
+  SQLITE_VERSION = FFI::CApi.sqlite3_libversion
+  SQLITE_VERSION_NUMBER = FFI::CApi.sqlite3_libversion_number
+  SQLITE_LOADED_VERSION = FFI::CApi.sqlite3_libversion
+  SQLITE_PACKAGED_LIBRARIES = false
+  SQLITE_PRECOMPILED_LIBRARIES = false
+end