amalgalite 1.8.0-x64-mingw-ucrt

data/lib/amalgalite/requires.rb

@@ -0,0 +1,151 @@
+require 'amalgalite'
+require 'pathname'
+require 'zlib'
+require 'amalgalite/packer'
+
+module Amalgalite
+  #
+  # Requires encapsulates requiring items from the database
+  #
+  class Requires
+    class << self
+      def load_path_db_connections
+        @load_path_db_connections ||= {}
+      end
+
+      def load_path
+        @load_path ||= []
+      end
+
+      #
+      # Allocate a database connection to the given filename. For
+      # file databases, this means giving the same connection
+      # back if you ask for a connection to the same file.
+      # For in-memory databases, you get a new one each time.
+      #
+      def db_connection_to( dbfile_name )
+        if dbfile_name == ":memory:"
+          return ::Amalgalite::Database.new( dbfile_name )
+        else
+          unless connection = load_path_db_connections[ dbfile_name ] 
+            connection = ::Amalgalite::Database.new( dbfile_name )
+            load_path_db_connections[dbfile_name] = connection
+          end
+          return connection
+        end
+      end
+
+      #
+      # Setting a class level variable as a flag to know what we are currently
+      # in the middle of requiring
+      #
+      def requiring
+        @requiring ||= []
+      end
+
+      def require( filename )
+        if load_path.empty? then
+          raise ::LoadError, "Amalgalite load path is empty -- #{filename}"
+        elsif $LOADED_FEATURES.include?( filename ) then
+          return false
+        elsif Requires.requiring.include?( filename ) then 
+          return false
+        else
+          Requires.requiring << filename
+          load_path.each do |lp|
+            if lp.require( filename ) then
+              Requires.requiring.delete( filename )
+              return true
+            end
+          end
+          Requires.requiring.delete( filename )
+          raise ::LoadError, "amalgalite has no such file to load -- #{filename}"
+        end
+      end
+    end
+
+    attr_reader :dbfile_name
+    attr_reader :table_name
+    attr_reader :filename_column
+    attr_reader :contents_column
+    attr_reader :compressed_column
+    attr_reader :db_connection
+
+    def initialize( opts = {} )
+      @dbfile_name       = opts[:dbfile_name]       || Bootstrap::DEFAULT_DB
+      @table_name        = opts[:table_name]        || Bootstrap::DEFAULT_TABLE
+      @filename_column   = opts[:filename_column]   || Bootstrap::DEFAULT_FILENAME_COLUMN
+      @contents_column   = opts[:contents_column]   || Bootstrap::DEFAULT_CONTENTS_COLUMN
+      @compressed_column = opts[:compressed_column] || Bootstrap::DEFAULT_COMPRESSED_COLUMN
+      @db_connection   = Requires.db_connection_to( dbfile_name )
+      Requires.load_path << self
+    end
+
+    #
+    # return the sql to find the file contents for a file in this requires
+    #
+    def sql
+      @sql ||= "SELECT #{filename_column}, #{compressed_column}, #{contents_column} FROM #{table_name} WHERE #{filename_column} = ?"
+    end
+
+    #
+    # load a file in this database table.  This will check and see if the
+    # file is already required.  If it isn't it will select the contents
+    # associated with the row identified by the filename and eval those contents
+    # within the context of TOPLEVEL_BINDING.  The filename is then appended to
+    # $LOADED_FEATURES.
+    #
+    # if the file was required then true is returned, otherwise false 
+    #
+    def require( filename )
+      if $LOADED_FEATURES.include?( filename ) then
+        return false
+      else
+        begin
+          filename = filename.gsub(/\.rb\Z/,'')
+
+          contents = file_contents(filename)
+
+          if contents
+            eval( contents, TOPLEVEL_BINDING, filename )
+            $LOADED_FEATURES << filename
+            return true
+          else
+            return false
+          end
+        rescue => e
+          raise ::LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
+        end
+      end
+    end
+
+    # 
+    # Return the contents of the named file.
+    #
+    def file_contents(filename)
+      rows = db_connection.execute(sql, filename)
+      if rows.size > 0 then
+        row = rows.first
+
+        contents = row[contents_column].to_s
+        if row[compressed_column] then 
+          contents = ::Amalgalite::Packer.gunzip( contents )
+        end
+        
+        return contents
+      else
+        return nil
+      end
+    end
+
+    
+    #
+    # Import an SQL dump into the fake file system.
+    #
+    def import(sql)
+      db_connection.import(sql)
+    end
+
+  end
+end
+require 'amalgalite/core_ext/kernel/require'

data/lib/amalgalite/schema.rb

@@ -0,0 +1,225 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'amalgalite/table'
+require 'amalgalite/index'
+require 'amalgalite/column'
+require 'amalgalite/view'
+
+module Amalgalite
+  #
+  # An object view of the schema  in the SQLite database.  If the schema changes
+  # after this class is created, it has no knowledge of that.
+  #
+  class Schema
+
+    # The internal database that this schema is for. Most of the time this will
+    # be 'main' for the main database. For the temp tables, this will be 'temp'
+    # and for any attached databsae, this is the name of attached database.
+    attr_reader :catalog
+
+    # The schema_version at the time this schema was taken.
+    attr_reader :schema_version
+
+    # The Amalagalite::Database this schema is associated with.
+    attr_reader :db
+
+    #
+    # Create a new instance of Schema
+    #
+    def initialize( db, catalog = 'main', master_table = 'sqlite_master' )
+      @db             = db
+      @catalog        = catalog
+      @schema_version = nil
+      @tables         = {}
+      @views          = {}
+      @master_table   = master_table
+
+      if @master_table == 'sqlite_master' then
+        @temp_schema = ::Amalgalite::Schema.new( db, 'temp', 'sqlite_temp_master')
+      else
+        @temp_schema = nil
+      end
+      load_schema!
+    end
+
+    def catalog_master_table
+      "#{catalog}.#{@master_table}"
+    end
+
+    def temporary?
+      catalog == "temp"
+    end
+
+    def dirty?()
+      return true  if (@schema_version != self.current_version)
+      return false unless @temp_schema
+      return @temp_schema.dirty?
+    end
+
+    def current_version
+      @db.first_value_from("PRAGMA #{catalog}.schema_version")
+    end
+
+    #
+    # load the schema from the database
+    def load_schema!
+      load_tables
+      load_views
+      if @temp_schema then
+        @temp_schema.load_schema!
+      end
+      @schema_version = self.current_version
+      nil
+    end
+
+    ##
+    # return the tables, reloading if dirty.
+    # If there is a temp table and a normal table with the same name, then the
+    # temp table is the one that is returned in the hash.
+    def tables
+      load_schema! if dirty?
+      t = @tables
+      if @temp_schema then
+        t = @tables.merge( @temp_schema.tables )
+      end
+      return t
+    end
+
+    ##
+    # load all the tables
+    #
+    def load_tables
+      @tables = {}
+      @db.execute("SELECT tbl_name FROM #{catalog_master_table} WHERE type = 'table' AND name != 'sqlite_sequence'") do |table_info|
+        table = load_table( table_info['tbl_name'] )
+        table.indexes = load_indexes( table )
+        @tables[table.name] = table
+      end
+      return @tables
+    end
+
+    ##
+    # Load a single table
+    def load_table( table_name )
+      rows = @db.execute("SELECT tbl_name, sql FROM #{catalog_master_table} WHERE type = 'table' AND tbl_name = ?", table_name)
+      table_info = rows.first
+      table = nil
+      if table_info then
+        table = Amalgalite::Table.new( table_info['tbl_name'], table_info['sql'] )
+        table.schema = self
+        table.columns = load_columns( table )
+        table.indexes = load_indexes( table )
+        @tables[table.name] = table
+      end
+      return table
+    end
+
+    ##
+    # load all the indexes for a particular table
+    #
+    def load_indexes( table )
+      indexes = {}
+
+      @db.prepare("SELECT name, sql FROM #{catalog_master_table} WHERE type ='index' and tbl_name = $name") do |idx_stmt|
+        idx_stmt.execute( "$name" => table.name) do |idx_info|
+          indexes[idx_info['name']] = Amalgalite::Index.new( idx_info['name'], idx_info['sql'], table )
+        end
+      end
+
+      @db.execute("PRAGMA index_list( #{@db.quote(table.name)} );") do |idx_list|
+        idx = indexes[idx_list['name']]
+
+        # temporary indexes do not show up in the previous list
+        if idx.nil? then
+          idx = Amalgalite::Index.new( idx_list['name'], nil, table )
+          indexes[idx_list['name']] = idx
+        end
+
+        idx.sequence_number = idx_list['seq']
+        idx.unique          = Boolean.to_bool( idx_list['unique'] )
+
+        @db.execute("PRAGMA index_info( #{@db.quote(idx.name)} );") do |col_info|
+          idx.columns << table.columns[col_info['name']]
+        end
+      end
+      return indexes
+    end
+
+    ##
+    # load all the columns for a particular table
+    #
+    def load_columns( table )
+      cols = {}
+      idx = 0
+      @db.execute("PRAGMA #{catalog}.table_info(#{@db.quote(table.name)})") do |row|
+        col = Amalgalite::Column.new( catalog,  table.name, row['name'], row['cid'])
+
+        col.default_value       = row['dflt_value']
+
+        col.declared_data_type  = row['type']
+        col.not_null_constraint = row['notnull']
+        col.primary_key         = row['pk']
+
+        # need to remove leading and trailing ' or " from the default value
+        if col.default_value and col.default_value.kind_of?( String ) and ( col.default_value.length >= 2 ) then
+          fc = col.default_value[0].chr
+          lc = col.default_value[-1].chr
+          if fc == lc and ( fc == "'" || fc == '"' ) then
+            col.default_value = col.default_value[1..-2]
+          end
+        end
+
+        unless table.temporary? then
+          # get more exact information
+          @db.api.table_column_metadata( catalog, table.name, col.name ).each_pair do |key, value|
+            col.send("#{key}=", value)
+          end
+        end
+        col.schema = self
+        cols[col.name] = col
+        idx += 1
+      end
+      return cols
+    end
+
+    ##
+    # return the views, reloading if dirty
+    #
+    # If there is a temp view, and a regular view of the same name, then the
+    # temporary view is the one that is returned in the hash.
+    #
+    def views
+      reload_schema! if dirty?
+      v = @views
+      if @temp_schema then
+        v = @views.merge( @temp_schema.views )
+      end
+      return v
+    end
+
+    ##
+    # load a single view
+    #
+    def load_view( name )
+      rows = @db.execute("SELECT name, sql FROM #{catalog_master_table} WHERE type = 'view' AND name = ?", name )
+      view_info = rows.first
+      view = Amalgalite::View.new( view_info['name'], view_info['sql'] )
+      view.schema = self
+      return view
+    end
+
+    ##
+    # load all the views for the database
+    #
+    def load_views
+      @db.execute("SELECT name, sql FROM #{catalog_master_table} WHERE type = 'view'") do |view_info|
+        view = load_view( view_info['name'] )
+        @views[view.name] = view
+      end
+      return @views
+    end
+  end
+end

data/lib/amalgalite/sqlite3/constants.rb

@@ -0,0 +1,95 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+module Amalgalite::SQLite3
+  module Constants
+    module Helpers
+      #
+      # convert an integer value into the string representation of the associated
+      # constant. this is a helper method used by some of the other modules
+      #
+      def name_from_value( value )
+        unless defined? @const_map_from_value
+          @const_map_from_value = {}
+          constants.each do |const_name|
+            c_int = const_get( const_name )
+            @const_map_from_value[c_int] = const_name.to_s
+          end
+        end
+        return @const_map_from_value[ value ]
+      end
+
+      #
+      # convert a string into the constant value.  This is helper method used by
+      # some of the other modules
+      #
+      def value_from_name( name )
+        unless defined? @const_map_from_name
+          @const_map_from_name = {}
+          constants.each do |const_name|
+            c_int = const_get( const_name )
+            @const_map_from_name[ const_name.to_s ] = c_int
+          end
+        end
+        return @const_map_from_name[ name.upcase ]
+      end
+    end
+
+
+    ##
+    # DataType defines the namespace for all possible SQLite data types.
+    # 
+    module DataType
+      extend Helpers
+    end
+
+    ##
+    # Open defines the namespace for all possible flags to the Database.open
+    # method
+    #
+    module Open
+      extend Helpers
+    end
+
+    ##
+    # Status defines the namespace for all the possible status flags for
+    # Amalgalite::SQLite3::Status objects
+    #
+    module Status
+      extend Helpers
+    end
+
+    ##
+    # DBStatus defines the namespace for all the possible status codes for the
+    # Amalgalite::SQlite3::Database::Status objects.
+    #
+    module DBStatus
+      extend Helpers
+    end
+
+    ##
+    # ResultCode defines the namespace for all possible result codes from an
+    # SQLite API call.
+    #
+    module ResultCode
+      extend Helpers
+    end # end ResultCode
+
+    ##
+    # Config defines the namespace for all possible parameter for the
+    # sqlite config API.
+    #
+    module Config
+      extend Helpers
+    end
+
+    ##
+    # StatementStatus defines the namespace for all the possible status codes
+    # for the SQLite prepared statements
+    #
+    module StatementStatus
+      extend Helpers
+    end
+  end
+end

data/lib/amalgalite/sqlite3/database/function.rb

@@ -0,0 +1,48 @@
+module Amalgalite::SQLite3
+  class Database
+    ##
+    # A wrapper around a proc for use as an SQLite Ddatabase fuction
+    #
+    #   f = Function.new( 'md5', lambda { |x| Digest::MD5.hexdigest( x.to_s ) } )
+    #
+    class Function
+
+      # the name of the function, and how it will be called in SQL
+      attr_reader :name
+
+      # The unique signature of this function.  This is used to determin if the
+      # function is already registered or not
+      #
+      def self.signature( name, arity )
+        "#{name}/#{arity}"
+      end
+
+      # Initialize with the name and the Proc
+      #
+      def initialize( name, _proc )
+        @name = name
+        @function = _proc
+      end
+
+      # The unique signature of this function
+      #
+      def signature
+        @signature ||= Function.signature( name, arity )
+      end
+      alias :to_s :signature
+
+      # The arity of SQL function, -1 means it is takes a variable number of
+      # arguments.
+      #
+      def arity
+        @function.arity
+      end
+
+      # Invoke the proc 
+      #
+      def call( *args )
+        @function.call( *args )
+      end
+    end
+  end
+end

data/lib/amalgalite/sqlite3/database/status.rb

@@ -0,0 +1,68 @@
+require 'amalgalite/sqlite3/constants'
+module Amalgalite::SQLite3
+  class Database
+    # 
+    # A Stat represents a single Database Status code and its current highwater mark.
+    #
+    # Some stats may not have a current or a highwater value, in those cases
+    # the associated _has_current?_ or _has_highwater?_ method returns false and the
+    # _current_ or _highwater_ method also returns +nil+.
+    #
+    class Stat
+      attr_reader :name
+      attr_reader :code
+
+      def initialize( api_db, name )
+        @name      = name
+        @code      = ::Amalgalite::SQLite3::Constants::DBStatus.value_from_name( name )
+        @current   = nil
+        @highwater = nil
+        @api_db    = api_db 
+      end
+
+      def current
+        update!
+        return @current
+      end
+
+      def highwater
+        update!
+        return @highwater
+      end
+
+      #
+      # reset the given stat's highwater mark.  This will also populate the
+      # _@current_ and _@highwater_ instance variables
+      #
+      def reset!
+        update!( true )
+      end
+    end
+
+    #
+    # Top level Status object holding all the Stat objects indicating the DBStatus
+    # of the SQLite3 C library.
+    #
+    class DBStatus
+      ::Amalgalite::SQLite3::Constants::DBStatus.constants.each do |const_name|
+        method_name = const_name.downcase
+        module_eval( <<-code, __FILE__, __LINE__ )
+        def #{method_name}
+          @#{method_name} ||=  Amalgalite::SQLite3::Database::Stat.new( self.api_db, '#{method_name}' )   
+        end
+      code
+      end
+
+      attr_reader :api_db
+
+      def initialize( api_db )
+        @api_db = api_db
+      end
+    end
+
+    # return the DBstatus object for the sqlite database
+    def status
+      @status ||= DBStatus.new( self )
+    end
+  end
+end

data/lib/amalgalite/sqlite3/status.rb

@@ -0,0 +1,60 @@
+require 'amalgalite/sqlite3/constants'
+module Amalgalite::SQLite3
+
+  # 
+  # A Stat represents a single Status code and its current highwater mark.
+  #
+  # Some stats may not have a current or a highwater value, in those cases
+  # the associated _has_current?_ or _has_highwater?_ method returns false and the
+  # _current_ or _highwater_ method also returns +nil+.
+  #
+  class Stat
+    attr_reader :name
+    attr_reader :code
+
+    def initialize( name )
+      @name      = name
+      @code      = ::Amalgalite::SQLite3::Constants::Status.value_from_name( name )
+      @current   = nil
+      @highwater = nil
+    end
+
+    def current
+      update!
+      return @current
+    end
+
+    def highwater
+      update!
+      return @highwater
+    end
+
+    #
+    # reset the given stat's highwater mark.  This will also populate the
+    # _@current_ and _@highwater_ instance variables
+    #
+    def reset!
+      update!( true )
+    end
+  end
+
+  #
+  # Top level Status object holding all the Stat objects indicating the Status
+  # of the SQLite3 C library.
+  #
+  class Status
+    ::Amalgalite::SQLite3::Constants::Status.constants.each do |const_name|
+      method_name = const_name.downcase
+      module_eval( <<-code, __FILE__, __LINE__ )
+        def #{method_name}
+          @#{method_name} ||=  Amalgalite::SQLite3::Stat.new( '#{method_name}' )   
+        end
+      code
+    end
+  end
+
+  # return the status object for the sqlite database
+  def self.status
+    @status ||= Status.new
+  end
+end

data/lib/amalgalite/sqlite3/version.rb

@@ -0,0 +1,55 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+module Amalgalite 
+  module SQLite3
+    module Version
+      # Sqlite3 version number is equal to 
+      # MAJOR * 1_000_000 + MINOR * 1_000 + RELEASE
+
+      # major version number of the SQLite C library
+      MAJOR   = (to_i / 1_000_000).freeze
+      
+      # minor version number of the SQLite C library
+      MINOR   = ((to_i % 1_000_000) / 1_000).freeze
+      
+      # release version number of the SQLite C library
+      RELEASE = (to_i % 1_000).freeze
+   
+      #
+      # call-seq:
+      #   Amalgalite::SQLite3::Version.to_a -> [ MAJOR, MINOR, RELEASE ]
+      #
+      # Return the SQLite C library version number as an array of MAJOR, MINOR,
+      # RELEASE
+      # 
+      def self.to_a
+        [ MAJOR, MINOR, RELEASE ]
+      end
+
+      def self.compiled_matches_runtime?
+        self.compiled_version == self.runtime_version
+      end
+    end
+
+    # Version of SQLite that ships with Amalgalite
+    VERSION = Version.to_s.freeze
+  end
+end
+
+unless Amalgalite::SQLite3::Version.compiled_matches_runtime? then
+  warn <<eom
+You are seeing something odd.  The compiled version of SQLite that
+is embedded in this extension is for some reason, not being used.
+The version in the extension is #{Amalgalite::SQLite3::Version.compiled_version} and the version that
+as been loaded as a shared library is #{Amalgalite::SQLite3::Version.runtime_version}.  These versions
+should be the same, but they are not.
+
+One known issue is if you are using this libary in conjunction with
+Hitimes on Mac OS X.  You should make sure that "require 'amalgalite'"
+appears before "require 'hitimes'" in your ruby code.
+
+This is a non-trivial problem, and I am working on it.
+eom
+end

data/lib/amalgalite/sqlite3.rb

@@ -0,0 +1,6 @@
+require 'amalgalite/version'
+require 'amalgalite/sqlite3/version'
+require 'amalgalite/sqlite3/constants'
+require 'amalgalite/sqlite3/status'
+require 'amalgalite/sqlite3/database/status'
+require 'amalgalite/sqlite3/database/function'