activerecord 1.14.4 → 1.15.0

data/lib/active_record/connection_adapters/sybase_adapter.rb

@@ -1,11 +1,20 @@
 # sybase_adaptor.rb
-# Author: John Sheets <dev@metacasa.net>
-# Date:   01 Mar 2006
-#
-# Based on code from Will Sobel (http://dev.rubyonrails.org/ticket/2030)
-#
+# Author: John R. Sheets
+# 
+# 01 Mar 2006: Initial version.  Based on code from Will Sobel
+#              (http://dev.rubyonrails.org/ticket/2030)
+# 
 # 17 Mar 2006: Added support for migrations; fixed issues with :boolean columns.
-#
+# 
+# 13 Apr 2006: Improved column type support to properly handle dates and user-defined
+#              types; fixed quoting of integer columns.
+# 
+# 05 Jan 2007: Updated for Rails 1.2 release:
+#              restricted Fixtures#insert_fixtures monkeypatch to Sybase adapter;
+#              removed SQL type precision from TEXT type to fix broken
+#              ActiveRecordStore (jburks, #6878); refactored select() to use execute();
+#              fixed leaked exception for no-op change_column(); removed verbose SQL dump
+#              from columns(); added missing scale parameter in normalize_type().
 
 require 'active_record/connection_adapters/abstract_adapter'
 
@@ -35,7 +44,7 @@ module ActiveRecord
 
       ConnectionAdapters::SybaseAdapter.new(
         SybSQL.new({'S' => host, 'U' => username, 'P' => password},
-          ConnectionAdapters::SybaseAdapterContext), database, logger)
+          ConnectionAdapters::SybaseAdapterContext), database, config, logger)
     end
   end # class Base
 
@@ -48,7 +57,7 @@ module ActiveRecord
     #
     # * <tt>:host</tt> -- The name of the database server. No default, must be provided.
     # * <tt>:database</tt> -- The name of the database. No default, must be provided.
-    # * <tt>:username</tt>  -- Defaults to sa.
+    # * <tt>:username</tt>  -- Defaults to "sa".
     # * <tt>:password</tt>  -- Defaults to empty string.
     #
     # Usage Notes:
@@ -75,7 +84,7 @@ module ActiveRecord
     #   2> go
     class SybaseAdapter < AbstractAdapter # :nodoc:
       class ColumnWithIdentity < Column
-        attr_reader :identity, :primary
+        attr_reader :identity
 
         def initialize(name, default, sql_type = nil, nullable = nil, identity = nil, primary = nil)
           super(name, default, sql_type, nullable)
@@ -84,14 +93,15 @@ module ActiveRecord
 
         def simplified_type(field_type)
           case field_type
-            when /int|bigint|smallint|tinyint/i                        then :integer
-            when /float|double|decimal|money|numeric|real|smallmoney/i then :float
-            when /text|ntext/i                                         then :text
-            when /binary|image|varbinary/i                             then :binary
-            when /char|nchar|nvarchar|string|varchar/i                 then :string
-            when /bit/i                                                then :boolean
-            when /datetime|smalldatetime/i                             then :datetime
-            else                                                       super
+            when /int|bigint|smallint|tinyint/i        then :integer
+            when /float|double|real/i                  then :float
+            when /decimal|money|numeric|smallmoney/i   then :decimal
+            when /text|ntext/i                         then :text
+            when /binary|image|varbinary/i             then :binary
+            when /char|nchar|nvarchar|string|varchar/i then :string
+            when /bit/i                                then :boolean
+            when /datetime|smalldatetime/i             then :datetime
+            else                                       super
           end
         end
 
@@ -106,10 +116,12 @@ module ActiveRecord
       end # class ColumnWithIdentity
 
       # Sybase adapter
-      def initialize(connection, database, logger = nil)
+      def initialize(connection, database, config = {}, logger = nil)
         super(connection, logger)
         context = connection.context
         context.init(logger)
+        @config = config
+        @numconvert = config.has_key?(:numconvert) ? config[:numconvert] : true
         @limit = @offset = 0
         unless connection.sql_norow("USE #{database}")
           raise "Cannot USE #{database}"
@@ -123,6 +135,7 @@ module ActiveRecord
           :text        => { :name => "text" },
           :integer     => { :name => "int" },
           :float       => { :name => "float", :limit => 8 },
+          :decimal     => { :name => "decimal" },
           :datetime    => { :name => "datetime" },
           :timestamp   => { :name => "timestamp" },
           :time        => { :name => "time" },
@@ -132,6 +145,15 @@ module ActiveRecord
         }
       end
 
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        return super unless type.to_s == 'integer'
+        if !limit.nil? && limit < 4
+          'smallint'
+        else
+          'integer'
+        end
+      end
+
       def adapter_name
         'Sybase'
       end
@@ -154,29 +176,6 @@ module ActiveRecord
         30
       end
 
-      # Check for a limit statement and parse out the limit and
-      # offset if specified. Remove the limit from the sql statement
-      # and call select.
-      def select_all(sql, name = nil)
-        select(sql, name)
-      end
-
-      # Remove limit clause from statement. This will almost always
-      # contain LIMIT 1 from the caller. set the rowcount to 1 before
-      # calling select.
-      def select_one(sql, name = nil)
-        result = select(sql, name)
-        result.nil? ? nil : result.first
-      end
-
-      def columns(table_name, name = nil)
-        table_structure(table_name).inject([]) do |columns, column|
-          name, default, type, nullable, identity, primary = column
-          columns << ColumnWithIdentity.new(name, default, type, nullable, identity, primary)
-          columns
-        end
-      end
-
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         begin
           table_name = get_table_name(sql)
@@ -186,7 +185,7 @@ module ActiveRecord
           if col != nil
             if query_contains_identity_column(sql, col)
               begin
-                execute enable_identity_insert(table_name, true)
+                enable_identity_insert(table_name, true)
                 ii_enabled = true
               rescue Exception => e
                 raise ActiveRecordError, "IDENTITY_INSERT could not be turned ON"
@@ -202,7 +201,7 @@ module ActiveRecord
         ensure
           if ii_enabled
             begin
-              execute enable_identity_insert(table_name, false)
+              enable_identity_insert(table_name, false)
             rescue Exception => e
               raise ActiveRecordError, "IDENTITY_INSERT could not be turned OFF"
             end
@@ -211,45 +210,62 @@ module ActiveRecord
       end
 
       def execute(sql, name = nil)
-        log(sql, name) do
-          @connection.context.reset
-          @connection.set_rowcount(@limit || 0)
-          @limit = @offset = nil
-          @connection.sql_norow(sql)
-          if @connection.cmd_fail? or @connection.context.failed?
-            raise "SQL Command Failed for #{name}: #{sql}\nMessage: #{@connection.context.message}"
-          end
-        end
-        # Return rows affected
+        raw_execute(sql, name)
         @connection.results[0].row_count
       end
 
-      alias_method :update, :execute
-      alias_method :delete, :execute
+      def begin_db_transaction()    raw_execute "BEGIN TRAN" end
+      def commit_db_transaction()   raw_execute "COMMIT TRAN" end
+      def rollback_db_transaction() raw_execute "ROLLBACK TRAN" end
 
-      def begin_db_transaction()    execute "BEGIN TRAN" end
-      def commit_db_transaction()   execute "COMMIT TRAN" end
-      def rollback_db_transaction() execute "ROLLBACK TRAN" end
+      def current_database
+        select_one("select DB_NAME() as name")["name"]
+      end
 
       def tables(name = nil)
-        tables = []
-        select("select name from sysobjects where type='U'", name).each do |row|
-          tables << row['name']
-        end
-        tables
+        select("select name from sysobjects where type='U'", name).map { |row| row['name'] }
       end
 
       def indexes(table_name, name = nil)
-        indexes = []
-        select("exec sp_helpindex #{table_name}", name).each do |index|
+        select("exec sp_helpindex #{table_name}", name).map do |index|
           unique = index["index_description"] =~ /unique/
           primary = index["index_description"] =~ /^clustered/
           if !primary
             cols = index["index_keys"].split(", ").each { |col| col.strip! }
-            indexes << IndexDefinition.new(table_name, index["index_name"], unique, cols)
+            IndexDefinition.new(table_name, index["index_name"], unique, cols)
           end
+        end.compact
+      end
+
+      def columns(table_name, name = nil)
+        sql = <<SQLTEXT
+SELECT col.name AS name, type.name AS type, col.prec, col.scale,
+  col.length, col.status, obj.sysstat2, def.text
+ FROM sysobjects obj, syscolumns col, systypes type, syscomments def
+ WHERE obj.id = col.id AND col.usertype = type.usertype AND col.cdefault *= def.id
+  AND obj.type = 'U' AND obj.name = '#{table_name}' ORDER BY col.colid
+SQLTEXT
+        @logger.debug "Get Column Info for table '#{table_name}'" if @logger
+        @connection.set_rowcount(0)
+        @connection.sql(sql)
+
+        raise "SQL Command for table_structure for #{table_name} failed\nMessage: #{@connection.context.message}" if @connection.context.failed?
+        return nil if @connection.cmd_fail?
+
+        @connection.top_row_result.rows.map do |row|
+          name, type, prec, scale, length, status, sysstat2, default = row
+          name.sub!(/_$/o, '')
+          type = normalize_type(type, prec, scale, length)
+          default_value = nil
+          if default =~ /DEFAULT\s+(.+)/o
+            default_value = $1.strip
+            default_value = default_value[1...-1] if default_value =~ /^['"]/o
+          end
+          nullable = (status & 8) == 8
+          identity = status >= 128
+          primary = (sysstat2 & 8) == 8
+          ColumnWithIdentity.new(name, default_value, type, nullable, identity, primary)
         end
-        indexes
       end
 
       def quoted_true
@@ -261,11 +277,13 @@ module ActiveRecord
       end
 
       def quote(value, column = nil)
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
         case value
           when String                
             if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
               "#{quote_string(column.class.string_to_binary(value))}"
-            elsif value =~ /^[+-]?[0-9]+$/o
+            elsif @numconvert && force_numeric?(column) && value =~ /^[+-]?[0-9]+$/o
               value
             else
               "'#{quote_string(value)}'"
@@ -273,39 +291,16 @@ module ActiveRecord
           when NilClass              then (column && column.type == :boolean) ? '0' : "NULL"
           when TrueClass             then '1'
           when FalseClass            then '0'
-          when Float, Fixnum, Bignum then value.to_s
-          when Date                  then "'#{value.to_s}'" 
+          when Float, Fixnum, Bignum then force_numeric?(column) ? value.to_s : "'#{value.to_s}'"
           when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-          else                            "'#{quote_string(value.to_yaml)}'"
+          else                       super
         end
       end
 
-      def quote_column(type, value)
-        case type
-          when :boolean
-            case value
-              when String then value =~ /^[ty]/o ? 1 : 0
-              when true   then 1
-              when false  then 0
-              else             value.to_i
-            end
-          when :integer then value.to_i
-          when :float   then value.to_f
-          when :text, :string, :enum
-            case value
-              when String, Symbol, Fixnum, Float, Bignum, TrueClass, FalseClass 
-                "'#{quote_string(value.to_s)}'"
-              else
-                "'#{quote_string(value.to_yaml)}'"
-            end
-          when :date, :datetime, :time
-            case value
-              when Time, DateTime then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-              when Date           then "'#{value.to_s}'"
-              else                     "'#{quote_string(value)}'"
-            end
-          else "'#{quote_string(value.to_yaml)}'"
-        end
+      # True if column is explicitly declared non-numeric, or
+      # if column is nil (not specified).
+      def force_numeric?(column)
+        (column.nil? || [:integer, :float, :decimal].include?(column.type))
       end
 
       def quote_string(s)
@@ -313,13 +308,15 @@ module ActiveRecord
       end
 
       def quote_column_name(name)
-        "[#{name}]"
+        # If column name is close to max length, skip the quotes, since they
+        # seem to count as part of the length.
+        ((name.to_s.length + 2) <= table_alias_length) ? "[#{name}]" : name.to_s
       end
 
       def add_limit_offset!(sql, options) # :nodoc:
         @limit = options[:limit]
         @offset = options[:offset]
-        if !normal_select?
+        if use_temp_table?
           # Use temp table to hack offset with Sybase
           sql.sub!(/ FROM /i, ' INTO #artemp FROM ')
         elsif zero_limit?
@@ -335,6 +332,11 @@ module ActiveRecord
         end
       end
 
+      def add_lock!(sql, options) #:nodoc:
+        @logger.info "Warning: Sybase :lock option '#{options[:lock].inspect}' not supported" if @logger && options.has_key?(:lock)
+        sql
+      end
+
       def supports_migrations? #:nodoc:
         true
       end
@@ -348,12 +350,18 @@ module ActiveRecord
       end
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        sql_commands = ["ALTER TABLE #{table_name} MODIFY #{column_name} #{type_to_sql(type, options[:limit])}"]
-        if options[:default]
+        begin
+          execute "ALTER TABLE #{table_name} MODIFY #{column_name} #{type_to_sql(type, options[:limit])}"
+        rescue StatementInvalid => e
+          # Swallow exception and reset context if no-op.
+          raise e unless e.message =~ /no columns to drop, add or modify/
+          @connection.context.reset
+        end
+
+        if options.has_key?(:default)
           remove_default_constraint(table_name, column_name)
-          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{options[:default]} FOR #{column_name}"
+          execute "ALTER TABLE #{table_name} REPLACE #{column_name} DEFAULT #{quote options[:default]}"
         end
-        sql_commands.each { |c| execute(c) }
       end
 
       def remove_column(table_name, column_name)
@@ -362,10 +370,10 @@ module ActiveRecord
       end
 
       def remove_default_constraint(table_name, column_name)
-        defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
-        defaults.each {|constraint|
+        sql = "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
+        select(sql).each do |constraint|
           execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
-        }
+        end
       end
 
       def remove_index(table_name, options = {})
@@ -373,7 +381,7 @@ module ActiveRecord
       end
 
       def add_column_options!(sql, options) #:nodoc:
-        sql << " DEFAULT #{quote(options[:default], options[:column])}" unless options[:default].nil?
+        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
 
         if check_null_for_column?(options[:column], sql)
           sql << (options[:null] == false ? " NOT NULL" : " NULL")
@@ -381,6 +389,12 @@ module ActiveRecord
         sql
       end
 
+      def enable_identity_insert(table_name, enable = true)
+        if has_identity_column(table_name)
+          execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+        end
+      end
+
     private
       def check_null_for_column?(col, sql)
         # Sybase columns are NOT NULL by default, so explicitly set NULL
@@ -424,34 +438,44 @@ module ActiveRecord
         end
       end
 
-      def normal_select?
-        # If limit is not set at all, we can ignore offset;
-        # If limit *is* set but offset is zero, use normal select
-        # with simple SET ROWCOUNT.  Thus, only use the temp table
-        # if limit is set and offset > 0.
-        has_limit = !@limit.nil?
-        has_offset = !@offset.nil? && @offset > 0
-        !has_limit || !has_offset
+      # If limit is not set at all, we can ignore offset;
+      # if limit *is* set but offset is zero, use normal select
+      # with simple SET ROWCOUNT.  Thus, only use the temp table
+      # if limit is set and offset > 0.
+      def use_temp_table?
+        !@limit.nil? && !@offset.nil? && @offset > 0
       end
 
       def zero_limit?
         !@limit.nil? && @limit == 0
       end
 
-      # Select limit number of rows starting at optional offset.
-      def select(sql, name = nil)
-        @connection.context.reset
+      def raw_execute(sql, name = nil)
         log(sql, name) do
-          if normal_select?
-            # If limit is not explicitly set, return all results.
-            @logger.debug "Setting row count to (#{@limit || 'off'})" if @logger
-
-            # Run a normal select
-            @connection.set_rowcount(@limit || 0)
+          @connection.context.reset
+          @logger.debug "Setting row count to (#{@limit})" if @logger && @limit
+          @connection.set_rowcount(@limit || 0)
+          if sql =~ /^\s*SELECT/i
             @connection.sql(sql)
           else
+            @connection.sql_norow(sql)
+          end
+          @limit = @offset = nil
+          if @connection.cmd_fail? or @connection.context.failed?
+            raise "SQL Command Failed for #{name}: #{sql}\nMessage: #{@connection.context.message}"
+          end
+        end
+      end
+
+      # Select limit number of rows starting at optional offset.
+      def select(sql, name = nil)
+        if !use_temp_table?
+          execute(sql, name)
+        else
+          log(sql, name) do
             # Select into a temp table and prune results
             @logger.debug "Selecting #{@limit + (@offset || 0)} or fewer rows into #artemp" if @logger
+            @connection.context.reset
             @connection.set_rowcount(@limit + (@offset || 0))
             @connection.sql_norow(sql)  # Select into temp table
             @logger.debug "Deleting #{@offset || 0} or fewer rows from #artemp" if @logger
@@ -462,29 +486,21 @@ module ActiveRecord
           end
         end
 
+        raise StatementInvalid, "SQL Command Failed for #{name}: #{sql}\nMessage: #{@connection.context.message}" if @connection.context.failed? or @connection.cmd_fail?
+      
         rows = []
-        if @connection.context.failed? or @connection.cmd_fail?
-          raise StatementInvalid, "SQL Command Failed for #{name}: #{sql}\nMessage: #{@connection.context.message}"
-        else
-          results = @connection.top_row_result
-          if results && results.rows.length > 0
-            fields = fixup_column_names(results.columns)
-            results.rows.each do |row|
-              hashed_row = {}
-              row.zip(fields) { |cell, column| hashed_row[column] = cell }
-              rows << hashed_row
-            end
+        results = @connection.top_row_result
+        if results && results.rows.length > 0
+          fields = results.columns.map { |column| column.sub(/_$/, '') }
+          results.rows.each do |row|
+            hashed_row = {}
+            row.zip(fields) { |cell, column| hashed_row[column] = cell }
+            rows << hashed_row
           end
         end
-        @connection.sql_norow("drop table #artemp") if !normal_select?
+        @connection.sql_norow("drop table #artemp") if use_temp_table?
         @limit = @offset = nil
-        return rows
-      end
-
-      def enable_identity_insert(table_name, enable = true)
-        if has_identity_column(table_name)
-          "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-        end
+        rows
       end
 
       def get_table_name(sql)
@@ -502,80 +518,42 @@ module ActiveRecord
       end
 
       def get_identity_column(table_name)
-        @table_columns = {} unless @table_columns
-        @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
-        @table_columns[table_name].each do |col|
-          return col.name if col.identity
+        @id_columns ||= {}
+        if !@id_columns.has_key?(table_name)
+          @logger.debug "Looking up identity column for table '#{table_name}'" if @logger
+          col = columns(table_name).detect { |col| col.identity }
+          @id_columns[table_name] = col.nil? ? nil : col.name
         end
-
-        return nil
+        @id_columns[table_name]
       end
 
       def query_contains_identity_column(sql, col)
         sql =~ /\[#{col}\]/
       end
 
-      # Remove trailing _ from names.
-      def fixup_column_names(columns)
-        columns.map { |column| column.sub(/_$/, '') }
-      end
-
-      def table_structure(table_name)
-        sql = <<SQLTEXT
-SELECT col.name AS name, type.name AS type, col.prec, col.scale, col.length,
-  col.status, obj.sysstat2, def.text
- FROM sysobjects obj, syscolumns col, systypes type, syscomments def
- WHERE obj.id = col.id AND col.usertype = type.usertype AND col.cdefault *= def.id
-  AND obj.type = 'U' AND obj.name = '#{table_name}' ORDER BY col.colid
-SQLTEXT
-        log(sql, "Get Column Info ") do
-          @connection.set_rowcount(0)
-          @connection.sql(sql)
-        end
-        if @connection.context.failed?
-          raise "SQL Command for table_structure for #{table_name} failed\nMessage: #{@connection.context.message}"
-        elsif !@connection.cmd_fail?
-          columns = []
-          results = @connection.top_row_result
-          results.rows.each do |row|
-            name, type, prec, scale, length, status, sysstat2, default = row
-            type = normalize_type(type, prec, scale, length)
-            default_value = nil
-            name.sub!(/_$/o, '')
-            if default =~ /DEFAULT\s+(.+)/o
-              default_value = $1.strip
-              default_value = default_value[1...-1] if default_value =~ /^['"]/o
-            end
-            nullable = (status & 8) == 8
-            identity = status >= 128
-            primary = (sysstat2 & 8) == 8
-
-            columns << [name, default_value, type, nullable, identity, primary]
-          end
-          columns
-        else
-          nil
-        end
+      # Resolve all user-defined types (udt) to their fundamental types.
+      def resolve_type(field_type)
+        (@udts ||= {})[field_type] ||= select_one("sp_help #{field_type}")["Storage_type"].strip
       end
 
       def normalize_type(field_type, prec, scale, length)
-        if field_type =~ /numeric/i and (scale.nil? or scale == 0)
-          type = 'int'
+        has_scale = (!scale.nil? && scale > 0)
+        type = if field_type =~ /numeric/i and !has_scale
+          'int'
         elsif field_type =~ /money/i
-          type = 'numeric'
+          'numeric'
         else
-          type = field_type
-        end
-        size = ''
-        if prec
-          size = "(#{prec})"
-        elsif length
-          size = "(#{length})"
+          resolve_type(field_type.strip)
         end
-        return type + size
-      end
 
-      def default_value(value)
+        spec = if prec
+          has_scale ? "(#{prec},#{scale})" : "(#{prec})"
+        elsif length && !(type =~ /date|time|text/)
+          "(#{length})"
+        else
+          ''
+        end
+        "#{type}#{spec}"
       end
     end # class SybaseAdapter
 
@@ -667,18 +645,18 @@ class Fixtures
   alias :original_insert_fixtures :insert_fixtures
 
   def insert_fixtures
-    values.each do |fixture|
-      allow_identity_inserts table_name, true
-      @connection.execute "INSERT INTO #{@table_name} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
-      allow_identity_inserts table_name, false
+    if @connection.instance_of?(ActiveRecord::ConnectionAdapters::SybaseAdapter)
+      values.each do |fixture|
+        @connection.enable_identity_insert(table_name, true)
+        @connection.execute "INSERT INTO #{@table_name} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
+        @connection.enable_identity_insert(table_name, false)
+      end
+    else
+      original_insert_fixtures
     end
   end
-
-  def allow_identity_inserts(table_name, enable)
-      @connection.execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}" rescue nil
-  end
 end
 
 rescue LoadError => cannot_require_sybase
   # Couldn't load sybase adapter
-end
+end