sqlite3 0.0.5 → 0.0.6

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/sqlite3/constants.rb

@@ -1,14 +1,6 @@
 module SQLite3
   module Constants
 
-    # module TextRep
-    #   UTF8    = 1
-    #   UTF16LE = 2
-    #   UTF16BE = 3
-    #   UTF16   = 4
-    #   ANY     = 5
-    # end
-
     module ColumnType
       INTEGER = 1
       FLOAT   = 2

data/lib/sqlite3/database.rb

@@ -77,9 +77,6 @@ module SQLite3
 
       @closed = false
       @results_as_hash = options.fetch(:results_as_hash, false)
-      # @type_translation = options.fetch(:type_translation, false)
-      # @translator = nil
-      # @transaction_active = false
     end
 
     # Return +true+ if the string is a valid (ie, parsable) SQL statement, and
@@ -100,16 +97,6 @@ module SQLite3
       @driver.errcode(@handle)
     end
 
-    # Return the type translator employed by this database instance. Each
-    # database instance has its own type translator; this allows for different
-    # type handlers to be installed in each instance without affecting other
-    # instances. Furthermore, the translators are instantiated lazily, so that
-    # if a database does not use type translation, it will not be burdened by
-    # the overhead of a useless type translator. (See the Translator class.)
-    # def translator
-    #   @translator ||= Translator.new
-    # end
-
     # Closes this database.
     def close
       unless @closed
@@ -189,49 +176,6 @@ module SQLite3
       end
     end
 
-    # Executes all SQL statements in the given string. By contrast, the other
-    # means of executing queries will only execute the first statement in the
-    # string, ignoring all subsequent statements. This will execute each one
-    # in turn. The same bind parameters, if given, will be applied to each
-    # statement.
-    #
-    # This always returns +nil+, making it unsuitable for queries that return
-    # rows.
-    # def execute_batch(sql, *bind_vars)
-    #   sql = sql.strip
-    #   until sql.empty? do
-    #     prepare(sql) do |stmt|
-    #       stmt.execute(*bind_vars)
-    #       sql = stmt.remainder.strip
-    #     end
-    #   end
-    #   nil
-    # end
-
-    # This is a convenience method for creating a statement, binding
-    # paramters to it, and calling execute:
-    #
-    #   result = db.query("select * from foo where a=?", 5)
-    #   # is the same as
-    #   result = db.prepare("select * from foo where a=?").execute(5)
-    #
-    # You must be sure to call +close+ on the ResultSet instance that is
-    # returned, or you could have problems with locks on the table. If called
-    # with a block, +close+ will be invoked implicitly when the block
-    # terminates.
-    # def query(sql, *bind_vars)
-    #   result = prepare(sql).execute(*bind_vars)
-    #   if block_given?
-    #     begin
-    #       yield result
-    #     ensure
-    #       result.close
-    #     end
-    #   else
-    #     return result
-    #   end
-    # end
-
     # A convenience method for obtaining the first row of a result set, and
     # discarding all others. It is otherwise identical to #execute.
     #
@@ -264,17 +208,6 @@ module SQLite3
       @driver.changes(@handle)
     end
 
-    # Returns the total number of changes made to this database instance
-    # since it was opened.
-    # def total_changes
-    #   @driver.total_changes(@handle)
-    # end
-
-    # Interrupts the currently executing operation, causing it to abort.
-    # def interrupt
-    #   @driver.interrupt(@handle)
-    # end
-
     # Indicates that if a request for a resource terminates because that
     # resource is busy, SQLite should sleep and retry for up to the indicated
     # number of milliseconds. By default, SQLite does not retry
@@ -377,4 +310,3 @@ module SQLite3
 
   end
 end
-

data/lib/sqlite3/driver/ffi/api.rb

@@ -11,7 +11,7 @@ module SQLite3
                   "libsqlite3.dylib"
                 when /linux|freebsd|netbsd|openbsd|dragonfly|solaris/
                   "libsqlite3.so"
-                when /win32|i386-mingw32/
+                when /win|mingw/
                   "sqlite3.dll"
                 else
                   abort <<-EOF
@@ -33,16 +33,10 @@ EOF
         attach_function :sqlite3_errmsg16, [:pointer], :pointer
         attach_function :sqlite3_errcode, [:pointer], :int
         attach_function :sqlite3_prepare, [:pointer, :string, :int, :pointer, :pointer], :int
-        # attach_function :sqlite3_prepare16, [:pointer, :pointer, :int, :pointer, :pointer], :int
         attach_function :sqlite3_finalize, [:pointer], :int
-        # attach_function :sqlite3_reset, [:pointer], :int
         attach_function :sqlite3_step, [:pointer], :int
         attach_function :sqlite3_last_insert_rowid, [:pointer], :int64
         attach_function :sqlite3_changes, [:pointer], :int
-        # attach_function :sqlite3_total_changes, [:pointer], :int
-        # attach_function :sqlite3_interrupt, [:pointer], :void
-        # attach_function :sqlite3_complete, [:string], :int
-        # attach_function :sqlite3_complete16, [:pointer], :int
         attach_function :sqlite3_busy_timeout, [:pointer, :int], :int
         attach_function :sqlite3_bind_blob, [:pointer, :int, :pointer, :int, :pointer], :int
         attach_function :sqlite3_bind_double, [:pointer, :int, :double], :int
@@ -51,57 +45,18 @@ EOF
         attach_function :sqlite3_bind_null, [:pointer, :int], :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_bind_value, [:pointer, :int, :pointer], :int
-        # attach_function :sqlite3_bind_parameter_count, [:pointer], :int
-        # attach_function :sqlite3_bind_parameter_name, [:pointer, :int], :string
-        # attach_function :sqlite3_bind_parameter_index, [:pointer, :string], :int
         attach_function :sqlite3_column_count, [:pointer], :int
         attach_function :sqlite3_data_count, [: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_decltype, [:pointer, :int], :string
-        # attach_function :sqlite3_column_decltype16, [:pointer, :int], :pointer
         attach_function :sqlite3_column_double, [:pointer, :int], :double
-        # attach_function :sqlite3_column_int, [:pointer, :int], :int
         attach_function :sqlite3_column_int64, [:pointer, :int], :int64
         attach_function :sqlite3_column_name, [:pointer, :int], :string
-        # attach_function :sqlite3_column_name16, [:pointer, :int], :pointer
         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_aggregate_count, [:pointer], :int
-        # attach_function :sqlite3_value_blob, [:pointer], :pointer
-        # attach_function :sqlite3_value_bytes, [:pointer], :int
-        # attach_function :sqlite3_value_bytes16, [:pointer], :int
-        # attach_function :sqlite3_value_double, [:pointer], :double
-        # attach_function :sqlite3_value_int, [:pointer], :int
-        # attach_function :sqlite3_value_int64, [:pointer], :int64
-        # attach_function :sqlite3_value_text, [:pointer], :string
-        # attach_function :sqlite3_value_text16, [:pointer], :pointer
-        # attach_function :sqlite3_value_text16le, [:pointer], :pointer
-        # attach_function :sqlite3_value_text16be, [:pointer], :pointer
-        # attach_function :sqlite3_value_type, [:pointer], :int
-        # attach_function :sqlite3_aggregate_context, [:pointer, :int], :pointer
-        # attach_function :sqlite3_user_data, [:pointer], :pointer
-        # attach_function :sqlite3_get_auxdata, [:pointer, :int], :pointer
-        # attach_function :sqlite3_set_auxdata, [:pointer, :int, :pointer, :pointer], :void
-        # attach_function :sqlite3_result_blob, [:pointer, :pointer, :int, :pointer], :void
-        # attach_function :sqlite3_result_double, [:pointer, :double], :void
-        # attach_function :sqlite3_result_error, [:pointer, :string, :int], :void
-        # attach_function :sqlite3_result_error16, [:pointer, :pointer, :int], :void
-        # attach_function :sqlite3_result_int, [:pointer, :int], :void
-        # attach_function :sqlite3_result_int64, [:pointer, :int64], :void
-        # attach_function :sqlite3_result_null, [:pointer], :void
-        # attach_function :sqlite3_result_text, [:pointer, :string, :int, :pointer], :void
-        # attach_function :sqlite3_result_text16, [:pointer, :pointer, :int, :pointer], :void
-        # attach_function :sqlite3_result_text16le, [:pointer, :pointer, :int, :pointer], :void
-        # attach_function :sqlite3_result_text16be, [:pointer, :pointer, :int, :pointer], :void
-        # attach_function :sqlite3_result_value, [:pointer, :pointer], :void
-        # attach_function :sqlite3_create_collation, [:pointer, :string, :int, :pointer, :pointer], :int
-        # attach_function :sqlite3_create_collation16, [:pointer, :string, :int, :pointer, :pointer], :int
-        # attach_function :sqlite3_collation_needed, [:pointer, :pointer, :pointer], :int
-        # attach_function :sqlite3_collation_needed16, [:pointer, :pointer, :pointer], :int
       end
 
     end

data/lib/sqlite3/driver/ffi/driver.rb

@@ -44,66 +44,6 @@ module SQLite3
           [result, handle.get_pointer(0), remainder_string]
         end
 
-        # def complete?(sql)
-        #   API.send(utf16?(string) ? :sqlite3_complete16 : :sqlite3_complete, sql)
-        # end
-
-        # def value_blob(value)
-        #   blob = API.sqlite3_value_blob(value)
-        #   # blob.free = nil
-        #   blob.to_s(API.sqlite3_value_bytes(value))
-        # end
-
-        # def value_text(value)
-        #   method = case utf16
-        #            when nil, false
-        #              :sqlite3_value_text
-        #            when :le
-        #              :sqlite3_value_text16le
-        #            when :be
-        #              :sqlite3_value_text16be
-        #            else
-        #              :sqlite3_value_text16
-        #            end
-
-        #   result = API.send(method, value)
-
-        #   if utf16
-        #     # result.free = nil
-        #     size = API.sqlite3_value_bytes(value)
-        #     result = result.to_s(size)
-        #   end
-
-        #   result
-        # end
-
-        # def result_text(func, text)
-        #   method = case utf16
-        #            when false, nil
-        #              :sqlite3_result_text
-        #            when :le
-        #              :sqlite3_result_text16le
-        #            when :be
-        #              :sqlite3_result_text16be
-        #            else
-        #              :sqlite3_result_text16
-        #            end
-
-        #   s = text.to_s
-        #   API.send(method, func, s, s.length, TRANSIENT)
-        # end
-
-        # def aggregate_context(context)
-        #   ptr = API.sqlite3_aggregate_context(context, 4)
-        #   ptr.free = nil
-        #   obj = (ptr ? ptr.to_object : nil)
-        #   if obj.nil?
-        #     obj = Hash.new
-        #     ptr.set_object obj
-        #   end
-        #   obj
-        # end
-
         def bind_string(stmt, index, value)
           case value.encoding
           when Encoding.utf_8, Encoding.us_ascii
@@ -138,7 +78,6 @@ module SQLite3
 
         api_delegate :column_name
         api_delegate :column_decltype
-        # api_delegate :aggregate_count
         api_delegate :bind_double
         api_delegate :bind_int
         api_delegate :bind_int64
@@ -148,29 +87,16 @@ module SQLite3
         api_delegate :busy_timeout
         api_delegate :changes
         api_delegate :close
-        # api_delegate :column_bytes
-        # api_delegate :column_bytes16
         api_delegate :column_count
         api_delegate :column_double
-        # api_delegate :column_int
         api_delegate :column_int64
         api_delegate :column_type
         api_delegate :data_count
         api_delegate :errcode
         api_delegate :finalize
-        # api_delegate :interrupt
         api_delegate :last_insert_rowid
         api_delegate :libversion
-        # api_delegate :reset
-        # api_delegate :result_error
         api_delegate :step
-        # api_delegate :total_changes
-        # api_delegate :value_bytes
-        # api_delegate :value_bytes16
-        # api_delegate :value_double
-        # api_delegate :value_int
-        # api_delegate :value_int64
-        # api_delegate :value_type
 
         private
 

data/lib/sqlite3/errors.rb

@@ -41,17 +41,18 @@ module SQLite3
   class RangeException < Exception; end
   class NotADatabaseException < Exception; end
 
-  EXCEPTIONS = [
-                nil,
-                SQLException, InternalException, PermissionException,
-                AbortException, BusyException, LockedException, MemoryException,
-                ReadOnlyException, InterruptException, IOException, CorruptException,
-                NotFoundException, FullException, CantOpenException, ProtocolException,
-                EmptyException, SchemaChangedException, TooBigException,
-                ConstraintException, MismatchException, MisuseException,
-                UnsupportedException, AuthorizationException, FormatException,
-                RangeException, NotADatabaseException
-               ].each_with_index { |e,i| e.instance_variable_set( :@code, i ) if e }
+  EXCEPTIONS =
+    [
+     nil, SQLException, InternalException,
+     PermissionException, AbortException, BusyException,
+     LockedException, MemoryException, ReadOnlyException,
+     InterruptException, IOException, CorruptException,
+     NotFoundException, FullException, CantOpenException,
+     ProtocolException, EmptyException, SchemaChangedException,
+     TooBigException, ConstraintException, MismatchException,
+     MisuseException, UnsupportedException, AuthorizationException,
+     FormatException, RangeException, NotADatabaseException
+    ].each_with_index { |e,i| e.instance_variable_set(:@code, i ) if e }
 
   module Error
     def check( result, db=nil, msg=nil )

data/lib/sqlite3/pragmas.rb

@@ -7,211 +7,6 @@ module SQLite3
   # at http://sqlite.org/pragma.html.
   module Pragmas
 
-    # Returns +true+ or +false+ depending on the value of the named pragma.
-    # def get_boolean_pragma(name)
-    #   get_first_value("PRAGMA #{name}") != "0"
-    # end
-    # private :get_boolean_pragma
-
-    # Sets the given pragma to the given boolean value. The value itself
-    # may be +true+ or +false+, or any other commonly used string or
-    # integer that represents truth.
-    # def set_boolean_pragma(name, mode)
-    #   case mode
-    #   when String
-    #     case mode.downcase
-    #     when "on", "yes", "true", "y", "t"
-    #       mode = "'ON'"
-    #     when "off", "no", "false", "n", "f"
-    #       mode = "'OFF'"
-    #     else
-    #       raise Exception, "unrecognized pragma parameter #{mode.inspect}"
-    #     end
-    #   when true, 1
-    #     mode = "ON"
-    #   when false, 0, nil
-    #     mode = "OFF"
-    #   else
-    #     raise Exception,
-    #     "unrecognized pragma parameter #{mode.inspect}"
-    #   end
-
-    #   execute("PRAGMA #{name}=#{mode}")
-    # end
-    # private :set_boolean_pragma
-
-    # Requests the given pragma (and parameters), and if the block is given,
-    # each row of the result set will be yielded to it. Otherwise, the results
-    # are returned as an array.
-    # def get_query_pragma(name, *parms, &block) # :yields: row
-    #   if parms.empty?
-    #     execute("PRAGMA #{name}", &block)
-    #   else
-    #     args = "'" + parms.join("','") + "'"
-    #     execute("PRAGMA #{name}(#{args})", &block)
-    #   end
-    # end
-    # private :get_query_pragma
-
-    # Return the value of the given pragma.
-    # def get_enum_pragma(name)
-    #   get_first_value("PRAGMA #{name}")
-    # end
-    # private :get_enum_pragma
-
-    # Set the value of the given pragma to +mode+. The +mode+ parameter must
-    # conform to one of the values in the given +enum+ array. Each entry in
-    # the array is another array comprised of elements in the enumeration that
-    # have duplicate values. See #synchronous, #default_synchronous,
-    # #temp_store, and #default_temp_store for usage examples.
-    # def set_enum_pragma(name, mode, enums)
-    #   match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
-    #   raise Exception,
-    #   "unrecognized #{name} #{mode.inspect}" unless match
-    #   execute("PRAGMA #{name}='#{match.first.upcase}'")
-    # end
-    # private :set_enum_pragma
-
-    # Returns the value of the given pragma as an integer.
-    # def get_int_pragma(name)
-    #   get_first_value("PRAGMA #{name}").to_i
-    # end
-    # private :get_int_pragma
-
-    # Set the value of the given pragma to the integer value of the +value+
-    # parameter.
-    # def set_int_pragma(name, value)
-    #   execute("PRAGMA #{name}=#{value.to_i}")
-    # end
-    # private :set_int_pragma
-
-    # The enumeration of valid synchronous modes.
-    # SYNCHRONOUS_MODES = [ [ "full", 2 ], [ "normal", 1 ], [ "off", 0 ] ]
-
-    # The enumeration of valid temp store modes.
-    # TEMP_STORE_MODES  = [ [ "default", 0 ], [ "file", 1 ], [ "memory", 2 ] ]
-
-    # Does an integrity check on the database. If the check fails, a
-    # SQLite3::Exception will be raised. Otherwise it
-    # returns silently.
-    # def integrity_check
-    #   execute("PRAGMA integrity_check") do |row|
-    #     raise Exception, row[0] if row[0] != "ok"
-    #   end
-    # end
-
-    # def auto_vacuum
-    #   get_boolean_pragma "auto_vacuum"
-    # end
-
-    # def auto_vacuum=(mode)
-    #   set_boolean_pragma "auto_vacuum", mode
-    # end
-
-    # def schema_cookie
-    #   get_int_pragma "schema_cookie"
-    # end
-
-    # def schema_cookie=(cookie)
-    #   set_int_pragma "schema_cookie", cookie
-    # end
-
-    # def user_cookie
-    #   get_int_pragma "user_cookie"
-    # end
-
-    # def user_cookie=(cookie)
-    #   set_int_pragma "user_cookie", cookie
-    # end
-
-    # def cache_size
-    #   get_int_pragma "cache_size"
-    # end
-
-    # def cache_size=(size)
-    #   set_int_pragma "cache_size", size
-    # end
-
-    # def default_cache_size
-    #   get_int_pragma "default_cache_size"
-    # end
-
-    # def default_cache_size=(size)
-    #   set_int_pragma "default_cache_size", size
-    # end
-
-    # def default_synchronous
-    #   get_enum_pragma "default_synchronous"
-    # end
-
-    # def default_synchronous=(mode)
-    #   set_enum_pragma "default_synchronous", mode, SYNCHRONOUS_MODES
-    # end
-
-    # def synchronous
-    #   get_enum_pragma "synchronous"
-    # end
-
-    # def synchronous=(mode)
-    #   set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
-    # end
-
-    # def default_temp_store
-    #   get_enum_pragma "default_temp_store"
-    # end
-
-    # def default_temp_store=(mode)
-    #   set_enum_pragma "default_temp_store", mode, TEMP_STORE_MODES
-    # end
-
-    # def temp_store
-    #   get_enum_pragma "temp_store"
-    # end
-
-    # def temp_store=(mode)
-    #   set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
-    # end
-
-    # def full_column_names
-    #   get_boolean_pragma "full_column_names"
-    # end
-
-    # def full_column_names=(mode)
-    #   set_boolean_pragma "full_column_names", mode
-    # end
-
-    # def parser_trace
-    #   get_boolean_pragma "parser_trace"
-    # end
-
-    # def parser_trace=(mode)
-    #   set_boolean_pragma "parser_trace", mode
-    # end
-
-    # def vdbe_trace
-    #   get_boolean_pragma "vdbe_trace"
-    # end
-
-    # def vdbe_trace=(mode)
-    #   set_boolean_pragma "vdbe_trace", mode
-    # end
-
-    # def database_list(&block) # :yields: row
-    #   get_query_pragma "database_list", &block
-    # end
-
-    # def foreign_key_list(table, &block) # :yields: row
-    #   get_query_pragma "foreign_key_list", table, &block
-    # end
-
-    # def index_info(index, &block) # :yields: row
-    #   get_query_pragma "index_info", index, &block
-    # end
-
-    # def index_list(table, &block) # :yields: row
-    #   get_query_pragma "index_list", table, &block
-    # end
-
     def table_info(table, &block) # :yields: row
       columns, *rows = execute2("PRAGMA table_info(#{table})")
 

data/lib/sqlite3/statement.rb

@@ -198,9 +198,6 @@ module SQLite3
         @columns << @driver.column_name(@handle, column)
         @types << @driver.column_decltype(@handle, column)
       end
-
-      @columns.freeze
-      @types.freeze
     end
     private :get_metadata
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sqlite3
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - "Jakub Ku\xC5\xBAma"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-20 00:00:00 +01:00
+date: 2009-12-26 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency