sqlite3 0.1.1 → 1.3.3.beta.1

data/lib/sqlite3/api.rb

@@ -1,52 +0,0 @@
-module SQLite3
-  module API
-    extend FFI::Library
-
-    lib_paths = Array(ENV["SQLITE3_LIB"] || Dir["/{opt,usr}/{,local/}lib{,64}/libsqlite3.{dylib,so*}"])
-    fallback_names = ["libsqlite3", "sqlite3"]
-    ffi_lib(lib_paths + fallback_names)
-
-    attach_function :sqlite3_bind_blob, [:pointer, :int, :pointer, :int, :pointer], :int
-    attach_function :sqlite3_bind_double, [:pointer, :int, :double], :int
-    attach_function :sqlite3_bind_int, [:pointer, :int, :int], :int
-    attach_function :sqlite3_bind_int64, [:pointer, :int, :int64], :int
-    attach_function :sqlite3_bind_null, [:pointer, :int], :int
-    attach_function :sqlite3_bind_parameter_index, [:pointer, :string], :int
-    attach_function :sqlite3_bind_text, [:pointer, :int, :string, :int, :pointer], :int
-    attach_function :sqlite3_bind_text16, [:pointer, :int, :pointer, :int, :pointer], :int
-    attach_function :sqlite3_busy_timeout, [:pointer, :int], :int
-    attach_function :sqlite3_changes, [:pointer], :int
-    attach_function :sqlite3_close, [:pointer], :int
-    attach_function :sqlite3_column_blob, [:pointer, :int], :pointer
-    attach_function :sqlite3_column_bytes, [:pointer, :int], :int
-    attach_function :sqlite3_column_bytes16, [:pointer, :int], :int
-    attach_function :sqlite3_column_count, [:pointer], :int
-    attach_function :sqlite3_column_decltype, [:pointer, :int], :string
-    attach_function :sqlite3_column_double, [:pointer, :int], :double
-    attach_function :sqlite3_column_int64, [:pointer, :int], :int64
-    attach_function :sqlite3_column_name, [:pointer, :int], :string
-    attach_function :sqlite3_column_text, [:pointer, :int], :string
-    attach_function :sqlite3_column_text16, [:pointer, :int], :pointer
-    attach_function :sqlite3_column_type, [:pointer, :int], :int
-    attach_function :sqlite3_data_count, [:pointer], :int
-    attach_function :sqlite3_errcode, [:pointer], :int
-    attach_function :sqlite3_errmsg, [:pointer], :string
-    attach_function :sqlite3_errmsg16, [:pointer], :pointer
-    attach_function :sqlite3_finalize, [:pointer], :int
-    attach_function :sqlite3_last_insert_rowid, [:pointer], :int64
-    attach_function :sqlite3_libversion, [], :string
-    attach_function :sqlite3_open, [:string, :pointer], :int
-    attach_function :sqlite3_open16, [:pointer, :pointer], :int
-    attach_function :sqlite3_prepare, [:pointer, :string, :int, :pointer, :pointer], :int
-    attach_function :sqlite3_reset, [:pointer], :int
-    attach_function :sqlite3_step, [:pointer], :int
-
-    begin
-      attach_function :sqlite3_enable_load_extension, [:pointer, :int], :int
-      attach_function :sqlite3_load_extension, [:pointer, :string, :string, :string], :int
-      EXTENSION_SUPPORT = true
-    rescue FFI::NotFoundError
-      EXTENSION_SUPPORT = false
-    end
-  end
-end

data/lib/sqlite3/driver.rb

@@ -1,138 +0,0 @@
-module SQLite3
-  class Driver
-    TRANSIENT = FFI::Pointer.new(-1)
-
-    def open(filename, utf_16 = false)
-      handle = FFI::MemoryPointer.new(:pointer)
-      if utf_16
-        filename = filename.encode(Encoding.utf_16native) if filename.respond_to?(:encode)
-        result = API.sqlite3_open16(c_string(filename), handle)
-      else
-        filename = filename.encode(Encoding.utf_8) if filename.respond_to?(:encode)
-        result = API.sqlite3_open(filename, handle)
-      end
-      [result, handle.get_pointer(0)]
-    end
-
-    def errmsg(db, utf_16 = false)
-      if utf_16
-        ptr = API.sqlite3_errmsg16(db)
-        result = get_string_utf_16(ptr)
-        result.force_encoding(Encoding.utf_16native) if result.respond_to?(:force_encoding)
-        result
-      else
-        result = API.sqlite3_errmsg(db)
-        result.force_encoding(Encoding.utf_8) if result.respond_to?(:force_encoding)
-        result
-      end
-    end
-
-    def prepare(db, sql)
-      handle = FFI::MemoryPointer.new(:pointer)
-      remainder = FFI::MemoryPointer.new(:pointer)
-
-      if Encoding.utf_16?(sql)
-        str = c_string(sql)
-        result = API.sqlite3_prepare16(db, str, str.bytesize, handle, remainder)
-        remainder_string = get_string_utf_16(remainder.get_pointer(0))
-      else
-        result = API.sqlite3_prepare(db, sql, sql.bytesize, handle, remainder)
-        remainder_string = remainder.get_pointer(0).get_string(0)
-      end
-
-      [result, handle.get_pointer(0), remainder_string]
-    end
-
-    def bind_string(stmt, index, value)
-      case value.encoding
-      when Encoding.utf_8, Encoding.us_ascii
-        API.sqlite3_bind_text(stmt, index, value, value.bytesize, TRANSIENT)
-      when Encoding.utf_16le, Encoding.utf_16be
-        value = add_byte_order_mask(value)
-        API.sqlite3_bind_text16(stmt, index, value, value.bytesize, TRANSIENT)
-      else
-        API.sqlite3_bind_blob(stmt, index, value, value.bytesize, TRANSIENT)
-      end
-    end
-
-    def column_blob(stmt, column)
-      blob = API.sqlite3_column_blob(stmt, column)
-      length = API.sqlite3_column_bytes(stmt, column)
-      blob.get_bytes(0, length) # free?
-    end
-
-    def column_text(stmt, column, utf_16 = false)
-      if utf_16
-        ptr = API.sqlite3_column_text16(stmt, column)
-        length = API.sqlite3_column_bytes16(stmt, column)
-        ptr.get_bytes(0, length).force_encoding(Encoding.utf_16native) # free?
-      else
-        API.sqlite3_column_text(stmt, column).force_encoding(Encoding.utf_8)
-      end
-    end
-
-    def extension_support?
-      API::EXTENSION_SUPPORT
-    end
-
-    def load_extension(db, name, entry_point = nil)
-      result = API.sqlite3_load_extension(db, name, entry_point, nil)
-      [result, nil]
-    end
-
-    def enable_load_extension(db, onoff = false)
-      API.sqlite3_enable_load_extension(db, (onoff ? 1 : 0))
-    end
-
-    def self.api_delegate(name)
-      define_method(name) { |*args| API.send("sqlite3_#{name}", *args) }
-    end
-
-    api_delegate :bind_double
-    api_delegate :bind_int
-    api_delegate :bind_int64
-    api_delegate :bind_null
-    api_delegate :bind_parameter_index
-    api_delegate :busy_timeout
-    api_delegate :changes
-    api_delegate :close
-    api_delegate :column_count
-    api_delegate :column_decltype
-    api_delegate :column_double
-    api_delegate :column_int64
-    api_delegate :column_name
-    api_delegate :column_type
-    api_delegate :data_count
-    api_delegate :errcode
-    api_delegate :finalize
-    api_delegate :last_insert_rowid
-    api_delegate :libversion
-    api_delegate :reset
-    api_delegate :step
-
-    private
-
-    def c_string(string)
-      if Encoding.utf_16?(string)
-        result = add_byte_order_mask(string)
-        terminate_string!(result)
-      else
-        string # FFI does the job
-      end
-    end
-
-    def add_byte_order_mask(string)
-      "\uFEFF".encode(string.encoding) + string
-    end
-
-    def terminate_string!(string)
-      string << "\0\0".force_encoding(string.encoding)
-    end
-
-    def get_string_utf_16(ptr)
-      length = 0
-      length += 2 until ptr.get_bytes(length, 2) == "\0\0"
-      ptr.get_bytes(0, length)
-    end
-  end
-end

data/lib/sqlite3/encoding.rb

@@ -1,43 +0,0 @@
-module SQLite3
-  class Encoding
-    class << self
-      def find(encoding)
-        enc = encoding.to_s
-        if enc.downcase == "utf-16"
-          utf_16native
-        else
-          ::Encoding.find(enc).tap do |e|
-            if utf_16?(e) && e != utf_16native
-              raise ArgumentError, "requested to use byte order different than native"
-            end
-          end
-        end
-      end
-
-      def utf_16?(str_or_enc)
-        enc = str_or_enc.kind_of?(::Encoding) ? str_or_enc : str_or_enc.encoding
-        [utf_16le, utf_16be].include?(enc)
-      end
-
-      def utf_16native
-        "Ruby".unpack("i")[0] == 2036495698 ? utf_16le : utf_16be
-      end
-
-      def us_ascii
-        ::Encoding::US_ASCII
-      end
-
-      def utf_8
-        ::Encoding::UTF_8
-      end
-
-      def utf_16le
-        ::Encoding::UTF_16LE
-      end
-
-      def utf_16be
-        ::Encoding::UTF_16BE
-      end
-    end
-  end
-end

data/lib/sqlite3/extensions.rb

@@ -1,27 +0,0 @@
-module SQLite3
-  module Extensions
-    def enable_load_extension(onoff=true)
-      must_support_extensions!
-      result = @driver.enable_load_extension(@handle, onoff)
-      Error.check(result, self)
-    end
-
-    def disable_load_extension
-      must_support_extensions!
-      result = @driver.enable_load_extension(@handle, false)
-      Error.check(result, self)
-    end
-
-    def load_extension(name, entry_point=nil)
-      must_support_extensions!
-      result, message = @driver.load_extension(@handle, name, entry_point)
-      Error.check(result, self, message)
-    end
-
-    private
-
-    def must_support_extensions!
-      raise SQLite3::Exception, "extensions API not supported" unless @driver.extension_support?
-    end
-  end
-end