akitaonrails-activerecord-sqlserver-adapter 1.1.0 → 1.1.1

data/lib/dbi/trace.rb

@@ -0,0 +1,90 @@
+# $Id: trace.rb,v 1.1 2006/01/04 02:03:22 francis Exp $
+# 
+# Tracing for DBI programs
+# 
+# Copyright (c) 2001 Michael Neumann
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+
+# works only correct with the newest version > 0.3.3
+require "aspectr"
+require "dbi"      # to work as "ruby -r dbi/trace myapp.rb"
+
+module DBI
+
+class HandleTracer < AspectR::Aspect
+
+  def initialize(klass)
+    @never_wrap = /^__|^send$|^id$|^class$|^$ /
+    self.wrap(klass, :pre, :post, methods(klass)) 
+  end
+
+  # trace methods -------------------------------------------------------------- 
+
+  def pre(method, object, exitstatus, *args)
+    
+    par = args.collect{|a| a.inspect}.join(", ")
+
+    if object.trace_mode == 2 then
+      object.trace_output << "-> #{method} for #{object} (#{par})\n"
+    elsif object.trace_mode == 3 then
+      object.trace_output << "-> #{method} for #{object.inspect} (#{par})\n"
+    end
+  end
+
+  def post(method, object, exitstatus, *args)
+
+    case object.trace_mode
+    when 1, 2 # return values and errors
+      arrow = object.trace_mode == 1 ? "<=" : "<-"
+      if exitstatus.kind_of? Array
+        object.trace_output << "#{arrow} #{method} for #{object} = #{exitstatus[0] || 'nil'}\n" 
+      else
+        if exitstatus == true
+          object.trace_output << "!! #{$!.message.chomp}\n" 
+        end
+        object.trace_output << "#{arrow} #{method} for #{object}\n"
+      end
+ 
+    when 3
+      if exitstatus.kind_of? Array
+        object.trace_output << "<- #{method} for #{object.inspect} = #{exitstatus[0].inspect}\n" 
+      else
+        if exitstatus == true
+          object.trace_output << "!! #{$!.inspect}\n" 
+        end
+        object.trace_output << "<- #{method} for #{object.inspect}\n"
+      end
+    end
+  
+  end
+
+  private # helper methods -----------------------------------------------------
+
+  def methods(klass)
+    meths = (DBI::Handle.instance_methods | klass.instance_methods) - %w(trace_mode trace_output trace)
+    /(#{meths.collect{|m| Regexp.quote(m)}.join('|')})/
+  end
+
+end
+
+@@tracer_driver    = HandleTracer.new(DBI::DriverHandle)
+@@tracer_database  = HandleTracer.new(DBI::DatabaseHandle)
+@@tracer_statement = HandleTracer.new(DBI::StatementHandle)
+
+ 
+end # module DBI
+  

data/lib/dbi/utils.rb

@@ -0,0 +1,365 @@
+#
+# $Id: utils.rb,v 1.5 2006/01/29 06:14:19 djberg96 Exp $
+#
+
+module DBI
+   class Date
+      attr_accessor :year, :month, :day
+
+      # 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
+
+      # 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
+   end
+
+   class Time
+      attr_accessor :hour, :minute, :second
+
+      # 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
+
+      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
+
+   class Timestamp
+      attr_accessor :year, :month, :day
+      attr_accessor :hour, :minute, :second
+      attr_writer   :fraction
+  
+      # 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
+
+      # 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
+
+module Utils
+
+  module ConvParam
+    def conv_param(*params)
+      params.collect do |p|
+        case p
+        when ::Date
+          DBI::Date.new(p)
+        when ::Time
+          DBI::Timestamp.new(p)
+        else
+          p
+        end
+      end
+    end
+  end
+
+
+  def Utils.measure
+    start = ::Time.now
+    yield
+    ::Time.now - start
+  end
+  
+  ##
+  # parse a string of the form "database=xxx;key=val;..."
+  # or database:host and return hash of key/value pairs
+  #
+  # improved by John Gorman <jgorman@webbysoft.com>
+  def Utils.parse_params(str)
+    params = str.split(";")
+    hash = {}
+    params.each do |param| 
+      key, val = param.split("=") 
+      hash[key] = val if key and val
+    end 
+    if hash.empty?
+      database, host = str.split(":")
+      hash['database'] = database if database
+      hash['host']     = host if host   
+    end
+    hash 
+  end
+
+
+module XMLFormatter
+  def XMLFormatter.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
+
+  # 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 XMLFormatter.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
+
+
+ 
+  def XMLFormatter.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
+    # from xmloracle.rb 
+    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
+
+
+module TableFormatter
+
+  # TODO: add a nr-column where the number of the column is shown
+  def TableFormatter.ascii(header, rows, 
+    header_orient=:left, rows_orient=:left, 
+    indent=2, cellspace=1, pagebreak_after=nil,
+    output=STDOUT)
+
+    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]
+        (value.nil? ? "NULL" : value).to_s.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 = (c.nil? ? "NULL" : c).to_s
+        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 # module Utils
+end # module DBI
+
+