akitaonrails-activerecord-sqlserver-adapter 1.1.0 → 1.1.1

data/lib/dbi/columninfo.rb

@@ -0,0 +1,158 @@
+class ColumnInfo < Hash
+
+   # Creates and returns a ColumnInfo object.  This represents metadata for
+   # columns within a given table, such as the data type, whether or not the
+   # the column is a primary key, etc.
+   #
+   # ColumnInfo is a subclass of Hash.
+   #
+   def initialize(hash=nil)
+      self.update(hash) if hash
+   end
+   
+   # Returns the column's name.
+   def name
+      self['name']
+   end
+   
+   # Sets the column's name.
+   def name=(val)
+      self['name'] = val
+   end
+   
+   # Returns a portable integer representation of the column's type.  Here are
+   # the constant names (under DBI) and their respective values:
+   #
+   # SQL_CHAR      = 1
+   # SQL_NUMERIC   = 2
+   # SQL_DECIMAL   = 3
+   # SQL_INTEGER   = 4
+   # SQL_SMALLINT  = 5
+   # SQL_FLOAT     = 6
+   # SQL_REAL      = 7
+   # SQL_DOUBLE    = 8
+   # SQL_DATE      = 9 
+   # SQL_TIME      = 10
+   # SQL_TIMESTAMP = 11
+   # SQL_VARCHAR   = 12
+   #
+   # SQL_LONGVARCHAR   = -1
+   # SQL_BINARY        = -2
+   # SQL_VARBINARY     = -3
+   # SQL_LONGVARBINARY = -4
+   # SQL_BIGINT        = -5
+   # SQL_BIT           = -7
+   # SQL_TINYINT       = -6
+   #
+   def sql_type
+      self['sql_type']
+   end
+   
+   # Sets the integer representation for the column's type.
+   def sql_type=(val)
+      self['sql_type'] = val
+   end
+   
+   # A string representation of the column's type, e.g. 'date'.
+   def type_name
+      self['type_name']
+   end
+   
+   # Sets the representation for the column's type.
+   def type_name=(val)
+      self['type_name'] = val
+   end
+   
+   # Returns the precision, i.e. number of bytes or digits.
+   def precision
+      self['precision']
+   end
+   
+   # Sets the precision, i.e. number of bytes or digits.
+   def precision=(val)
+      self['precision'] = val
+   end
+   
+   # Returns the number of digits from right.
+   def scale
+      self['scale']
+   end
+   
+   # Sets the number of digits from right.
+   def scale=(val)
+      self['scale'] = val
+   end
+   
+   # Returns the default value for the column, or nil if not set.
+   def default
+      self['default']
+   end
+   
+   # Sets the default value for the column.
+   def default=(val)
+      self['default'] = val
+   end
+   
+   # Returns whether or not the column is may contain a NULL.
+   def nullable
+      self['nullable']
+   end
+   
+   # Sets whether or not the column may contain a NULL.
+   def nullable=(val)
+      self['nullable'] = val
+   end
+   
+   # Returns whether or not the column is indexed.
+   def indexed
+      self['indexed']
+   end
+   
+   # Sets whether or not the column is indexed.
+   def indexed=(val)
+      self['indexed'] = 'val'
+   end
+   
+   # Returns whether or not the column is a primary key.
+   def primary
+      self['primary']
+   end
+   
+   # Sets whether or not the column is a primary key.
+   def primary=(val)
+      self['primary'] = val
+   end
+   
+   # Returns whether or not data in the column must be unique.
+   def unique
+      self['unique']
+   end
+   
+   # Sets whether or not data in the column must be unique.
+   def unique=(val)
+      self['unique'] = val
+   end
+
+   # Aliases
+   alias nullable? nullable
+   alias is_nullable? nullable
+
+   alias indexed? indexed
+   alias is_indexed? indexed
+
+   alias primary? primary
+   alias is_primary? primary
+
+   alias unique? unique
+   alias is_unique unique
+
+   alias size precision
+   alias size= precision=
+   alias length precision
+   alias length= precision=
+
+   alias decimal_digits scale
+   alias decimal_digits= scale=
+end
+
+

data/lib/dbi/row.rb

@@ -0,0 +1,205 @@
+require "delegate"
+
+# The DBI::Row class is a delegate of Array, rather than a subclass, because
+# there are times when it should act like an Array, and others when it should
+# act like a Hash (and still others where it should act like String, Regexp,
+# etc).  It also needs to store metadata about the row, such as
+# column data type and index information, that users can then access.
+#
+module DBI
+   class Row < DelegateClass(Array)
+      attr_reader :column_names
+
+      # DBI::Row.new(columns, size_or_array=nil)
+      #
+      # Returns a new DBI::Row object using +columns+.  The +size_or_array+
+      # argument may either be an Integer or an Array.  If it is not provided,
+      # it defaults to the length of +columns+.
+      #
+      # DBI::Row is a delegate of the Array class, so all of the Array
+      # instance methods are available to your DBI::Row object (keeping in
+      # mind that initialize, [], and []= have been explicitly overridden).
+      #
+      def initialize(columns, size_or_array=nil)
+         size_or_array ||= columns.size 
+
+         case size_or_array
+            when Integer
+               @arr = Array.new(size_or_array)
+            when Array
+               @arr = size_or_array
+            else
+               raise TypeError, "parameter must be either Integer or Array"
+         end
+
+         # The '@column_map' is used to map column names to integer values so
+         # that users can reference row values by name or number.
+
+         @column_map   = {}
+         @column_names = columns
+         columns.each_with_index { |c,i| @column_map[c] = i }
+         super(@arr)
+      end
+
+      # Replaces the contents of @arr with +new_values+
+      def set_values(new_values)
+         @arr.replace(new_values)
+      end
+      
+      # Yields a column value by name (rather than index), along with the
+      # column name itself.
+      def each_with_name
+         @arr.each_with_index do |v, i|
+            yield v, @column_names[i]
+         end 
+      end
+      
+      # Returns the Row object as a hash
+      def to_h
+         hash = {}
+         each_with_name{ |v, n| hash[n] = v}
+         hash
+      end
+      
+      # Create a new row with 'new_values', reusing the field name hash.
+      def clone_with(new_values)    
+         Row.new(@column_names, new_values)
+      end
+
+      alias field_names column_names
+
+      # Retrieve a value by index (rather than name).
+      #
+      # Deprecated.  Since Row delegates to Array, just use Row#at.
+      def by_index(index)
+         @arr[index]
+      end
+    
+      # Value of the field named +field_name+ or nil if not found.
+      def by_field(field_name)
+         begin
+            @arr[@column_map[field_name.to_s]]
+         rescue TypeError
+            nil
+         end
+      end
+ 
+      # Row#[]
+      #
+      # row[int]
+      # row[array]
+      # row[regexp]
+      # row[arg, arg]
+      # row[arg, arg, ...]
+      #
+      # Sample: Row.new(["first","last","age"], ["Daniel", "Berger", "36"])
+      #
+      # Retrieves row elements.  Exactly what it retrieves depends on the
+      # kind and number of arguments used.
+      #
+      # Zero arguments will raise an ArgumentError.
+      #
+      # One argument will return a single result.  This can be a String,
+      # Symbol, Integer, Range or Regexp and the appropriate result will
+      # be returned.  Strings, Symbols and Regexps act like hash lookups,
+      # while Integers and Ranges act like Array index lookups.
+      #
+      # Two arguments will act like the second form of Array#[], i.e it takes
+      # two integers, with the first number the starting point and the second
+      # number the length, and returns an array of values.
+      #
+      # If three or more arguments are provided, an array of results is
+      # returned.  The behavior for each argument is that of a single argument,
+      # i.e. Strings, Symbols, and Regexps act like hash lookups, while
+      # Integers and Ranges act like Array index lookups.
+      # 
+      # If no results are found, or an unhandled type is passed, then nil
+      # (or a nil element) is returned.
+      #
+      def [](*args)
+         begin
+            case args.length
+               when 0
+                  err = "wrong # of arguments(#{args.size} for at least 1)"
+                  raise ArgumentError, err
+               when 1
+                  case args[0]
+                     when Array
+                        args[0].collect { |e| self[e] }
+                     when Regexp
+                        self[@column_names.grep(args[0])] 
+                     else
+                        @arr[conv_param(args[0])]
+                  end
+               # We explicitly check for a length of 2 in order to properly
+               # simulate the second form of Array#[].
+               when 2
+                  @arr[conv_param(args[0]), conv_param(args[1])]
+               else
+                  results = []
+                  args.flatten.each{ |arg|
+                     case arg
+                        when Integer
+                           results.push(@arr[arg])
+                        when Regexp
+                           results.push(self[@column_names.grep(arg)])
+                        else
+                           results.push(self[conv_param(arg)])
+                     end
+                  }
+                  results.flatten
+            end
+         rescue TypeError
+            nil
+         end
+      end
+
+      # Assign a value to a Row object by element.  You can assign using
+      # a single element reference, or by using a start and length similar
+      # to the second form of Array#[]=.
+      #
+      # row[0]     = "kirk"
+      # row[:last] = "haines"
+      # row[0, 2]  = "test" 
+      #
+      def []=(key, value_or_length, obj=nil)
+         if obj
+            @arr[conv_param(key), conv_param(value_or_length)] = obj
+         else
+            @arr[conv_param(key)] = value_or_length
+         end
+      end
+
+      def clone
+         clone_with(@arr.dup)
+      end
+
+      alias dup clone
+
+      private
+
+      # Simple helper method to grab the proper value from @column_map
+      def conv_param(arg)
+         case arg
+            when String, Symbol
+               @column_map[arg.to_s]
+            when Range
+               if arg.first.kind_of?(Symbol) || arg.first.kind_of?(String)
+                  first = @column_map[arg.first.to_s]
+                  last  = @column_map[arg.last.to_s]
+               else
+                  first = arg.first
+                  last  = arg.last
+               end
+
+               if arg.exclude_end?
+                  (first...last) 
+               else
+                  (first..last)
+               end
+            else
+               arg
+         end
+      end
+   end # class Row
+end # module DBI

data/lib/dbi/sql.rb

@@ -0,0 +1,239 @@
+#
+# $Id: sql.rb,v 1.3 2006/03/27 20:25:02 francis Exp $
+#
+# parts extracted from Jim Weirichs DBD::Pg
+#
+
+module DBI
+require "dbi/utils"
+require "parsedate"
+require "time"
+
+module SQL
+
+  ## Is the SQL statement a query?
+  def SQL.query?(sql)
+    sql =~ /^\s*select\b/i
+  end
+
+
+  ####################################################################
+  # Mixin module useful for expanding SQL statements.
+  #
+  module BasicQuote
+
+    # by Masatoshi SEKI
+    class Coerce
+      def as_int(str)
+        return nil if str.nil?
+        if str == "" then nil else str.to_i end 
+      end 
+
+      def as_float(str)
+        return nil if str.nil?
+        str.to_f
+      end
+
+      def as_str(str)
+        str
+      end
+
+      def as_bool(str)
+        if str == "t" or str == "1"
+          true
+        elsif str == "f" or str == "0"
+          false
+        else
+          nil
+        end
+      end
+
+      def as_time(str)
+        return nil if str.nil? or str.empty?
+        t = ParseDate.parsedate(str)
+        DBI::Time.new(*t[3,3])
+      end
+
+
+      def as_timestamp(str)
+        return nil if str.nil? or str.empty?
+        ary = ParseDate.parsedate(str)
+        begin 
+          time = ::Time.gm(*(ary[0,6])) 
+        rescue ArgumentError => ae 
+          # don't fault stupid values that MySQL nevertheless stores 
+          return nil 
+        end
+        if ary[6] =~ /^((\+|\-)\d+)(:\d+)?$/
+          diff = $1.to_i * 3600  # seconds per hour 
+          time -= diff
+          time.localtime
+        end 
+        DBI::Timestamp.new(time)
+      end
+
+
+      def as_date(str)
+        return nil if str.nil?
+        ary = ParseDate.parsedate(str)
+        DBI::Date.new(*ary[0,3])
+      rescue
+        nil
+      end
+
+
+      def coerce(sym, str)
+        self.send(sym, str)
+      end
+
+    end # class Coerce
+
+    
+    ## Quote strings appropriately for SQL statements
+    def quote(value)
+      case value
+      when String
+	value = value.gsub(/'/, "''")	# ' (for ruby-mode)
+	"'#{value}'"
+      when NilClass
+	"NULL"
+      when TrueClass
+        "'t'"
+      when FalseClass
+        "'f'"
+      when Array
+	value.collect { |v| quote(v) }.join(", ")
+      when DBI::Date, DBI::Time, DBI::Timestamp, ::Date
+        "'#{value.to_s}'"
+      when ::Time
+        "'#{value.rfc2822}'"
+      else
+	value.to_s
+      end
+    end
+  end # module BasicQuote
+
+
+
+  ####################################################################
+  # Mixin module useful for binding arguments to an SQL string.
+  #
+  module BasicBind
+
+    ## Bind the :sql string to an array of :args, quoting with :quoter.
+    #
+    def bind(quoter, sql, args)
+      arg_index = 0
+      result = ""
+      tokens(sql).each { |part|
+	case part
+	when '?'
+	  result << quoter.quote(args[arg_index])
+	  arg_index += 1
+	when '??'
+	  result << "?"
+	else
+	  result << part
+	end
+      }
+      if arg_index < args.size
+        raise "Too many SQL parameters"
+      elsif arg_index > args.size
+        raise "Not enough SQL parameters"
+      end
+      result
+    end
+
+    ## Break the sql string into parts.
+    #
+    # This is NOT a full lexer for SQL.  It just breaks up the SQL
+    # string enough so that question marks, double question marks and
+    # quoted strings are separated.  This is used when binding
+    # arguments to "?" in the SQL string.  
+    #
+    # C-style (/* */) and Ada-style (--) comments are handled.
+    # Note: Nested C-style comments are NOT handled!
+    #
+    def tokens(sql)
+      sql.scan(%r{
+        (
+            -- .*                               (?# matches "--" style comments to the end of line or string )
+        |   -                                   (?# matches single "-" )
+        |
+            /[*] .*? [*]/                       (?# matches C-style comments )
+        |   /                                   (?# matches single slash )    
+        |
+            ' ( [^'\\]  |  ''  |  \\. )* '      (?# match strings surrounded by apostophes )
+        |
+            " ( [^"\\]  |  ""  |  \\. )* "      (?# match strings surrounded by " )
+        |
+            \?\??                               (?# match one or two question marks )
+        |
+            [^-/'"?]+                           (?# match all characters except ' " ? - and / )
+            
+        )}x).collect {|t| t.first}
+    end
+
+  end # module BasicBind
+
+
+  class PreparedStatement
+    include BasicBind # for method tokens(sql)
+
+    attr_accessor :unbound
+
+    def initialize(quoter, sql)
+      @quoter, @sql = quoter, sql
+      prepare
+    end
+
+    def bind(args)
+      if @arg_index < args.size
+        raise "Too many SQL parameters"
+      elsif @arg_index > args.size
+        raise "Not enough SQL parameters"
+      end
+
+      @unbound.each do |res_pos, arg_pos|
+        @result[res_pos] = @quoter.quote(args[arg_pos])
+      end
+
+      @result.join("")
+    end
+
+    private
+
+    def prepare
+      @result = [] 
+      @unbound = {}
+      pos = 0
+      @arg_index = 0
+
+      tokens(@sql).each { |part|
+	case part
+	when '?'
+          @result[pos] = nil
+          @unbound[pos] = @arg_index
+          pos += 1
+          @arg_index += 1
+	when '??'
+          if @result[pos-1] != nil
+            @result[pos-1] << "?"
+          else
+            @result[pos] = "?"
+            pos += 1
+          end
+	else
+          if @result[pos-1] != nil
+            @result[pos-1] << part
+          else
+            @result[pos] = part
+            pos += 1
+          end
+	end
+      }
+    end
+  end
+
+end # module SQL
+end # module DBI