amalgalite 1.8.0-x64-mingw-ucrt

data/lib/amalgalite/function.rb

@@ -0,0 +1,61 @@
+require 'amalgalite/sqlite3/database/function'
+module Amalgalite
+  #
+  # A Base class to inherit from for creating your own SQL scalar functions
+  # in ruby.
+  #
+  # These are SQL functions similar to _abs(X)_, _length(X)_, _random()_.  Items
+  # that take parameters and return value.  They have no state between
+  # calls. Built in SQLite scalar functions are :
+  #
+  # * http://www.sqlite.org/lang_corefunc.html
+  # * http://www.sqlite.org/lang_datefunc.html
+  #
+  # Functions defined in Amalgalite databases conform to the Proc interface.
+  # Everything that is defined in an Amalgalite database using +define_function+
+  # has its +to_proc+ method called.  As a result, any Function must also
+  # conform to the +to_proc+ protocol.
+  #
+  # If you choose to use Function as a parent class of your SQL scalar function
+  # implementation you should only have implement +call+ with the appropriate
+  # _arity_.
+  #
+  # For instance to implement a _sha1(X)_ SQL function you could implement it as
+  #
+  #   class SQLSha1 < ::Amalgalite::Function
+  #     def initialize
+  #       super( 'md5', 1 )
+  #     end
+  #     def call( s )
+  #       ::Digest::MD5.hexdigest( s.to_s )
+  #     end
+  #   end
+  #
+  class Function
+    # The name of the SQL function
+    attr_accessor :name
+
+    # The arity of the SQL function
+    attr_accessor :arity
+
+    # Initialize the function with a name and arity
+    def initialize( name, arity )
+      @name = name
+      @arity = arity
+    end
+
+    # All SQL functions defined foloow the +to_proc+ protocol
+    def to_proc
+      self
+    end
+
+    # <b>Do Not Override</b>
+    #
+    # The function signature for use by the Amaglaite datase in tracking
+    # function definition and removal.
+    #
+    def signature
+      @signature ||= ::Amalgalite::SQLite3::Database::Function.signature( self.name, self.arity )
+    end
+  end
+end

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/memory_database.rb

@@ -0,0 +1,15 @@
+require 'amalgalite/database'
+module Amalgalite
+  #
+  # The encapsulation of a connection to an SQLite3 in-memory database.  
+  #
+  # Open an in-memory database:
+  #
+  #   db = Amalgalite::MemoryDatabase.new
+  #
+  class MemoryDatabase < Database
+    def initialize
+      super( ":memory:" )
+    end
+  end
+end

data/lib/amalgalite/packer.rb

@@ -0,0 +1,231 @@
+require 'optparse'
+require 'ostruct'
+require 'pathname'
+require 'zlib'
+
+require 'amalgalite'
+module Amalgalite
+  #
+  # Pack items into an amalgalite database.  
+  #
+  class Packer
+    attr_reader :packing_list
+    attr_reader :dbfile
+    attr_reader :options
+
+    class << self
+      def default_options
+        {
+          :table_name        => Requires::Bootstrap::DEFAULT_TABLE,
+          :filename_column   => Requires::Bootstrap::DEFAULT_FILENAME_COLUMN,
+          :contents_column   => Requires::Bootstrap::DEFAULT_CONTENTS_COLUMN,
+          :compressed_column => Requires::Bootstrap::DEFAULT_COMPRESSED_COLUMN,
+          :strip_prefix      => Dir.pwd,
+          :compressed        => false,
+          :verbose           => false,
+        }
+      end
+
+      #
+      # compress data
+      #
+      def gzip( data )
+        zipped = StringIO.new
+        Zlib::GzipWriter.wrap( zipped ) do |io|
+          io.write( data )
+        end
+        return zipped.string
+      end
+
+      # 
+      # uncompress gzip data
+      #
+      def gunzip( data )
+        data = StringIO.new( data )
+        Zlib::GzipReader.new( data ).read
+      end
+
+
+      #
+      # return the files in their dependency order for use for packing into a
+      # database
+      #
+      def amalgalite_require_order
+        @require_order ||= %w[
+          amalgalite.rb
+          amalgalite/sqlite3/database/function.rb
+          amalgalite/aggregate.rb
+          amalgalite/blob.rb
+          amalgalite/boolean.rb
+          amalgalite/busy_timeout.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/function.rb
+          amalgalite/progress_handler.rb
+          amalgalite/csv_table_importer.rb
+          amalgalite/database.rb
+          amalgalite/index.rb
+          amalgalite/memory_database.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/status.rb
+          amalgalite/sqlite3/database/status.rb
+          amalgalite/sqlite3.rb
+          amalgalite/taps/io.rb
+          amalgalite/taps/console.rb
+          amalgalite/taps.rb
+          amalgalite/packer.rb
+          amalgalite/core_ext/kernel/require.rb
+          amalgalite/requires.rb
+        ]
+      end
+    end
+
+    # 
+    # Create a new packer instance with the list of items to pack and all the
+    # options
+    #
+    def initialize(  options = {} )
+      @options = Packer.default_options.merge( options )
+      @dbfile  = @options[:dbfile] || Requires::Bootstrap::DEFAULT_DB
+    end
+
+    # 
+    # The SQL to create the table for storing ruby code
+    #
+    def create_table_sql
+      <<-create
+      CREATE TABLE #{options[:table_name]} (
+      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+      #{options[:filename_column]}   TEXT UNIQUE,
+      #{options[:compressed_column]} BOOLEAN,
+      #{options[:contents_column]}   BLOB
+      );
+      create
+    end
+
+    #
+    # Make sure that the dbfile exists and has the appropriate schema.  
+    #
+    def check_db( db )
+      if db.schema.tables[ options[:table_name] ] and options[:drop_table] then
+        STDERR.puts "Dropping table #{options[:table_name]}" if options[:verbose]
+        db.execute("DROP TABLE #{options[:table_name]}")
+        db.reload_schema!
+      end
+
+      unless db.schema.tables[ options[:table_name] ]
+        db.execute( create_table_sql )
+        db.reload_schema!
+      end
+
+    end
+
+
+    #
+    # Stores all the .rb files in the list into the given database.  The prefix
+    # is the file system path to remove from the front of the path on each file
+    #
+    # manifest is an array of OpenStructs.  
+    #
+    def pack_files( manifest )
+      db = Amalgalite::Database.new( dbfile )
+      check_db( db )
+      max_width = manifest.collect{ |m| m.require_path.length }.sort.last
+      contents_column = db.schema.tables[ options[:table_name] ].columns[ options[:contents_column] ]
+      db.transaction do |trans|
+        manifest.each do |file_info|
+          msg  = "  -> #{file_info.require_path.ljust( max_width )} : "
+          begin
+            if options[:merge] then
+              trans.execute( "DELETE FROM #{options[:table_name]} WHERE #{options[:filename_column]} = ?", file_info.require_path )
+            end
+
+            trans.prepare("INSERT INTO #{options[:table_name]}(#{options[:filename_column]}, #{options[:compressed_column]}, #{options[:contents_column]}) VALUES( $filename, $compressed, $contents)") do |stmt|
+              contents = IO.readlines( file_info.file_path )
+              if options[:self] then
+                contents.each { |l| l.gsub!( /^(\s*require .*)$/m, "# commented out by #{self.class.name} \\1") }
+              end
+              contents = contents.join
+
+              if options[:compressed] then
+                contents = Packer.gzip( contents )
+              end
+              content_io = StringIO.new( contents )
+              stmt.execute( "$filename"   => file_info.require_path,
+                            "$contents"   => Amalgalite::Blob.new( :io => content_io,
+                                                                   :column => contents_column ),
+                            "$compressed" => options[:compressed] )
+              STDERR.puts "#{msg} stored #{file_info.file_path}" if options[:verbose]
+            end
+          rescue => e
+            STDERR.puts "#{msg} error #{e}"
+          end
+        end
+      end
+    end
+
+    #
+    # given a file, see if it can be found in the ruby load path, if so, return that
+    # full path
+    #
+    def full_path_of( rb_file )
+      $LOAD_PATH.each do |load_path|
+        guess = File.expand_path( File.join( load_path, rb_file ) )
+        return guess if File.exist?( guess )
+      end
+      return nil
+    end
+
+    # 
+    # Make the manifest for packing
+    #
+    def make_manifest( file_list )
+      manifest = []
+      prefix_path = ::Pathname.new( options[:strip_prefix] )
+      file_list.each do |f|
+        file_path = ::Pathname.new( File.expand_path( f ) )
+        m = ::OpenStruct.new
+        # if it is a directory then grab all the .rb files from it
+        if File.directory?( file_path ) then
+          manifest.concat( make_manifest( Dir.glob( File.join( f, "**", "*.rb" ) ) ) )
+          next
+        elsif File.readable?( file_path ) then
+          m.require_path = file_path.relative_path_from( prefix_path )
+          m.file_path    = file_path.realpath.to_s
+        elsif lp = full_path_of( f ) then
+          m.require_path = f
+          m.file_path    = lp
+        else
+          STDERR.puts "Unable to add #{f} to the manifest, cannot find the file on disk"
+          next
+        end
+        # Make sure that we can handle files without the .rb extension
+        # if we have to. This means bin/foo works as a require path
+        # without requiring bin/foo to actually be bin/foo.rb
+        m.require_path = m.require_path.to_s.sub(/\.rb\Z/,'')
+        manifest << m
+      end
+      return manifest
+    end
+
+    #
+    # Given a list of files pack them into the associated database and table.
+    #
+    def pack( file_list )
+      manifest = make_manifest( file_list )
+      pack_files( manifest )
+    end
+  end
+end

data/lib/amalgalite/paths.rb

@@ -0,0 +1,80 @@
+#--
+# 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
+      @root_dir ||= (
+        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+        lib_index  = path_parts.rindex("lib")
+        path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      )
+      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
+
+    # returns:: [String] The full expanded path of the +spec+ 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.spec_path(*args)
+      self.sub_path("spec", *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,131 @@
+#--
+# 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
+        return 0.0 if ( 1 == @n )
+        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" % self.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 )
+      msg = msg.gsub(/\s+/,' ')
+      unless sampler = @samplers[msg]
+        sampler = @samplers[msg] = ProfileSampler.new( msg )
+      end
+      sampler.sample( time )
+      @delegate_obj.send( @delegate_method, msg, time )
+    end
+  end
+end

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