rhodes-framework 1.0.0

data/res/sqlite3/driver/native/driver.rb

@@ -0,0 +1,257 @@
+require 'sqlite3/sqlite3_api'
+
+module SQLite3 ; module Driver ; module Native
+
+  class Driver
+
+    def initialize
+      @callback_data = Hash.new
+      @authorizer = Hash.new
+      @busy_handler = Hash.new
+      @trace = Hash.new
+    end
+
+    def complete?( sql, utf16=false )
+      API.send( utf16 ? :sqlite3_complete16 : :sqlite3_complete, sql ) != 0
+    end
+
+    def busy_handler( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+        result = API.sqlite3_busy_handler( db, API::Sqlite3_ruby_busy_handler, cb )
+        # Reference the Callback object so that 
+        # it is not deleted by the GC
+        @busy_handler[db] = cb
+      else
+        # Unreference the callback *after* having removed it
+        # from sqlite
+        result = API.sqlite3_busy_handler( db, nil, nil )
+        @busy_handler.delete(db)
+      end
+
+      result
+    end
+
+    def set_authorizer( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+        result = API.sqlite3_set_authorizer( db, API::Sqlite3_ruby_authorizer, cb )
+        @authorizer[db] = cb # see comments in busy_handler
+      else
+        result = API.sqlite3_set_authorizer( db, nil, nil )
+        @authorizer.delete(db) # see comments in busy_handler
+      end
+
+      result
+    end
+
+    def trace( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+        result = API.sqlite3_trace( db, API::Sqlite3_ruby_trace, cb )
+        @trace[db] = cb # see comments in busy_handler
+      else
+        result = API.sqlite3_trace( db, nil, nil )
+        @trace.delete(db) # see comments in busy_handler
+      end
+
+      result
+    end
+
+    def open( filename, utf16=false )
+      API.send( utf16 ? :sqlite3_open16 : :sqlite3_open, filename )
+    end
+
+    def errmsg( db, utf16=false )
+      API.send( utf16 ? :sqlite3_errmsg16 : :sqlite3_errmsg, db )
+    end
+
+    def prepare( db, sql, utf16=false )
+      API.send( ( utf16 ? :sqlite3_prepare16 : :sqlite3_prepare ),
+        db, sql )
+    end
+
+    def bind_text( stmt, index, value, utf16=false )
+      API.send( ( utf16 ? :sqlite3_bind_text16 : :sqlite3_bind_text ),
+        stmt, index, value.to_s )
+    end
+
+    def column_name( stmt, index, utf16=false )
+      API.send( ( utf16 ? :sqlite3_column_name16 : :sqlite3_column_name ),
+        stmt, index )
+    end
+
+    def column_decltype( stmt, index, utf16=false )
+      API.send(
+        ( utf16 ? :sqlite3_column_decltype16 : :sqlite3_column_decltype ),
+        stmt, index )
+    end
+
+    def column_text( stmt, index, utf16=false )
+      API.send( ( utf16 ? :sqlite3_column_text16 : :sqlite3_column_text ),
+        stmt, index )
+    end
+
+    def create_function( db, name, args, text, cookie, func, step, final )
+      if func || ( step && final )
+        cb = API::CallbackData.new
+        cb.proc = cb.proc2 = nil
+        cb.data = cookie
+      end
+
+      if func
+        cb.proc = func
+
+        func = API::Sqlite3_ruby_function_step
+        step = final = nil
+      elsif step && final
+        cb.proc = step
+        cb.proc2 = final
+
+        func = nil
+        step = API::Sqlite3_ruby_function_step
+        final = API::Sqlite3_ruby_function_final
+      end
+
+      result = API.sqlite3_create_function( db, name, args, text, cb, func, step, final )
+
+      # see comments in busy_handler
+      if cb
+        @callback_data[ name ] = cb
+      else
+        @callback_data.delete( name )
+      end
+
+      return result
+    end
+
+    def value_text( value, utf16=false )
+      method = case utf16
+        when nil, false then :sqlite3_value_text
+        when :le then :sqlite3_value_text16le
+        when :be then :sqlite3_value_text16be
+        else :sqlite3_value_text16
+      end
+
+      API.send( method, value )
+    end
+
+    def result_text( context, result, utf16=false )
+      method = case utf16
+        when nil, false then :sqlite3_result_text
+        when :le then :sqlite3_result_text16le
+        when :be then :sqlite3_result_text16be
+        else :sqlite3_result_text16
+      end
+
+      API.send( method, context, result.to_s )
+    end
+
+    def result_error( context, value, utf16=false )
+      API.send( ( utf16 ? :sqlite3_result_error16 : :sqlite3_result_error ),
+        context, value )
+    end
+
+    def libversion (*args) API.sqlite3_libversion( *args ) ; end
+    def close (*args) API.sqlite3_close( *args ) ; end
+    def last_insert_rowid (*args) API.sqlite3_last_insert_rowid( *args ) ; end
+    def changes (*args) API.sqlite3_changes( *args ) ; end
+    def total_changes (*args) API.sqlite3_total_changes( *args ) ; end
+    def interrupt (*args) API.sqlite3_interrupt( *args ) ; end
+    def busy_timeout (*args) API.sqlite3_busy_timeout( *args ) ; end
+    def errcode (*args) API.sqlite3_errcode( *args ) ; end
+    def bind_blob (*args) API.sqlite3_bind_blob( *args ) ; end
+    def bind_double (*args) API.sqlite3_bind_double( *args ) ; end
+    def bind_int (*args) API.sqlite3_bind_int( *args ) ; end
+    def bind_int64 (*args) API.sqlite3_bind_int64( *args ) ; end
+    def bind_null (*args) API.sqlite3_bind_null( *args ) ; end
+    def bind_parameter_count (*args) API.sqlite3_bind_parameter_count( *args ) ; end
+    def bind_parameter_name (*args) API.sqlite3_bind_parameter_name( *args ) ; end
+    def bind_parameter_index (*args) API.sqlite3_bind_parameter_index( *args ) ; end
+    def column_count (*args) API.sqlite3_column_count( *args ) ; end
+    def step (*args) API.sqlite3_step( *args ) ; end
+    def data_count (*args) API.sqlite3_data_count( *args ) ; end
+    def column_blob (*args) API.sqlite3_column_blob( *args ) ; end
+    def column_bytes (*args) API.sqlite3_column_bytes( *args ) ; end
+    def column_bytes16 (*args) API.sqlite3_column_bytes16( *args ) ; end
+    def column_double (*args) API.sqlite3_column_double( *args ) ; end
+    def column_int (*args) API.sqlite3_column_int( *args ) ; end
+    def column_int64 (*args) API.sqlite3_column_int64( *args ) ; end
+    def column_type (*args) API.sqlite3_column_type( *args ) ; end
+    def finalize (*args) API.sqlite3_finalize( *args ) ; end
+    def reset (*args) API.sqlite3_reset( *args ) ; end
+    def aggregate_count (*args) API.sqlite3_aggregate_count( *args ) ; end
+    def value_blob (*args) API.sqlite3_value_blob( *args ) ; end
+    def value_bytes (*args) API.sqlite3_value_bytes( *args ) ; end
+    def value_bytes16 (*args) API.sqlite3_value_bytes16( *args ) ; end
+    def value_double (*args) API.sqlite3_value_double( *args ) ; end
+    def value_int (*args) API.sqlite3_value_int( *args ) ; end
+    def value_int64 (*args) API.sqlite3_value_int64( *args ) ; end
+    def value_type (*args) API.sqlite3_value_type( *args ) ; end
+    def result_blob (*args) API.sqlite3_result_blob( *args ) ; end
+    def result_double (*args) API.sqlite3_result_double( *args ) ; end
+    def result_int (*args) API.sqlite3_result_int( *args ) ; end
+    def result_int64 (*args) API.sqlite3_result_int64( *args ) ; end
+    def result_null (*args) API.sqlite3_result_null( *args ) ; end
+    def result_value (*args) API.sqlite3_result_value( *args ) ; end
+    def aggregate_context (*args) API.sqlite3_aggregate_context( *args ) ; end
+        
+=begin
+    def self.api_delegate( name )
+      eval "def #{name} (*args) API.sqlite3_#{name}( *args ) ; end"
+    end
+
+    api_delegate :libversion
+    api_delegate :close
+    api_delegate :last_insert_rowid
+    api_delegate :changes
+    api_delegate :total_changes
+    api_delegate :interrupt
+    api_delegate :busy_timeout
+    api_delegate :errcode
+    api_delegate :bind_blob
+    api_delegate :bind_double
+    api_delegate :bind_int
+    api_delegate :bind_int64
+    api_delegate :bind_null
+    api_delegate :bind_parameter_count
+    api_delegate :bind_parameter_name
+    api_delegate :bind_parameter_index
+    api_delegate :column_count
+    api_delegate :step
+    api_delegate :data_count
+    api_delegate :column_blob
+    api_delegate :column_bytes
+    api_delegate :column_bytes16
+    api_delegate :column_double
+    api_delegate :column_int
+    api_delegate :column_int64
+    api_delegate :column_type
+    api_delegate :finalize
+    api_delegate :reset
+    api_delegate :aggregate_count
+    api_delegate :value_blob
+    api_delegate :value_bytes
+    api_delegate :value_bytes16
+    api_delegate :value_double
+    api_delegate :value_int
+    api_delegate :value_int64
+    api_delegate :value_type
+    api_delegate :result_blob
+    api_delegate :result_double
+    api_delegate :result_int
+    api_delegate :result_int64
+    api_delegate :result_null
+    api_delegate :result_value
+    api_delegate :aggregate_context
+=end
+
+  end
+
+end ; end ; end

data/res/sqlite3/errors.rb

@@ -0,0 +1,68 @@
+require 'sqlite3/constants'
+
+module SQLite3
+
+  class Exception < ::StandardError
+    @code = 0
+
+    # The numeric error code that this exception represents.
+    def self.code
+      @code
+    end
+
+    # A convenience for accessing the error code for this exception.
+    def code
+      self.class.code
+    end
+  end
+
+  class SQLException < Exception; end
+  class InternalException < Exception; end
+  class PermissionException < Exception; end
+  class AbortException < Exception; end
+  class BusyException < Exception; end
+  class LockedException < Exception; end
+  class MemoryException < Exception; end
+  class ReadOnlyException < Exception; end
+  class InterruptException < Exception; end
+  class IOException < Exception; end
+  class CorruptException < Exception; end
+  class NotFoundException < Exception; end
+  class FullException < Exception; end
+  class CantOpenException < Exception; end
+  class ProtocolException < Exception; end
+  class EmptyException < Exception; end
+  class SchemaChangedException < Exception; end
+  class TooBigException < Exception; end
+  class ConstraintException < Exception; end
+  class MismatchException < Exception; end
+  class MisuseException < Exception; end
+  class UnsupportedException < Exception; end
+  class AuthorizationException < Exception; end
+  class FormatException < Exception; end
+  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 }
+
+  module Error
+    def check( result, db=nil, msg=nil )
+      unless result == Constants::ErrorCode::OK
+        msg = ( msg ? msg + ": " : "" ) + db.errmsg if db
+        raise(( EXCEPTIONS[result] || SQLite3::Exception ), msg)
+      end
+    end
+    module_function :check
+  end
+
+end

data/res/sqlite3/pragmas.rb

@@ -0,0 +1,271 @@
+require 'sqlite3/errors'
+
+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
+
+    def table_info( table, &block ) # :yields: row
+      columns, *rows = execute2("PRAGMA table_info(#{table})")
+
+      needs_tweak_default = version_compare(driver.libversion, "3.3.7") > 0
+
+      result = [] unless block_given?
+      rows.each do |row|
+        new_row = {}
+        columns.each_with_index do |name, index|
+          new_row[name] = row[index]
+        end
+
+        tweak_default(new_row) if needs_tweak_default
+
+        if block_given?
+          yield new_row
+        else
+          result << new_row
+        end
+      end
+
+      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 /^'(.*)'$/
+          hash["dflt_value"] = $1.gsub(/''/, "'")
+        when /^"(.*)"$/
+          hash["dflt_value"] = $1.gsub(/""/, '"')
+        end
+      end
+  end
+
+end