amalgalite 0.1.0

data/lib/amalgalite/table.rb

@@ -0,0 +1,34 @@
+#--
+# 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 table 
+  #
+  class Table
+
+    # the table name
+    attr_reader   :name
+
+    # the original sql that was used to create this table
+    attr_reader   :sql
+
+    # an array of Index objects holding the meta informationa about the indexes
+    # on this table
+    attr_accessor :indexes
+
+    # an array of Column objects holding the meta information about the columns
+    # in this table
+    attr_accessor :columns
+
+    def initialize( name, sql ) 
+      @name    = name
+      @sql     = sql
+      @indexes = []
+      @columns = []
+    end
+  end
+end
+

data/lib/amalgalite/taps/console.rb

@@ -0,0 +1,27 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'amalgalite/taps/io'
+
+module Amalgalite::Taps
+  #
+  # Class provide an IO tap that can write to $stdout
+  #
+  class Stdout < ::Amalgalite::Taps::IO
+    def initialize
+      super( $stdout )
+    end
+  end
+
+  #
+  # This class provide an IO tap that can write to $stderr
+  #
+  class Stderr < ::Amalgalite::Taps::IO
+    def initialize
+      super( $stderr )
+    end
+  end
+
+end

data/lib/amalgalite/taps/io.rb

@@ -0,0 +1,71 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'amalgalite/profile_tap'
+require 'stringio'
+
+module Amalgalite
+  module Taps
+    #
+    # An IOTap is an easy way to send all top information to andy IO based
+    # object.  Both profile and trace tap information can be captured
+    # This means you can send the events to STDOUT with:
+    #
+    #   db.profile_tap = db.trace_tap  = Amalgalite::Taps::Stdout.new
+    #
+    #
+    class IO
+
+      attr_reader :profile_tap
+      attr_reader :io
+
+      def initialize( io )
+        @io = io
+        @profile_tap = ProfileTap.new( self, 'output_profile_event' )
+      end
+
+      def trace( msg )
+        io.puts msg 
+      end
+
+      # need a profile method, it routes through the profile tap which calls back
+      # to output_profile_event
+      def profile( msg, time )
+        @profile_tap.profile(msg, time)
+      end
+
+      def output_profile_event( msg, time )
+        io.puts "#{time} : #{msg}"
+      end
+
+      def dump_profile
+        samplers.each do |s|
+          io.puts s.to_s
+        end
+      end
+
+      def samplers
+        profile_tap.samplers
+      end
+    end
+
+    #
+    # This class provides an IO tap that writes to a StringIO.  The result is
+    # available via .to_s or .string.
+    #
+    class StringIO < ::Amalgalite::Taps::IO
+      def initialize
+        @stringio = ::StringIO.new
+        super( @stringio )
+      end
+
+      def to_s
+        @stringio.string
+      end
+      alias :string :to_s
+    end
+  end
+end
+

data/lib/amalgalite/trace_tap.rb

@@ -0,0 +1,35 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  #
+  # A TraceTap receives tracing information from SQLite3. It receives the SQL
+  # statement being executed as a +msg+ just before the statement first begins
+  # executing.
+  #
+  # A TraceTap is a wrapper around another object and a method.  The Tap object
+  # will receive the call to +trace+ and redirect that call to another object
+  # and method.
+  #
+  class TraceTap
+
+    attr_reader :delegate_obj
+    attr_reader :delegate_method
+
+    def initialize( wrapped_obj, send_to = 'trace' )
+      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
+    end
+
+    def trace( msg )
+      delegate_obj.send( delegate_method, msg )
+    end
+  end
+end
+

data/lib/amalgalite/type_map.rb

@@ -0,0 +1,60 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+module Amalgalite
+  ##
+  # TypeMap defines the protocol used between Ruby and SQLite for mapping
+  # binding types, used in prepared statements; and result types, used in
+  # returning objects from a query.
+  #
+  #
+  class TypeMap
+    ##
+    # :call-seq:
+    #   map.bind_type_of( obj ) -> DataType constant
+    #
+    # bind_type_of is called during the Statement#bind process to convert the
+    # bind parameter to the appropriate SQLite types.  This method MUST return
+    # one of the valid constants in the namespace 
+    # Amalgalite::SQLite::Constants::DataType
+    #
+    def bind_type_of( obj )
+      raise NotImplementedError, "bind_type_of has not been implemented"
+    end
+
+    ##
+    # :call-seq:
+    #   map.result_value_of( declared_type, value ) -> String
+    #
+    # result_value_of is called during the result processing of column values 
+    # to convert an SQLite database value into the appropriate Ruby class.  
+    #
+    # +declared_type+ is the string from the original CREATE TABLE statment 
+    # from which the column value originates.  It may also be nil if the origin
+    # column cannot be determined.
+    #
+    # +value+ is the SQLite value from the column as either a Ruby String,
+    # Integer, Float or Amalgalite::Blob. 
+    #
+    # result_value should return the value that is to be put into the result set
+    # for the query.  It may do nothing, or it may do massive amounts of
+    # conversion. 
+    def result_value_of( delcared_type, value )
+      raise NotImplementedError, "result_value_of has not been implemented"
+    end
+  end 
+
+  ##
+  # The TypeMaps module holds all typemaps that ship with Amagalite.  They
+  # currently are:
+  #
+  # DefaultMap:: does a 'best-guess' mapping to convert as many types as
+  #              possible to known ruby classes from known SQL types.
+  # StorageMap:: converts to a limited set of classes directly based 
+  #              upon the SQLite storage types
+  # TextMap::    Everything is Text ... everything everything everything
+  #
+  module TypeMaps
+  end
+end

data/lib/amalgalite/type_maps/default_map.rb

@@ -0,0 +1,153 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'amalgalite/type_map'
+require 'amalgalite3'
+require 'time'
+require 'date'
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalgalite::TypeMap that does its best to convert between Ruby classes
+  # and known SQL data types.  
+  #
+  # Upon instantiation, DefaultMap generates a conversion map to try to figure
+  # out the best way to convert between populate SQL 'types' and ruby classes
+  #
+  class DefaultMap
+    class << self
+      def methods_handling_sql_types # :nodoc:
+        @methods_handling_sql_types ||= {
+          'date'      => %w[ date ],
+          'datetime'  => %w[ datetime ],
+          'time'      => %w[ timestamp ],
+          'float'     => %w[ double real numeric decimal ],
+          'integer'   => %w[ integer tinyint smallint int int2 int4 int8 bigint serial bigserial ],
+          'string'    => %w[ text char varchar character ],
+          'boolean'   => %w[ bool boolean ],
+          'blob'      => %w[ binary blob ],
+        }
+      end
+
+      # say what method to call to convert an sql type to a ruby type
+      #
+      def sql_to_method( sql_type  ) # :nodoc:
+        unless @sql_to_method
+          @sql_to_method = {}
+          methods_handling_sql_types.each_pair do |method, sql_types|
+            sql_types.each { |t| @sql_to_method[t] = method }
+          end
+        end
+        return @sql_to_method[sql_type]
+      end
+    end
+
+    def initialize
+    end
+
+    ##
+    # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
+    # nothing can be found then default to TEXT.
+    #
+    def bind_type_of( obj )
+      case obj
+      when Float
+        ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+      when Fixnum
+        ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+      when NilClass
+        ::Amalgalite::SQLite3::Constants::DataType::NULL
+      when ::Amalgalite::Blob
+        ::Amalgalite::SQLite3::Constants::DataType::BLOB
+      else
+        ::Amalgalite::SQLite3::Constants::DataType::TEXT
+      end
+    end
+
+    ##
+    # Map the incoming value to an outgoing value.  For some incoming values,
+    # there will be no change, but for some (i.e. Dates and Times) there is some
+    # conversion
+    #
+    def result_value_of( declared_type, value )
+      case value
+      when Numeric
+        return value
+      when NilClass
+        return value
+      when String
+        if declared_type then
+          conversion_method = DefaultMap.sql_to_method( declared_type.downcase )
+          if conversion_method then
+            return send(conversion_method, value)  
+          else
+            raise ::Amalgalite::Error, "Unable to convert SQL type of #{declared_type} to a Ruby class"
+          end
+        else
+          # unable to do any other conversion, just return what we have.
+          return value
+        end
+      else 
+        raise ::Amalgalite::Error, "Unable to convert a class #{value.class.name} with value #{value.inspect}"
+      end
+    end
+
+    ##
+    # convert a string to a date
+    #
+    def date( str )
+      Date.parse( str )
+    end
+
+    ##
+    # convert a string to a datetime
+    #
+    def datetime( str )
+      DateTime.parse( str )
+    end
+
+    ##
+    # convert a string to a Time
+    #
+    def time( str )
+      Time.parse( str )
+    end
+
+    ##
+    # convert a string to a Float
+    #
+    def float( str )
+      Float( str )
+    end
+
+    ##
+    # convert an string to an Integer
+    #
+    def integer( str )
+      Float( str ).to_i
+    end
+
+    ##
+    # convert a string to a String, yes redundant I know.
+    # 
+    def string( str )
+      str
+    end
+
+    ##
+    # convert a string to true of false
+    #
+    def boolean( str )
+      ::Amalgalite::Boolean.to_bool( str )
+    end
+
+    ##
+    # convert a string to a blog
+    #
+    def blob( str )
+      raise NotImplementedError, "Blob type conversion is not implemented"
+    end
+  end
+end

data/lib/amalgalite/type_maps/storage_map.rb

@@ -0,0 +1,41 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'amalgalite/type_map'
+require 'amalgalite3'
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that has a one-to-one conversion between SQLite types
+  # and Ruby classes
+  #
+  class StorageMap < ::Amalgalite::TypeMap
+    ##
+    # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
+    # nothing can be found then default to TEXT.
+    #
+    def bind_type_of( obj )
+      case obj
+      when Float
+        ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+      when Fixnum
+        ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+      when NilClass
+        ::Amalgalite::SQLite3::Constants::DataType::NULL
+      when ::Amalgalite::Blob
+        ::Amalgalite::SQLite3::Constants::DataType::BLOB
+      else
+        ::Amalgalite::SQLite3::Constants::DataType::TEXT
+      end
+    end
+
+    ##
+    # Do no mapping, just return the value as it was retrieved from SQLite.
+    #
+    def result_value_of( delcared_type, value )
+      return value
+    end
+  end
+end

data/lib/amalgalite/type_maps/text_map.rb

@@ -0,0 +1,23 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+require 'amalgalite/type_map'
+require 'amalgalite3'
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that converts both bind parameters and result
+  # parameters to a String, no matter what.
+  #
+  class TextMap < ::Amalgalite::TypeMap
+    def bind_type_of( obj )
+      return ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+
+    def result_value_of( delcared_type, value )
+      return value.to_s
+    end
+  end
+end