ydbi 0.5.0

data/lib/dbi/utils/date.rb

@@ -0,0 +1,59 @@
+module DBI
+    #
+    # Represents a Date.
+    #
+    # DEPRECATED: Please use a regular Date or DateTime object.
+    #
+    class Date
+        attr_accessor :year, :month, :day
+
+        # Aliases
+        alias :mon :month
+        alias :mon= :month=
+        alias :mday :day
+        alias :mday= :day=
+
+        # Returns a new Time object based on the year, month and day or, if a
+        # Time object was passed to the constructor, returns that object.
+        def to_time
+            @original_time || ::Time.local(@year, @month, @day, 0, 0, 0)
+        end
+
+        # Returns a new Date object based on the year, month and day or, if a
+        # Date object was passed to the constructor, returns that object.
+        def to_date
+            @original_date || ::Date.new(@year, @month, @day)
+        end
+
+        # Returns a DBI::Date object as a string in YYYY-MM-DD format.
+        def to_s
+            sprintf("%04d-%02d-%02d", @year, @month, @day)
+        end
+
+        private 
+
+        # DBI::Date.new(year = 0, month = 0, day = 0)
+        # DBI::Date.new(Date)
+        # DBI::Date.new(Time)
+        #
+        # Creates and returns a new DBI::Date object.  It's similar to the
+        # standard Date class' constructor except that it also accepts a
+        # Date or Time object.
+        def initialize(year=0, month=0, day=0)
+            case year
+            when ::Date
+                @year, @month, @day = year.year, year.month, year.day 
+                @original_date = year
+            when ::Time
+                @year, @month, @day = year.year, year.month, year.day 
+                @original_time = year
+            else
+                @year, @month, @day = year, month, day
+            end
+        end
+
+        public
+
+        deprecate :initialize, :public
+    end
+end

data/lib/dbi/utils/tableformatter.rb

@@ -0,0 +1,112 @@
+module DBI
+    module Utils
+        # Formats a resultset in a textual table, suitable for printing.
+        module TableFormatter
+
+            def self.coerce(obj) # :nodoc:
+                # FIXME this is probably short-sighted.
+                obj = "NULL" if obj.nil?
+                obj = (obj.kind_of?(Array) or obj.kind_of?(Hash)) ? obj.inspect : obj.to_s
+                return obj
+            end
+
+            # Perform the formatting.
+            #
+            # * +header+: table headers, as you'd expect they correspond to each column in the row.
+            # * +rows+: array of array (or DBI::Row) which represent the data.
+            # * +header_orient+: jusification of the header. :left, :right, or :center.
+            # * +rows_orient+: justification of the rows. same as +header_orient+.
+            # * +indent+: number of spaces to indent each line in the output.
+            # * +cellspace+: number of spaces to pad the cell on the left and right.
+            # * +pagebreak_after+: introduce a pagebreak each +n+ rows.
+            # * +output+: object that responds to `<<` which will contain the output. Default is STDOUT.
+            #
+            # If a block is provided, +output+ will be yielded each row if
+            # +pagebreak+ is nil, otherwise it will be yielded when the output
+            # is complete.
+            #--
+            # TODO: add a nr-column where the number of the column is shown
+            #++
+            def self.ascii(header, 
+                           rows, 
+                           header_orient=:left, 
+                           rows_orient=:left, 
+                           indent=2, 
+                           cellspace=1, 
+                           pagebreak_after=nil,
+                           output=STDOUT)
+
+                if rows.size == 0 or rows[0].size == 0
+                    output.puts "No rows selected"
+                    return
+                end
+
+                header_orient ||= :left
+                rows_orient   ||= :left
+                indent        ||= 2
+                cellspace     ||= 1
+
+                # pagebreak_after n-rows (without counting header or split-lines)
+                # yield block with output as param after each pagebreak (not at the end)
+
+                col_lengths = (0...(header.size)).collect do |colnr|
+                    [
+                        (0...rows.size).collect { |rownr|
+                        value = rows[rownr][colnr]
+                        coerce(value).size
+                    }.max,
+                        header[colnr].size
+                    ].max
+                end
+
+                indent = " " * indent
+
+                split_line = indent + "+"
+                col_lengths.each {|col| split_line << "-" * (col+cellspace*2) + "+" }
+
+                cellspace = " " * cellspace
+
+                output_row = proc {|row, orient|
+                    output << indent + "|"
+                    row.each_with_index {|c,i|
+                        output << cellspace
+
+                        str = coerce(c)
+
+                        output << case orient
+                        when :left then   str.ljust(col_lengths[i])
+                        when :right then  str.rjust(col_lengths[i])
+                        when :center then str.center(col_lengths[i])
+                        end 
+                        output << cellspace
+                        output << "|"
+                    }
+                    output << "\n" 
+                } 
+
+                rownr = 0
+
+                loop do 
+                    output << split_line + "\n"
+                    output_row.call(header, header_orient)
+                    output << split_line + "\n"
+                    if pagebreak_after.nil?
+                        rows.each {|ar| output_row.call(ar, rows_orient)}
+                        output << split_line + "\n"
+                        break
+                    end      
+
+                    rows[rownr,pagebreak_after].each {|ar| output_row.call(ar, rows_orient)}
+                    output << split_line + "\n"
+
+                    rownr += pagebreak_after
+
+                    break if rownr >= rows.size
+
+                    yield output if block_given?
+                end
+
+            end
+        end # module TableFormatter
+    end
+end

data/lib/dbi/utils/time.rb

@@ -0,0 +1,52 @@
+module DBI
+    #
+    # Represents a Time
+    #
+    # DEPRECATED: Please use a regular Time or DateTime object.
+   class Time
+      attr_accessor :hour, :minute, :second
+
+      private
+      # DBI::Time.new(hour = 0, minute = 0, second = 0)
+      # DBI::Time.new(Time)
+      #
+      # Creates and returns a new DBI::Time object.  Unlike the Time object
+      # in the standard library, accepts an hour, minute and second, or a
+      # Time object.
+      def initialize(hour=0, minute=0, second=0)
+         case hour
+            when ::Time
+               @hour, @minute, @second = hour.hour, hour.min, hour.sec
+               @original_time = hour
+            else
+               @hour, @minute, @second = hour, minute, second
+         end
+      end
+
+      public
+      
+      deprecate :initialize, :public
+
+      alias :min :minute
+      alias :min= :minute=
+      alias :sec :second
+      alias :sec= :second=
+
+      # Returns a new Time object based on the hour, minute and second, using
+      # the current year, month and day.  If a Time object was passed to the
+      # constructor, returns that object instead.
+      def to_time
+         if @original_time
+            @original_time
+         else
+            t = ::Time.now
+            ::Time.local(t.year, t.month, t.day, @hour, @minute, @second)
+         end
+      end
+
+      # Returns a DBI::Time object as a string in HH:MM:SS format.
+      def to_s
+         sprintf("%02d:%02d:%02d", @hour, @minute, @second)
+      end
+   end
+end

data/lib/dbi/utils/timestamp.rb

@@ -0,0 +1,96 @@
+module DBI
+    #
+    # Represents a Timestamp.
+    #
+    # DEPRECATED: Please use a regular DateTime object.
+    #
+   class Timestamp
+      attr_accessor :year, :month, :day
+      attr_accessor :hour, :minute, :second
+      attr_writer   :fraction
+
+      private
+      # DBI::Timestamp(year=0,month=0,day=0,hour=0,min=0,sec=0,fraction=nil)
+      # DBI::Timestamp(Time)
+      # DBI::Timestamp(Date)
+      #
+      # Creates and returns a new DBI::Timestamp object.  This is similar to
+      # a Time object in the standard library, but it also contains fractional
+      # seconds, expressed in nanoseconds.  In addition, the constructor
+      # accepts either a Date or Time object.
+      def initialize(year=0, month=0, day=0, hour=0, min=0, sec=0, fraction=nil)
+         case year
+            when ::Time
+               @year, @month, @day = year.year, year.month, year.day 
+               @hour, @minute, @second, @fraction = year.hour, year.min, year.sec, nil 
+               @original_time = year
+            when ::Date
+               @year, @month, @day = year.year, year.month, year.day 
+               @hour, @minute, @second, @fraction = 0, 0, 0, nil 
+               @original_date = year
+            else
+               @year, @month, @day = year, month, day
+               @hour, @minute, @second, @fraction = hour, min, sec, fraction
+         end
+      end
+
+      public
+      
+      deprecate :initialize, :public
+
+      # Returns true if +timestamp+ has a year, month, day, hour, minute,
+      # second and fraction equal to the comparing object.
+      #
+      # Returns false if the comparison fails for any reason.
+      def ==(timestamp)
+         @year == timestamp.year and @month == timestamp.month and
+         @day == timestamp.day and @hour == timestamp.hour and
+         @minute == timestamp.minute and @second == timestamp.second and
+         (fraction() == timestamp.fraction)
+      rescue
+         false
+      end
+
+      # Returns fractional seconds, or 0 if not set.
+      def fraction
+         @fraction || 0
+      end
+
+      # Aliases
+      alias :mon :month
+      alias :mon= :month=
+      alias :mday :day
+      alias :mday= :day=
+      alias :min :minute
+      alias :min= :minute=
+      alias :sec :second
+      alias :sec= :second=
+
+      # Returns a DBI::Timestamp object as a string in YYYY-MM-DD HH:MM:SS
+      # format.  If a fraction is present, then it is appended in ".FF" format.
+      def to_s
+         string = sprintf("%04d-%02d-%02d %02d:%02d:%02d",
+             @year, @month, @day, @hour, @minute, @second) 
+
+         if @fraction
+            fraction = ("%.9f" % (@fraction.to_i / 1e9)).
+                        to_s[1..-1].gsub(/0{1,8}$/, "")
+            string += fraction
+         end
+
+         string
+      end
+
+      # Returns a new Time object based on the year, month and day or, if a
+      # Time object was passed to the constructor, returns that object.
+      def to_time
+         @original_time || ::Time.local(@year, @month, @day, @hour, @minute, @second)
+      end
+
+      # Returns a new Date object based on the year, month and day or, if a
+      # Date object was passed to the constructor, returns that object.
+      def to_date
+         @original_date || ::Date.new(@year, @month, @day)
+      end
+   end
+end

data/lib/dbi/utils/xmlformatter.rb

@@ -0,0 +1,73 @@
+module DBI
+    module Utils
+        # Formats results in XML.
+        module XMLFormatter
+            # Generate XML for a row. The column names will surround the the values as tags.
+            #
+            # * +dbrow+: the array of the result row.
+            # * +rowtag+: the name of the tag that encapsulates a row.
+            # * +output+: Object that responds to `<<`.
+            #
+            def self.row(dbrow, rowtag="row", output=STDOUT)
+                #XMLFormatter.extended_row(dbrow, "row", [],  
+                output << "<#{rowtag}>\n"
+                dbrow.each_with_name do |val, name|
+                    output << "  <#{name}>" + textconv(val) + "</#{name}>\n" 
+                end
+                output << "</#{rowtag}>\n"
+            end
+
+            # good lord, what a mess.
+            #
+            # nil in cols_as_tag, means "all columns expect those listed in cols_in_row_tag"
+            # add_row_tag_attrs are additional attributes which are inserted into the row-tag
+            def self.extended_row(dbrow, rowtag="row", cols_in_row_tag=[], cols_as_tag=nil, add_row_tag_attrs={}, output=STDOUT)
+                if cols_as_tag.nil?
+                    cols_as_tag = dbrow.column_names - cols_in_row_tag
+                end
+
+                output << "<#{rowtag}"
+                add_row_tag_attrs.each do |key, val|  
+                    # TODO: use textconv ? " substitution?
+                    output << %{ #{key}="#{textconv(val)}"}
+                end
+                cols_in_row_tag.each do |key|
+                    # TODO: use textconv ? " substitution?
+                    output << %{ #{key}="#{dbrow[key]}"}
+                end
+                output << ">\n"
+
+                cols_as_tag.each do |key|
+                    output << "  <#{key}>" + textconv(dbrow[key]) + "</#{key}>\n" 
+                end
+                output << "</#{rowtag}>\n"
+            end
+
+            # generate a full XML representation of the table.
+            # 
+            # Arguments and output are similar to #row, with the exception of
+            # +roottag+, which is a container for the individual row tags.
+            #
+            def self.table(rows, roottag = "rows", rowtag = "row", output=STDOUT)
+                output << '<?xml version="1.0" encoding="UTF-8" ?>'
+                output << "\n<#{roottag}>\n"
+                rows.each do |row|
+                    row(row, rowtag, output)
+                end
+                output << "</#{roottag}>\n"
+            end
+
+            class << self
+                private
+                # Your standard XML entity conversions.
+                def textconv(str)
+                    str = str.to_s.gsub('&', "&#38;")
+                    str = str.gsub('\'', "&#39;")
+                    str = str.gsub('"', "&#34;")
+                    str = str.gsub('<', "&#60;")
+                    str.gsub('>', "&#62;")
+                end
+            end # class self
+        end # module XMLFormatter
+    end
+end

data/lib/dbi/version.rb

@@ -0,0 +1,3 @@
+module DBI
+  VERSION = "0.5.0"
+end

data/prototypes/types2.rb

@@ -0,0 +1,237 @@
+require 'date'
+require 'time'
+
+#
+# General example, these would be types that would exist in DBI proper
+#
+
+module DBI
+    class DBI::Type
+        def self.parse(obj, type=nil, dbh=nil)
+            if type 
+                sym = ( "to_" + type.to_s ).to_sym
+                begin
+                    return self.__send__(sym, obj) 
+                rescue ::NoMethodError 
+                    self.to_type(obj)
+                end
+            else
+                return self.to_type(obj)
+            end
+        end
+
+        def self.coerce(obj, type=nil, dbh=nil)
+            if type
+                sym = ( "from_" + type.to_s ).to_sym
+                begin
+                    return self.__send__(sym, obj) 
+                rescue ::NoMethodError 
+                    self.from_type(obj)
+                end
+            else
+                return self.from_type(obj)
+            end
+        end
+
+        def self.from_type(obj)
+            obj.to_s rescue obj.to_str rescue obj
+        end
+
+        def self.to_type(obj)
+            obj
+        end
+    end
+
+    class DBI::Type::Null < DBI::Type
+        def self.to_type(obj)
+            return obj unless obj
+            return nil if obj.to_s.match(/^null$/i)
+            return obj
+        end
+
+        def self.from_type(obj)
+            obj
+        end
+    end
+
+    class DBI::Type::Integer < DBI::Type::Null
+        def self.parse(obj)
+            obj = super
+            return obj unless obj
+            return obj.to_i if obj.respond_to? :to_i
+            return obj
+        end
+    end
+
+    class DBI::Type::Timestamp < DBI::Type::Null
+        def self.to_type(obj)
+            obj = super
+            return obj unless obj
+
+            case obj
+            when ::DateTime
+                return obj
+            when ::Date
+                return ::DateTime.strptime(obj.to_s, "%Y-%m-%d")
+            when ::Time
+                return ::DateTime.parse(obj.to_s)
+            when ::Integer
+                return ::DateTime.parse(::Time.at(obj).to_s)
+            else
+                return ::DateTime.parse(obj.to_s)   if obj.respond_to? :to_s
+                return ::DateTime.parse(obj.to_str) if obj.respond_to? :to_str
+                return obj
+            end
+        end
+
+        def self.from_type(obj)
+            obj = super
+            return obj unless obj
+
+            case obj
+            when ::DateTime
+                return obj.to_s # produces ISO8601
+            when ::Time
+                return obj.iso8601
+            when ::Integer
+                return ::Time.at(obj).iso8601
+            else
+                return obj
+            end
+        end
+    end
+end
+
+module DBI::DBD
+    class Pg
+
+        #
+        # during connect time, after DatabaseHandle initialization, the hash
+        # that DatabaseHandle#type_map provides would be tweaked to take
+        # advantage of the available date formats.
+        #
+        # See 'PgDatabaseHandle' below for a mock.
+        #
+
+        class Type
+            class Timestamp < DBI::Type::Timestamp
+                def self.from_dmy(obj)
+                    return obj if DBI::Type::Null.parse(obj).nil?
+
+                    case obj
+                    when ::DateTime, ::Time
+                        obj.strftime("%d/%m/%Y %H:%M:%S")
+                    when ::Integer
+                        ::Time.at(obj).strftime("%d/%m/%Y %H:%M:%S")
+                    else
+                        # punt... this will actually try the baseline
+                        # conversion at this point
+                        raise "Crap!"
+                    end
+                end
+
+                def self.to_dmy(obj)
+                    return obj if DBI::Type::Null.parse(obj).nil?
+
+                    # realistically all there needs to be is a check for the
+                    # type ruby-pg typically returns and string, but to be
+                    # complete I'm showing how it could be done if the type was
+                    # less clear.
+
+                    case obj
+                    when ::DateTime
+                        return obj
+                    when ::Time  
+                        return ::DateTime.parse(obj.to_s)
+                    else
+                        return ::DateTime.strptime(obj, "%d/%m/%Y %H:%M:%S")
+                    end
+                end
+            end
+        end
+    end
+end 
+
+#
+# this is just used to emulate the methods a DatabaseHandle would have to
+# faciliate this.. certainly not a full (or correct) mirroring of the DBI API.
+#
+class DatabaseHandle
+
+    attr_accessor :columns
+    
+    def outbound_type_map
+        {
+            'timestamp' => [DBI::Type::Timestamp]
+        }
+    end
+
+    def inbound_type_map
+        {
+            ::DateTime => [DBI::Type::Timestamp],
+            ::Time     => [DBI::Type::Timestamp]
+        }
+    end
+
+    # humor me while I completely break DBI for the sake of brevity..
+    def execute(*bindvars)
+        bindvars.collect do |var|
+            type_info = inbound_type_map[var.class]
+            type_info[0].coerce(var, type_info[1], self)
+        end
+    end
+
+    def fetch(*bindvars)
+        ret = []
+
+        bindvars.each_with_index do |var, i|
+            type_info = outbound_type_map[columns[i]]
+            ret.push type_info[0].parse(var, type_info[1], self)
+        end
+        
+        return ret
+    end
+end
+
+class PgDatabaseHandle < DatabaseHandle
+    def outbound_type_map
+        {
+            'timestamp' => [DBI::DBD::Pg::Type::Timestamp, :dmy]
+        }
+    end
+
+    def inbound_type_map
+        {
+            ::DateTime => [DBI::DBD::Pg::Type::Timestamp, :dmy],
+            ::Time     => [DBI::DBD::Pg::Type::Timestamp, :dmy]
+        }
+    end
+end
+
+# ok! now for the functional example:
+
+if __FILE__ == $0
+
+    dbh = DatabaseHandle.new
+    dbh.columns = %w(timestamp timestamp)
+    # this would go TO the database..
+    p dbh.execute(DateTime.now, Time.now)
+    # this would come FROM the database...
+    p dbh.fetch(Time.now.iso8601, DateTime.now.to_s)
+
+    # now the Pg example:
+    dbh = PgDatabaseHandle.new
+    dbh.columns = %w(timestamp timestamp)
+
+    # this would go TO the database..
+    p dbh.execute(DateTime.now, Time.now)
+    # this would come FROM the database...
+    p dbh.fetch(Time.now.strftime("%d/%m/%Y %H:%M:%S"), DateTime.now.strftime("%d/%m/%Y %H:%M:%S"))
+    
+    # this should fail appropriately
+    begin
+        dbh.fetch(Time.now.iso8601, DateTime.now.to_s)
+    rescue Exception
+        puts "this failed like it should"
+    end
+end