amalgalite 0.4.2-x86-mswin32-60

data/lib/amalgalite/index.rb

@@ -0,0 +1,43 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  #
+  # a class representing the meta information about an SQLite index
+  #
+  class Index
+    # the name of the index
+    attr_reader   :name
+
+    # the sql statement that created the index
+    attr_reader   :sql
+
+    # the table the index is for
+    attr_accessor :table
+
+    # the columns that make up this index, in index order
+    attr_accessor :columns
+
+    # sqlite sequence number of the index
+    attr_accessor :sequence_number
+
+    # is the index unique
+    attr_writer   :unique
+
+    def initialize( name, sql, table ) 
+      @name             = name
+      @sql              = sql
+      @table            = table
+      @columns          = []
+      @sequence_number  = nil
+      @unique           = nil
+    end
+
+    def unique?
+      return @unique
+    end
+  end
+end
+

data/lib/amalgalite/paths.rb

@@ -0,0 +1,70 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+module Amalgalite
+  #
+  # Paths contains helpful methods to determine paths of files inside the
+  # Amalgalite library
+  #
+  module Paths
+    #
+    # The root directory of the project is considered to be the parent directory
+    # of the 'lib' directory.
+    #   
+    # returns:: [String] The full expanded path of the parent directory of 'lib'
+    #           going up the path from the current file.  Trailing
+    #           File::SEPARATOR is guaranteed.
+    #   
+    def self.root_dir
+      unless @root_dir
+        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+        lib_index  = path_parts.rindex("lib")
+        @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      end 
+      return @root_dir
+    end 
+
+    # returns:: [String] The full expanded path of the +config+ directory
+    #           below _root_dir_.  All parameters passed in are joined onto the
+    #           result.  Trailing File::SEPARATOR is guaranteed if _args_ are
+    #           *not* present.
+    #   
+    def self.config_path(*args)
+      self.sub_path("config", *args)
+    end 
+
+    # returns:: [String] The full expanded path of the +data+ directory below
+    #           _root_dir_.  All parameters passed in are joined onto the 
+    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _*args_ are *not* present.
+    #   
+    def self.data_path(*args)
+      self.sub_path("data", *args)
+    end 
+
+    # returns:: [String] The full expanded path of the +lib+ directory below
+    #           _root_dir_.  All parameters passed in are joined onto the 
+    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _*args_ are *not* present.
+    #   
+    def self.lib_path(*args)
+      self.sub_path("lib", *args)
+    end 
+
+    # returns:: [String] The full expanded path of the +ext+ directory below
+    #           _root_dir_.  All parameters passed in are joined onto the 
+    #           result. Trailing File::SEPARATOR is guaranteed if 
+    #           _*args_ are *not* present.
+    #
+    def self.ext_path(*args)
+      self.sub_path("ext", *args)
+    end
+
+    def self.sub_path(sub,*args)
+      sp = ::File.join(root_dir, sub) + File::SEPARATOR
+      sp = ::File.join(sp, *args) if args
+    end
+  end
+end
+

data/lib/amalgalite/profile_tap.rb

@@ -0,0 +1,130 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  # 
+  # A ProfileSampler is a sampler of profile times.  It aggregates up profile
+  # events that happen for the same source.  It is based upon the RFuzz::Sampler 
+  # class from the rfuzz gem
+  #
+  class ProfileSampler
+    #
+    # create a new sampler with the given name
+    #
+    def initialize( name )
+      @name = name
+      reset!
+    end
+
+    ##
+    # reset the internal state so it may be used again
+    #
+    def reset!
+      @sum   = 0.0
+      @sumsq = 0.0
+      @n     = 0
+      @min   = 0.0
+      @max   = 0.0
+    end
+
+    ##
+    # add a sample to the calculations
+    #
+    def sample( value )
+      @sum   += value
+      @sumsq += (value * value)
+      if @n == 0 then
+        @min = @max = value
+      else
+        @min = value if value < @min
+        @max = value if value > @max
+      end
+      @n += 1
+    end
+
+    ##
+    # return the mean of the data 
+    #
+    def mean
+      @sum / @n
+    end
+
+    ##
+    # returns the standard deviation of the data
+    #
+    def stddev
+      begin
+        Math.sqrt( (@sumsq - ( @sum * @sum / @n)) / (@n-1) )
+      rescue Errno::EDOM
+        return 0.0
+      end
+    end
+
+    ##
+    # return all the values as an array
+    #
+    def to_a
+      [ @name, @sum, @sumsq, @n, mean, stddev, @min, @max ]
+    end
+
+    ##
+    # return all the values as a hash
+    #
+    def to_h
+      { 'name'    => @name,  'n' => @n,
+        'sum'     => @sum,   'sumsq'   => @sumsq, 'mean'    => mean,
+        'stddev'  => stddev, 'min'     => @min,   'max'     => @max }
+    end
+
+    ##
+    # return a string containing the sampler summary
+    #
+    def to_s
+      "[%s] => sum: %d, sumsq: %d, n: %d, mean: %0.6f, stddev: %0.6f, min: %d, max: %d" % to_a
+    end
+
+  end
+
+  #
+  # A Profile Tap recives +profile+ events from SQLite  which involve the number of
+  # nanoseconds in wall-clock time it took for a particular thing to happen. In
+  # general this +thing+ is an SQL statement.
+  #
+  # It has a well known +profile+ method which when invoked will write the event
+  # to a delegate object.
+  #
+  #
+  class ProfileTap
+
+    attr_reader :samplers
+
+    #
+    # Create a new ProfileTap object that wraps the given object and calls the
+    # method named in +send_to+ ever time a profile event happens.
+    #
+    def initialize( wrapped_obj, send_to = 'profile' )
+      unless wrapped_obj.respond_to?( send_to ) 
+        raise Amalgalite::Error, "#{wrapped_obj.class.name} does not respond to #{send_to.to_s} "
+      end
+
+      @delegate_obj    = wrapped_obj
+      @delegate_method = send_to
+      @samplers        = {}
+    end
+
+    #
+    # Record the profile information and send the delegate object the msg and
+    # time information.
+    #
+    def profile( msg, time )
+      unless sampler = @samplers[msg] 
+        msg = msg.gsub(/\s+/,' ')
+        sampler = @samplers[msg] = ProfileSampler.new( msg )
+      end
+      sampler.sample( time )
+      @delegate_obj.send( @delegate_method, msg, time )
+    end
+  end
+end

data/lib/amalgalite/requires.rb

@@ -0,0 +1,112 @@
+require 'amalgalite'
+
+module Amalgalite
+  #
+  # Requires encapsulates requiring itesm from the database
+  class Requires
+    class << self
+      def load_path_db_connections
+        @load_path_db_connections ||= {}
+      end
+      def load_path
+        @load_path ||= []
+      end
+
+      def db_connection_to( dbfile_name )
+        unless connection = load_path_db_connections[ dbfile_name ] 
+          puts "loading file #{dbfile_name}"
+          connection = ::Amalgalite::Database.new( dbfile_name )
+          load_path_db_connections[dbfile_name] = connection
+        end
+        return connection
+      end
+
+      def require( filename )
+        load_path.each { |lp| lp.require( filename ) }
+      end
+
+      #
+      # return the files in their dependency order for use for packing into a
+      # database
+      #
+      def require_order
+        @require_roder ||= %w[
+          amalgalite.rb
+          amalgalite/blob.rb
+          amalgalite/boolean.rb
+          amalgalite/column.rb
+          amalgalite/statement.rb
+          amalgalite/trace_tap.rb
+          amalgalite/profile_tap.rb
+          amalgalite/type_map.rb
+          amalgalite/type_maps/storage_map.rb
+          amalgalite/type_maps/text_map.rb
+          amalgalite/type_maps/default_map.rb
+          amalgalite/database.rb
+          amalgalite/index.rb
+          amalgalite/paths.rb
+          amalgalite/table.rb
+          amalgalite/view.rb
+          amalgalite/schema.rb
+          amalgalite/version.rb
+          amalgalite/sqlite3/version.rb
+          amalgalite/sqlite3/constants.rb
+          amalgalite/sqlite3.rb
+          amalgalite/taps/io.rb
+          amalgalite/taps/console.rb
+          amalgalite/taps.rb
+          amalgalite/core_ext/kernel/require.rb
+          amalgalite/requires.rb
+       ]
+     end
+    end
+
+    attr_reader :dbfile_name
+    attr_reader :table_name
+    attr_reader :filename_column
+    attr_reader :contents_column
+    attr_reader :db_connection
+
+    def initialize( opts = {} )
+      @dbfile_name     = opts[:dbfile_name]     || "lib.db"
+      @table_name      = opts[:table_name]      || "rubylibs"
+      @filename_column = opts[:filename_column] || "filename"
+      @contents_column = opts[:contents_column] || "contents"
+      @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}, #{contents_column} FROM #{table_name} WHERE #{filename_column} = ?"
+    end
+
+    #
+    # require 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
+    # $".
+    #
+    # if the file was required then true is returned, otherwise false 
+    #
+    def require( filename )
+      if $".include?( filename ) then
+        return false
+      else
+        begin
+          rows = db_connection.execute(sql, filename)
+          row = rows.first
+          eval( row[contents_column].to_s, TOPLEVEL_BINDING)
+          $" << row[filename_column]
+        rescue => e
+          raise LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
+        end
+      end
+      return true
+    end
+  end
+end
+require 'amalgalite/core_ext/kernel/require'

data/lib/amalgalite/schema.rb

@@ -0,0 +1,115 @@
+#--
+# 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_reader :tables
+    attr_reader :views
+    attr_reader :db
+
+    #
+    # Create a new instance of Schema
+    #
+    def initialize( db, catalog = 'main', schema = 'sqlite')
+      @db = db
+      @catalog = catalog
+      @schema = schema
+
+      load_schema!
+    end
+
+    #
+    # load the schema from the database
+    def load_schema!
+      load_tables
+      load_views
+    end
+
+    ##
+    # load all the tables
+    #
+    def load_tables
+      @tables = {}
+      @db.execute("SELECT tbl_name, sql FROM sqlite_master WHERE type = 'table'") do |table_info|
+        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
+      end
+
+      @tables
+    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( #{table.name} );") do |idx_list|
+        idx = indexes[idx_list['name']]
+        
+        idx.sequence_number = idx_list['seq']
+        idx.unique          = Boolean.to_bool( idx_list['unique'] )
+
+        @db.execute("PRAGMA index_info( #{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 = {}
+      @db.execute("PRAGMA table_info(#{table.name})") do |row|
+        col = Amalgalite::Column.new( "main", table.name, row['name'] )
+
+        col.default_value = row['dflt_value']
+        @db.api.table_column_metadata( "main", table.name, col.name ).each_pair do |key, value|
+          col.send("#{key}=", value)
+        end
+        col.schema = self
+        cols[col.name] = col
+      end
+      cols
+    end
+
+    ##
+    # load all the views for the database
+    #
+    def load_views
+      @views = {}
+      @db.execute("SELECT name, sql FROM sqlite_master WHERE type = 'view'") do |view_info|
+        view = Amalgalite::View.new( view_info['name'], view_info['sql'] )
+        view.schema = self
+        @views[view.name] = view
+      end
+      @views
+    end
+  end
+end