amalgalite 1.6.0-x64-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,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.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,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