amalgalite 0.10.1-x86-mingw32

data/lib/amalgalite/progress_handler.rb

@@ -0,0 +1,21 @@
+module Amalgalite
+  ##
+  # A base class for use in creating your own progress handler classes
+  #
+  class ProgressHandler
+    def to_proc
+      self
+    end
+
+    # the arity of the call method
+    def arity() 0 ; end
+
+    ##
+    # Override this method, returning +false+ if the SQLite should act as if
+    # +interrupt!+ had been invoked.
+    # 
+    def call
+      raise NotImplementedError, "The progress handler call() method must be implemented"
+    end
+  end
+end

data/lib/amalgalite/requires.rb

@@ -0,0 +1,120 @@
+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
+      #
+      def db_connection_to( dbfile_name )
+        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
+
+      # 
+      # 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/,'')
+          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
+
+            eval( contents, TOPLEVEL_BINDING, row[filename_column] )
+            $LOADED_FEATURES << row[filename_column]
+            return true
+          else
+            return false
+          end
+        rescue => e
+          raise ::LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
+        end
+      end
+    end
+  end
+end
+require 'amalgalite/core_ext/kernel/require'

data/lib/amalgalite/schema.rb

@@ -0,0 +1,191 @@
+#--
+# 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
+
+    attr_reader :catalog
+    attr_reader :schema 
+    attr_writer :dirty
+    attr_reader :db
+
+    #
+    # Create a new instance of Schema
+    #
+    def initialize( db, catalog = 'main', schema = 'sqlite')
+      @db = db
+      @catalog = catalog
+      @schema = schema
+      @tables = {}
+      @views  = {}
+      @dirty  = true
+      load_schema!
+    end
+
+    def dirty?() @dirty; end
+    def dirty!() @dirty = true; end
+
+    #
+    # load the schema from the database
+    def load_schema!
+      load_tables
+      load_views
+      @dirty = false
+    end
+
+    ##
+    # return the tables, reloading if dirty
+    def tables
+      load_schema! if dirty?
+      return @tables
+    end
+
+    ##
+    # load all the tables
+    #
+    def load_tables
+      @tables = {}
+      @db.execute("SELECT tbl_name FROM sqlite_master 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 sqlite_master 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.columns = load_columns( table )
+        table.schema = self
+        table.indexes = load_indexes( table )
+        @tables[table.name] = table 
+      else
+        # might be a temporary table
+        table = Amalgalite::Table.new( table_name, nil )
+        cols = load_columns( table )
+        if cols.size > 0 then
+          table.columns = cols
+          table.schema = self
+          table.indexes = load_indexes( table )
+          @tables[table.name] = table
+        end
+      end
+      return table
+    end
+
+    ## 
+    # load all the indexes for a particular table
+    #
+    def load_indexes( table )
+      indexes = {}
+
+      @db.prepare("SELECT name, sql FROM sqlite_master 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 table_info(#{@db.quote(table.name)})") do |row|
+        col = Amalgalite::Column.new( "main", 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( "main", 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
+    #
+    def views
+      reload_schema! if dirty?
+      return @views
+    end
+
+    ##
+    # load a single view
+    #
+    def load_view( name )
+      rows = @db.execute("SELECT name, sql FROM sqlite_master 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 sqlite_master 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.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'

data/lib/amalgalite/sqlite3/constants.rb

@@ -0,0 +1,80 @@
+#--
+# 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
+          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 ] = 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
+    end
+    DataType.freeze
+
+    ##
+    # Open defines the namespace for all possible flags to the Database.open
+    # method
+    #
+    module Open
+    end
+    Open.freeze
+
+    ##
+    # 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
+  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