sqlite3-fiddle 1.0.0

data/lib/sqlite3/driver.rb

@@ -0,0 +1,115 @@
+require 'fiddle'
+require 'fiddle/import'
+
+module SQLite3
+  module Driver
+    extend Fiddle::Importer
+
+    if path = $LIBSQLITE3 || ENV['LIBSQLITE3']
+      dlload path
+    else
+      dlload 'libsqlite3.dylib' rescue begin
+        dlload 'libsqlite3.so' rescue begin
+          dlload 'libsqlite3.dll' rescue fail('Unable to find libsqlite3, set ' +
+            'the global $LIBSQLITE3 or the environment variable LIBSQLITE3')
+        end
+      end
+    end
+
+    extern 'const char *sqlite3_libversion()'
+    extern 'int sqlite3_busy_timeout(void*, int)'
+    extern 'int sqlite3_open_v2(const char *, sqlite3 **, int, const char *)'
+    extern 'int sqlite3_open16(const void *,sqlite3 **)'
+    extern 'int sqlite3_close(sqlite3*)'
+    extern 'int sqlite3_changes(void*)'
+    extern 'int sqlite3_total_changes(sqlite3*)'
+    extern 'long long sqlite3_last_insert_rowid(void*)'
+    extern 'int sqlite3_prepare_v2(void*, void*, int, void*, void*)'
+    extern 'int sqlite3_step(void*)'
+    extern 'int sqlite3_finalize(void*)'
+    extern 'int sqlite3_reset(void *)'
+    extern 'int sqlite3_clear_bindings(void*)'
+    extern 'int sqlite3_bind_parameter_count(void*)'
+    extern 'int sqlite3_column_count(void*)'
+    extern 'const char *sqlite3_column_name(void*, int)' rescue nil
+    extern 'const char *sqlite3_column_decltype(void*, int)'
+    extern 'const char *sqlite3_column_database_name(void*,int)' rescue nil
+    extern 'const char *sqlite3_column_table_name(void*,int)' rescue nil
+    extern 'const char *sqlite3_column_origin_name(void*,int)' rescue nil
+    extern 'int sqlite3_column_type(void*, int)'
+    extern 'const void *sqlite3_column_blob(void*, int)'
+    extern 'int sqlite3_column_bytes(void*, int)'
+    extern 'double sqlite3_column_double(void*, int)'
+    extern 'long long sqlite3_column_int64(void*, int)'
+    extern 'const unsigned char *sqlite3_column_text(void*, int)'
+    extern 'int sqlite3_bind_blob(void*, int, const void*, int, void*)'
+    extern 'int sqlite3_bind_double(void*, int, double)'
+    extern 'int sqlite3_bind_int64(void*, int, long long)'
+    extern 'int sqlite3_bind_null(void*, int)'
+    extern 'int sqlite3_bind_text(void*,int,const char*,int,void*)'
+    extern 'int sqlite3_bind_text16(void*,int,const char*,int,void*)'
+    extern 'int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *)'
+    extern 'int sqlite3_errcode(sqlite3 *)'
+    extern 'int sqlite3_complete(const char *)'
+    extern 'int sqlite3_get_autocommit(sqlite3*)'
+    extern 'int sqlite3_db_readonly(sqlite3 *, const char *)'
+    extern 'const char *sqlite3_errmsg(sqlite3*)'
+    extern 'void *sqlite3_trace(void*, void*, void*)'
+    extern 'int sqlite3_set_authorizer(sqlite3*, void*, void*)'
+    extern 'const void *sqlite3_value_blob(sqlite3_value*)'
+    extern 'int sqlite3_value_bytes(sqlite3_value*)'
+    extern 'int sqlite3_value_bytes16(sqlite3_value*)'
+    extern 'double sqlite3_value_double(sqlite3_value*)'
+    extern 'int sqlite3_value_int(sqlite3_value*)'
+    extern 'long long sqlite3_value_int64(sqlite3_value*)'
+    extern 'const unsigned char *sqlite3_value_text(sqlite3_value*)'
+    extern 'const void *sqlite3_value_text16(sqlite3_value*)'
+    extern 'const void *sqlite3_value_text16le(sqlite3_value*)'
+    extern 'const void *sqlite3_value_text16be(sqlite3_value*)'
+    extern 'int sqlite3_value_type(sqlite3_value*)'
+    extern 'int sqlite3_value_numeric_type(sqlite3_value*)'
+    extern 'void sqlite3_result_blob(sqlite3_context*, const void*, int, void*)'
+    extern 'void sqlite3_result_double(sqlite3_context*, double)'
+    extern 'void sqlite3_result_error(sqlite3_context*, const char*, int)'
+    extern 'void sqlite3_result_int(sqlite3_context*, int)'
+    extern 'void sqlite3_result_int64(sqlite3_context*, long long)'
+    extern 'void sqlite3_result_null(sqlite3_context*)'
+    extern 'void sqlite3_result_text(sqlite3_context*, const char*, int, void*)'
+    extern 'void sqlite3_result_text16(sqlite3_context*, const char*, int, void*)'
+    extern 'int sqlite3_create_function(sqlite3 *,const char *,int,int,void*,void*,void*,void*)'
+    extern 'void *sqlite3_user_data(sqlite3_context*)'
+    extern 'void sqlite3_interrupt(sqlite3*)'
+    extern 'int sqlite3_busy_handler(sqlite3*, void*, void*)'
+    extern 'int sqlite3_create_collation(sqlite3*,const char *,int,void *,void*)'
+    extern 'const char *sqlite3_errmsg(sqlite3*)'
+    extern 'sqlite3_backup *sqlite3_backup_init(sqlite3 *, const char *, sqlite3 *, const char *)'
+    extern 'int sqlite3_backup_step(sqlite3_backup *, int)'
+    extern 'int sqlite3_backup_finish(sqlite3_backup *)'
+    extern 'int sqlite3_backup_remaining(sqlite3_backup *)'
+    extern 'int sqlite3_backup_pagecount(sqlite3_backup *)'
+
+    def self.set_context_result(ctx, var)
+      case var
+      when Blob
+        Driver.sqlite3_result_blob(ctx, var.to_s, var.to_s.size, nil)
+      when String
+        if var.encoding == Encoding::UTF_16LE ||
+           var.encoding == Encoding::UTF_16BE
+          Driver.sqlite3_result_text16(ctx, var, -1, nil)
+        else
+          Driver.sqlite3_result_text(ctx, var.encode(Encoding::UTF_8), -1, nil)
+        end
+      when Fixnum, Bignum
+        Driver.sqlite3_result_int64(ctx, var)
+      when Float
+        Driver.sqlite3_result_double(ctx, var)
+      when NilClass
+        Driver.sqlite3_result_null(ctx)
+      when TrueClass, FalseClass
+        Driver.sqlite3_result_int(ctx, var ? 1 : 0)
+      else
+        raise RuntimeError, "can't return #{var.class}"
+      end
+    end
+  end
+end

data/lib/sqlite3/pragmas.rb

@@ -0,0 +1,280 @@
+require 'sqlite3/constants'
+
+module SQLite3
+
+  # This module is intended for inclusion solely by the Database class. It
+  # defines convenience methods for the various pragmas supported by SQLite3.
+  #
+  # For a detailed description of these pragmas, see the SQLite3 documentation
+  # 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
+
+    ###
+    # Returns information about +table+.  Yields each row of table information
+    # if a block is provided.
+    def table_info table
+      stmt    = prepare "PRAGMA table_info(#{table})"
+      columns = stmt.columns
+
+      needs_tweak_default =
+        version_compare(SQLite3.libversion.to_s, "3.3.7") > 0
+
+      result = [] unless block_given?
+      stmt.each do |row|
+        new_row = Hash[columns.zip(row)]
+
+        # FIXME: This should be removed but is required for older versions
+        # of rails
+        if(Object.const_defined?(:ActiveRecord))
+          new_row['notnull'] = new_row['notnull'].to_s
+        end
+
+        tweak_default(new_row) if needs_tweak_default
+
+        if block_given?
+          yield new_row
+        else
+          result << new_row
+        end
+      end
+      stmt.close
+
+      result
+    end
+
+    private
+
+      # Compares two version strings
+      def version_compare(v1, v2)
+        v1 = v1.split(".").map { |i| i.to_i }
+        v2 = v2.split(".").map { |i| i.to_i }
+        parts = [v1.length, v2.length].max
+        v1.push 0 while v1.length < parts
+        v2.push 0 while v2.length < parts
+        v1.zip(v2).each do |a,b|
+          return -1 if a < b
+          return  1 if a > b
+        end
+        return 0
+      end
+
+      # Since SQLite 3.3.8, the table_info pragma has returned the default
+      # value of the row as a quoted SQL value. This method essentially
+      # unquotes those values.
+      def tweak_default(hash)
+        case hash["dflt_value"]
+        when /^null$/i
+          hash["dflt_value"] = nil
+        when /^'(.*)'$/m
+          hash["dflt_value"] = $1.gsub(/''/, "'")
+        when /^"(.*)"$/m
+          hash["dflt_value"] = $1.gsub(/""/, '"')
+        end
+      end
+  end
+
+end

data/lib/sqlite3/resultset.rb

@@ -0,0 +1,158 @@
+module SQLite3
+
+  # The ResultSet object encapsulates the enumerability of a query's output.
+  # It is a simple cursor over the data that the query returns. It will
+  # very rarely (if ever) be instantiated directly. Instead, clients should
+  # obtain a ResultSet instance via Statement#execute.
+  class ResultSet
+    include Enumerable
+
+    class ArrayWithTypes < Array # :nodoc:
+      attr_accessor :types
+    end
+
+    class ArrayWithTypesAndFields < Array # :nodoc:
+      attr_writer :types
+      attr_writer :fields
+
+      def types
+        @types
+      end
+
+      def fields
+        @fields
+      end
+    end
+
+    # The class of which we return an object in case we want a Hash as
+    # result.
+    class HashWithTypesAndFields < Hash # :nodoc:
+      attr_writer :types
+      attr_writer :fields
+
+      def types
+        @types
+      end
+
+      def fields
+        @fields
+      end
+
+      def [] key
+        key = fields[key] if key.is_a? Numeric
+        super key
+      end
+    end
+
+    # Create a new ResultSet attached to the given database, using the
+    # given sql text.
+    def initialize db, stmt
+      @db   = db
+      @stmt = stmt
+    end
+
+    # Reset the cursor, so that a result set which has reached end-of-file
+    # can be rewound and reiterated.
+    def reset( *bind_params )
+      must_be_open!
+      @stmt.reset!
+      @stmt.bind_params( *bind_params )
+      @eof = false
+    end
+
+    # Query whether the cursor has reached the end of the result set or not.
+    def eof?
+      @stmt.done?
+    end
+
+    # Obtain the next row from the cursor. If there are no more rows to be
+    # had, this will return +nil+. If type translation is active on the
+    # corresponding database, the values in the row will be translated
+    # according to their types.
+    #
+    # The returned value will be an array, unless Database#results_as_hash has
+    # been set to +true+, in which case the returned value will be a hash.
+    #
+    # For arrays, the column names are accessible via the +fields+ property,
+    # and the column types are accessible via the +types+ property.
+    #
+    # For hashes, the column names are the keys of the hash, and the column
+    # types are accessible via the +types+ property.
+    def next
+      must_be_open!
+      if @db.results_as_hash
+        return next_hash
+      end
+
+      row = @stmt.step
+      return nil if @stmt.done?
+      row = ArrayWithTypesAndFields.new(row)
+      row.fields = @stmt.columns
+      row.types = @stmt.types
+      row
+    end
+
+    # Required by the Enumerable mixin. Provides an internal iterator over the
+    # rows of the result set.
+    def each
+      must_be_open!
+      while node = self.next
+        yield node
+      end
+    end
+
+    # Provides an internal iterator over the rows of the result set where
+    # each row is yielded as a hash.
+    def each_hash
+      while node = next_hash
+        yield node
+      end
+    end
+
+    # Closes the statement that spawned this result set.
+    # <em>Use with caution!</em> Closing a result set will automatically
+    # close any other result sets that were spawned from the same statement.
+    def close
+      @stmt.close
+    end
+
+    # Queries whether the underlying statement has been closed or not.
+    def closed?
+      @stmt.closed?
+    end
+
+    # Returns the types of the columns returned by this result set.
+    def types
+      must_be_open!
+      @stmt.types
+    end
+
+    # Returns the names of the columns returned by this result set.
+    def columns
+      must_be_open!
+      @stmt.columns
+    end
+
+    # Return the next row as a hash
+    def next_hash
+      must_be_open!
+      row = @stmt.step
+      return nil if @stmt.done?
+
+      # FIXME: this can be switched to a regular hash in 2.0
+      row = HashWithTypesAndFields[*@stmt.columns.zip(row).flatten]
+
+      # FIXME: these methods are deprecated for version 2.0, so we can remove
+      # this code in 2.0
+      row.fields = @stmt.columns
+      row.types = @stmt.types
+      row
+    end
+
+    private
+
+    def must_be_open!
+      raise Exception, "#{self.class} is closed!" if closed?
+    end
+  end
+end