Works under Rails v4.0.0

activerecord-sqlserver-adapter.gemspec

@@ -16,6 +16,6 @@ Gem::Specification.new do |s|
   s.require_path  = 'lib'
   s.rubyforge_project = 'activerecord-sqlserver-adapter'
 
-  s.add_dependency('activerecord', '~> 3.2.0')
+  s.add_dependency('activerecord', '4')
 end
 

lib/active_record/connection_adapters/sqlserver/core_ext/database_statements.rb

@@ -44,15 +44,15 @@ def transaction_with_retry_deadlock_victim(options = {})
                 if open_transactions == 0
                   if database_transaction_rollback.is_a?(::ActiveRecord::DeadlockVictim)
                     # SQL Server has already rolled back, so rollback activerecord's history
-                    rollback_transaction_records(true)
+                    rollback_transaction
                     retry
                   else
                     rollback_db_transaction
-                    rollback_transaction_records(true)
+                    #rollback_transaction_records(true)
                   end
                 else
                   rollback_to_savepoint
-                  rollback_transaction_records(false)
+                  rollback_transaction
                 end
               end
               raise unless database_transaction_rollback.is_a?(::ActiveRecord::Rollback)
@@ -67,7 +67,7 @@ def transaction_with_retry_deadlock_victim(options = {})
               begin
                 if open_transactions == 0
                   commit_db_transaction
-                  commit_transaction_records
+                  # commit_transaction_records
                 else
                   release_savepoint
                   save_point_records = @_current_transaction_records.pop
@@ -79,10 +79,10 @@ def transaction_with_retry_deadlock_victim(options = {})
               rescue Exception => database_transaction_rollback
                 if open_transactions == 0
                   rollback_db_transaction
-                  rollback_transaction_records(true)
+                  #rollback_transaction_records(true)
                 else
                   rollback_to_savepoint
-                  rollback_transaction_records(false)
+                  #rollback_transaction_records(false)
                 end
                 raise
               end

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -18,14 +18,16 @@ def execute(sql, name = nil)
         end
 
         def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
+          # This is so no id is tried to be updated
+          sql.gsub! /, \[id\] = @[0-9]*/, '' if sql =~ /UPDATE/ && sql =~ /, \[id\] = /
           if id_insert_table_name = sqlserver_options[:insert] ? query_requires_identity_insert?(sql) : nil
             with_identity_insert_enabled(id_insert_table_name) { do_exec_query(sql, name, binds) }
           else
             do_exec_query(sql, name, binds)
           end
         end
 
-        def exec_insert(sql, name, binds)
+        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
           exec_query sql, name, binds, :insert => true
         end
 
@@ -135,9 +137,11 @@ def use_database(database=nil)
 
         def user_options
           return {} if sqlserver_azure?
-          select_rows("dbcc useroptions",'SCHEMA').inject(HashWithIndifferentAccess.new) do |values,row| 
-            set_option = row[0].gsub(/\s+/,'_')
-            user_value = row[1]
+          select_rows("dbcc useroptions",'SCHEMA').inject(HashWithIndifferentAccess.new) do |values,row|
+            set_option = row.values[0].gsub(/\s+/,'_') if row.instance_of? Hash
+            set_option = row[0].gsub(/\s+/,'_') if row.instance_of? Array
+            user_value = row.values[1]  if row.instance_of? Hash
+            user_value = row[1]  if row.instance_of? Array
             values[set_option] = user_value
             values
           end
@@ -294,7 +298,7 @@ def charset
         protected
 
         def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds).to_a
+          exec_query(sql, name, binds)
         end
 
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -47,39 +47,28 @@ def columns(table_name, name = nil)
         def rename_table(table_name, new_name)
           do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
         end
-
-        def remove_column(table_name, *column_names)
-          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
-          ActiveSupport::Deprecation.warn 'Passing array to remove_columns is deprecated, please use multiple arguments, like: `remove_columns(:posts, :foo, :bar)`', caller if column_names.flatten!
-          column_names.flatten.each do |column_name|
-            remove_check_constraints(table_name, column_name)
-            remove_default_constraint(table_name, column_name)
-            remove_indexes(table_name, column_name)
-            do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
-          end
+
+        def remove_column(table_name, column_name, type = nil)
+          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if (column_name.is_a? Array)
+          ActiveSupport::Deprecation.warn 'Passing multiple arguments to remove_columns is deprecated, please use just one column name, like: `remove_columns(:posts, :column_name, :type)`', caller if column_name
+          remove_check_constraints(table_name, column_name)
+          remove_default_constraint(table_name, column_name)
+          remove_indexes(table_name, column_name)
+          do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
         end
 
         def change_column(table_name, column_name, type, options = {})
           sql_commands = []
-          indexes = []
           column_object = schema_cache.columns[table_name].detect { |c| c.name.to_s == column_name.to_s }
-
+          change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          change_column_sql << " NOT NULL" if options[:null] == false
+          sql_commands << change_column_sql
           if options_include_default?(options) || (column_object && column_object.type != type.to_sym)
-            remove_default_constraint(table_name,column_name)
-            indexes = indexes(table_name).select{ |index| index.columns.include?(column_name.to_s) }
-            remove_indexes(table_name, column_name)
+           	remove_default_constraint(table_name,column_name)
           end
-          sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(options[:default])} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
-          sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          sql_commands[-1] << " NOT NULL" if !options[:null].nil? && options[:null] == false
           if options_include_default?(options)
             sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name,column_name)} DEFAULT #{quote(options[:default])} FOR #{quote_column_name(column_name)}"
           end
-
-          #Add any removed indexes back
-          indexes.each do |index|
-            sql_commands << "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index.columns.collect {|c|quote_column_name(c)}.join(', ')})"
-          end
           sql_commands.each { |c| do_execute(c) }
         end