activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/lib/arjdbc/jdbc/base_ext.rb

@@ -1,15 +1,40 @@
 module ActiveRecord
-  class Base  # reopen
+  # ActiveRecord::Base extensions.
+  Base.class_eval do
     class << self
-      # Allow adapters to provide their own reset_column_information methods
-      #
-      # NOTE: This only affects the current thread's connection.
-      def reset_column_information_with_arjdbc_base_ext
-        # Invoke the adapter-specific reset_column_information method
+      # Allow adapters to provide their own {#reset_column_information} method.
+      # @note This only affects the current thread's connection.
+      def reset_column_information_with_arjdbc
+        # invoke the adapter-specific reset_column_information method
         connection.reset_column_information if connection.respond_to?(:reset_column_information)
-        reset_column_information_without_arjdbc_base_ext
+        reset_column_information_without_arjdbc
+      end
+      unless method_defined?("reset_column_information_without_arjdbc")
+        alias_method_chain :reset_column_information, :arjdbc
+      end
+    end
+  end
+  
+  # Represents exceptions that have propagated up through the JDBC API.
+  class JDBCError < ActiveRecordError
+    # The vendor code or error number that came from the database
+    attr_accessor :errno
+    # The full Java SQLException object that was raised.
+    attr_accessor :sql_exception
+  end
+
+  module ConnectionAdapters # :nodoc:
+    # Allows properly re-defining methods that may already be alias_method_chain'd.
+    module ShadowCoreMethods
+      def alias_chained_method(name, feature, target)
+        # NOTE: aliasing for things such as columns (with feature query_cache)
+        # seems to only be used for 2.3 since 3.0 methods are not aliased ...
+        if method_defined?(method = "#{name}_without_#{feature}")
+          alias_method method, target
+        else
+          alias_method name, target if name.to_s != target.to_s
+        end
       end
-      alias_method_chain :reset_column_information, :arjdbc_base_ext unless instance_methods.include?("reset_column_information_without_arjdbc_base_ext")
     end
   end
-end
+end

data/lib/arjdbc/jdbc/column.rb

@@ -3,14 +3,27 @@ module ActiveRecord
     class JdbcColumn < Column
       attr_writer :limit, :precision
 
-      def initialize(config, name, default, *args)
-        call_discovered_column_callbacks(config)
+      def initialize(config, name, *args)
+        if self.class == JdbcColumn
+          # NOTE: extending classes do not want this if they do they shall call
+          call_discovered_column_callbacks(config) if config
+          default = args.shift
+        else # for extending classes allow ignoring first argument :
+          if ! config.nil? && ! config.is_a?(Hash)
+            # initialize(name, default, *args)
+            default = name; name = config
+          else
+            default = args.shift
+          end
+        end
+        # super : (name, default, sql_type = nil, null = true)
         super(name, default_value(default), *args)
         init_column(name, default, *args)
       end
 
       def init_column(*args); end
 
+      # NOTE: our custom #extract_value_from_default(default)
       def default_value(value); value; end
 
       protected

data/lib/arjdbc/jdbc/connection.rb

@@ -20,8 +20,6 @@ module ActiveRecord
         connection # force the connection to load (@see RubyJDbcConnection.connection)
         set_native_database_types
         @stmts = {} # AR compatibility - statement cache not used
-      rescue ::ActiveRecord::ActiveRecordError
-        raise
       rescue Java::JavaSql::SQLException => e
         e = e.cause if defined?(NativeException) && e.is_a?(NativeException) # JRuby-1.6.8
         error = e.getMessage || e.getSQLState

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -1,5 +1,11 @@
-class ActiveRecord::Base
-  class << self
+module ArJdbc
+  if defined? ActiveRecord::ConnectionHandling # 4.0
+    ConnectionMethods = ActiveRecord::ConnectionHandling
+  else # 3.x
+    ConnectionMethods = (class << ActiveRecord::Base; self; end)
+  end
+  ConnectionMethods.module_eval do
+    
     def jdbc_connection(config)
       adapter_class = config[:adapter_class]
       adapter_class ||= ::ActiveRecord::ConnectionAdapters::JdbcAdapter
@@ -12,5 +18,6 @@ class ActiveRecord::Base
       config[:password] ||= ""
       jdbc_connection(config)
     end
+    
   end
-end
+end

data/lib/arjdbc/jdbc/driver.rb

@@ -13,11 +13,11 @@ module ActiveRecord
           properties.each { |key, val| @properties[key] = val.to_s } if properties
         end
       end
-
+      
       def driver_class
         @driver_class ||= begin
           driver_class_const = (@name[0...1].capitalize + @name[1..@name.length]).gsub(/\./, '_')
-          Jdbc::Mutex.synchronized do
+          Jdbc::DriverManager.java_class.synchronized do # avoid 2 threads here
             unless Jdbc.const_defined?(driver_class_const)
               driver_class_name = @name
               Jdbc.module_eval do

data/lib/arjdbc/jdbc/extension.rb

@@ -1,31 +1,28 @@
 module ArJdbc
-  # Defines an AR-JDBC extension. An extension consists of a
-  # declaration using this method and an ArJdbc::XYZ module that
-  # contains implementation and overrides for methods in
-  # ActiveRecord::ConnectionAdapters::AbstractAdapter. When you
-  # declare your extension, you provide a block that detects when a
-  # database configured to use the extension is present and loads the
-  # necessary code for it. AR-JDBC will patch the code into the base
-  # ActiveRecord::ConnectionAdapters::JdbcAdapter by extending an
-  # instance of it with your extension module.
+  
+  # Defines an AR-JDBC extension. An extension consists of a declaration using 
+  # this method and an ArJdbc::XYZ module that contains implementation and 
+  # overrides for methods in ActiveRecord::ConnectionAdapters::AbstractAdapter. 
+  # When you declare your extension, you provide a block that detects when a
+  # database configured to use the extension is present and loads the necessary 
+  # code for it. AR-JDBC will patch the code into the base JdbcAdapter by 
+  # extending an instance of it with your extension module.
   #
-  # +name+ should be a symbol that is the name of a module to be
-  # defined under the +ArJdbc+ module.
+  # +name+ the name of a module to be defined under the +ArJdbc+ module.
   #
-  # +block+ should be a one- or two-arity block that receives the
-  # dialect name or driver class name as the first argument, and
-  # optionally the whole database configuration hash as a second
-  # argument.
+  # +block+ should be a one- or two-arity block that receives the dialect name 
+  # or driver class name as the first argument, and optionally the whole 
+  # database configuration hash as a second argument
   #
   # Example:
   #
-  #     ArJdbc.extension :Frob do |name|
-  #       if name =~ /frob/i
-  #         # arjdbc/frob.rb should contain the implementation
-  #         require 'arjdbc/frob'
-  #         true
-  #       end
+  #   ArJdbc.extension :FRoB do |name|
+  #     if name =~ /frob/i
+  #       require 'arjdbc/frob' # contains ArJdbc::FRoB
+  #       true
   #     end
+  #   end
+  #
   def self.extension(name, &block)
     if const_defined?(name)
       mod = const_get(name)
@@ -44,4 +41,21 @@ module ArJdbc
       end
     end
   end
+  
+  private
+  def self.discover_extensions
+    if defined?(::Gem) && ::Gem.respond_to?(:find_files)
+      files = ::Gem.find_files('arjdbc/discover')
+    else
+      files = $LOAD_PATH.map do |p|
+        discover = File.join(p, 'arjdbc', 'discover.rb')
+        File.exist?(discover) ? discover : nil
+      end.compact
+    end
+    files.each do |file|
+      puts "Loading AR-JDBC extension #{file}" if $DEBUG
+      require file
+    end
+  end
+  
 end

data/lib/arjdbc/jdbc/java.rb

@@ -4,11 +4,9 @@ require 'arjdbc/jdbc/adapter_java'
 module ActiveRecord
   module ConnectionAdapters
     module Jdbc
-      Mutex = java.lang.Object.new
       DriverManager = java.sql.DriverManager
       Types = java.sql.Types
     end
-
     java_import "arjdbc.jdbc.JdbcConnectionFactory"
   end
 end

data/lib/arjdbc/jdbc/missing_functionality_helper.rb

@@ -1,42 +1,44 @@
 module ArJdbc
   module MissingFunctionalityHelper
-    #Taken from SQLite adapter
+    
+    # taken from SQLite adapter, code loosely based on http://git.io/P7tFQA
 
     def alter_table(table_name, options = {}) #:nodoc:
       table_name = table_name.to_s.downcase
-      altered_table_name = "altered_#{table_name}"
-      caller = lambda {|definition| yield definition if block_given?}
+      altered_table_name = "a#{table_name}"
+      caller = lambda { |definition| yield definition if block_given? }
 
       transaction do
         # A temporary table might improve performance here, but
         # it doesn't seem to maintain indices across the whole move.
-        move_table(table_name, altered_table_name,
-          options)
+        move_table(table_name, altered_table_name, options)
         move_table(altered_table_name, table_name, &caller)
       end
     end
-
+    
     def move_table(from, to, options = {}, &block) #:nodoc:
       copy_table(from, to, options, &block)
       drop_table(from)
     end
 
-    def copy_table(from, to, options = {}) #:nodoc:
-      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
-      create_table(to, options) do |definition|
+    def copy_table(from, to, options = {}) # :nodoc:
+      from_primary_key = primary_key(from)
+      create_table(to, options.merge(:id => false)) do |definition|
         @definition = definition
+        @definition.primary_key(from_primary_key) if from_primary_key.present?
         columns(from).each do |column|
           column_name = options[:rename] ?
             (options[:rename][column.name] ||
              options[:rename][column.name.to_sym] ||
              column.name) : column.name
-
+         
+          next if column_name == from_primary_key
+          
           @definition.column(column_name, column.type,
             :limit => column.limit, :default => column.default,
             :precision => column.precision, :scale => column.scale,
             :null => column.null)
         end
-        @definition.primary_key(primary_key(from)) if primary_key(from)
         yield @definition if block_given?
       end
 
@@ -49,20 +51,19 @@ module ArJdbc
     def copy_table_indexes(from, to, rename = {}) #:nodoc:
       indexes(from).each do |index|
         name = index.name.downcase
-        if to == "altered_#{from}"
-          name = "temp_#{name}"
-        elsif from == "altered_#{to}"
-          name = name[5..-1]
+        if to == "a#{from}"
+          name = "t#{name}"
+        elsif from == "a#{to}"
+          name = name[1..-1]
         end
 
         to_column_names = columns(to).map(&:name)
-        columns = index.columns.map {|c| rename[c] || c }.select do |column|
-          to_column_names.include?(column)
-        end
+        columns = index.columns.map { |column| rename[column] || column }
+        columns = columns.select { |column| to_column_names.include?(column) }
 
         unless columns.empty?
           # index name can't be the same
-          opts = { :name => name.gsub(/(_?)(#{from})_/, "\\1#{to}_") }
+          opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), :internal => true }
           opts[:unique] = true if index.unique
           add_index(to, columns, opts)
         end
@@ -70,19 +71,28 @@ module ArJdbc
     end
 
     def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-      column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
-      rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
+      column_mappings = Hash[ columns.map { |name| [name, name] } ]
+      rename.each { |a| column_mappings[a.last] = a.first }
       from_columns = columns(from).collect {|col| col.name}
-      columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
+      columns = columns.find_all{ |col| from_columns.include?(column_mappings[col]) }
       quoted_columns = columns.map { |col| quote_column_name(col) } * ','
 
       quoted_to = quote_table_name(to)
-      execute("SELECT * FROM #{quote_table_name(from)}").each do |row|
+      
+      raw_column_mappings = Hash[ columns(from).map { |c| [c.name, c] } ]
+      
+      execute("SELECT * FROM #{quote_table_name(from)}", 'Copy Table').each do |row|
         sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
-        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+        
+        column_values = columns.map do |col|
+          quote(row[column_mappings[col]], raw_column_mappings[col])
+        end
+
+        sql << column_values * ', '
         sql << ')'
-        execute sql
+        exec_insert sql, 'Copy Table', []
       end
     end
+    
   end
 end

data/lib/arjdbc/jdbc/railtie.rb

@@ -1,9 +1,2 @@
-require 'rails/railtie'
-
-module ::ArJdbc
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load File.expand_path('../rake_tasks.rb', __FILE__)
-    end
-  end
-end
+warn "DEPRECATED: require 'arjdbc/railtie' instead of 'arjdbc/jdbc/railtie' "
+require 'arjdbc/railtie'

data/lib/arjdbc/mimer.rb

@@ -1,2 +1,2 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/mimer/adapter'

data/lib/arjdbc/mssql.rb

@@ -1,6 +1,6 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/mssql/adapter'
 require 'arjdbc/mssql/connection_methods'
 module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
-end
+end

data/lib/arjdbc/mssql/adapter.rb

@@ -3,12 +3,15 @@ require 'arjdbc/mssql/utils'
 require 'arjdbc/mssql/tsql_methods'
 require 'arjdbc/mssql/limit_helpers'
 require 'arjdbc/mssql/lock_helpers'
+require 'arjdbc/mssql/explain_support'
 require 'arjdbc/jdbc/serialized_attributes_helper'
 
 module ArJdbc
   module MSSQL
     include Utils
     include TSqlMethods
+    
+    include ExplainSupport
 
     @@_lob_callback_added = nil
     
@@ -39,8 +42,13 @@ module ArJdbc
         extend LimitHelpers::SqlServerAddLimitOffset
       end
       base.config[:sqlserver_version] ||= version
+      base.configure_connection
     end
 
+    def configure_connection
+      use_database # config[:database]
+    end
+    
     def self.column_selector
       [ /sqlserver|tds|Microsoft SQL/i, lambda { |cfg, column| column.extend(::ArJdbc::MSSQL::Column) } ]
     end
@@ -49,6 +57,10 @@ module ArJdbc
       ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
     end
 
+    def jdbc_column_class
+      ::ActiveRecord::ConnectionAdapters::MSSQLColumn
+    end
+    
     def self.arel2_visitors(config)
       require 'arel/visitors/sql_server'
       visitors = config[:sqlserver_version] == '2000' ? 
@@ -101,7 +113,8 @@ module ArJdbc
     module Column
       include LockHelpers::SqlServerAddLock
 
-      attr_accessor :identity, :is_special
+      attr_accessor :identity, :special
+      alias_method :is_special, :special # #deprecated
 
       def simplified_type(field_type)
         case field_type
@@ -145,6 +158,14 @@ module ArJdbc
 
       def extract_limit(sql_type)
         case sql_type
+        when /^smallint/i
+          2
+        when /^int/i
+          4
+        when /^bigint/i
+          8
+        when /\(max\)/, /decimal/, /numeric/
+          nil
         when /text|ntext|xml|binary|image|varbinary|bit/
           nil
         else
@@ -153,7 +174,7 @@ module ArJdbc
       end
 
       def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
+        !!( sql_type =~ /nvarchar|ntext|nchar/i )
       end
 
       def unquote(value)
@@ -220,16 +241,75 @@ module ArJdbc
         else
           super
         end
+      when Date, Time
+        if column && column.type == :time
+          "'#{quoted_time(value)}'"
+        elsif column && column.sql_type.index('datetimeoffset')
+          "'#{quoted_full_iso8601(value)}'"
+        elsif column && column.sql_type.index('datetime')
+          "'#{quoted_datetime(value)}'"
+        else
+          super
+        end
       when TrueClass  then '1'
       when FalseClass then '0'
       else super
       end
     end
+    
+    def quoted_date(value)
+      if value.respond_to?(:usec)
+        "#{super}.#{sprintf("%03d", value.usec / 1000)}"
+      else
+        super
+      end
+    end
 
+    def quoted_datetime(value)
+      if value.acts_like?(:time)
+        time_zone_qualified_value = quoted_value_acts_like_time_filter(value)
+        if value.is_a?(Date)
+          time_zone_qualified_value.to_time.xmlschema.to(18)
+        else
+          if value.is_a?(ActiveSupport::TimeWithZone) && RUBY_VERSION < '1.9'
+            time_zone_qualified_value = time_zone_qualified_value.to_time
+          end
+          time_zone_qualified_value.iso8601(3).to(22)
+        end
+      else
+        quoted_date(value)
+      end
+    end
+    
+    def quoted_time(value)
+      if value.acts_like?(:time)
+        tz_value = quoted_value_acts_like_time_filter(value)
+        sprintf("%02d:%02d:%02d.%03d", tz_value.hour, tz_value.min, tz_value.sec, value.usec / 1000)
+      else
+        quoted_date(value)
+      end
+    end
+    
+    def quoted_full_iso8601(value)
+      if value.acts_like?(:time)
+        value.is_a?(Date) ? 
+          quoted_value_acts_like_time_filter(value).to_time.xmlschema.to(18) : 
+            quoted_value_acts_like_time_filter(value).iso8601(7).to(22)
+      else
+        quoted_date(value)
+      end
+    end
+        
+    def quoted_value_acts_like_time_filter(value)
+      method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+      value.respond_to?(method) ? value.send(method) : value
+    end
+    protected :quoted_value_acts_like_time_filter
+    
     def quote_table_name(name)
       quote_column_name(name)
     end
-
+    
     def quote_column_name(name)
       name.to_s.split('.').map do |n| # "[#{name}]"
         n =~ /^\[.*\]$/ ? n : "[#{n.gsub(']', ']]')}]"
@@ -257,40 +337,99 @@ module ArJdbc
       true
     end
 
+    # NOTE: Dynamic Name Resolution - SQL Server 2000 vs. 2005
+    # 
+    # A query such as "select * from table1" in SQL Server 2000 goes through 
+    # a set of steps to resolve and validate the object references before 
+    # execution. 
+    # The search first looks at the identity of the connection executing 
+    # the query.
+    # 
+    # However SQL Server 2005 provides a mechanism to allow finer control over
+    # name resolution to the administrators. By manipulating the value of the 
+    # default_schema_name columns in the sys.database_principals.
+    # 
+    # http://blogs.msdn.com/b/mssqlisv/archive/2007/03/23/upgrading-to-sql-server-2005-and-default-schema-setting.aspx
+    
+    # Returns the default schema (to be used for table resolution) used for 
+    # the {#current_user}.
+    def default_schema
+      return current_user if sqlserver_2000?
+      @default_schema ||= 
+        select_value("SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER")
+    end
+    alias_method :current_schema, :default_schema
+
+    # Allows for changing of the default schema (to be used during unqualified
+    # table name resolution).
+    # @note This is not supported on SQL Server 2000 !
+    def default_schema=(default_schema) # :nodoc:
+      raise "changing DEFAULT_SCHEMA only supported on SQLServer 2005+" if sqlserver_2000?
+      execute("ALTER #{current_user} WITH DEFAULT_SCHEMA=#{default_schema}")
+      @default_schema = nil if defined?(@default_schema)
+    end
+    alias_method :current_schema=, :default_schema=
+    
+    # `SELECT CURRENT_USER`
+    def current_user
+      @current_user ||= select_value("SELECT CURRENT_USER")
+    end
+    
+    def charset
+      select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
+    end
+    
+    def current_database
+      select_value 'SELECT DB_NAME()'
+    end
+    
+    def use_database(database = nil)
+      database ||= config[:database]
+      execute "USE #{quote_table_name(database)}" unless database.blank?
+    end
+    
     def recreate_database(name, options = {})
       drop_database(name)
       create_database(name, options)
     end
 
+    def recreate_database!(database = nil)
+      current_db = current_database
+      database ||= current_db
+      use_database('master') if this_db = ( database.to_s == current_db )
+      drop_database(database)
+      create_database(database)
+    ensure
+      use_database(current_db) if this_db
+    end
+    
     def drop_database(name)
-      execute "USE master"
-      execute "DROP DATABASE #{name}"
+      execute "DROP DATABASE #{quote_table_name(name)}"
     end
 
     def create_database(name, options = {})
-      execute "CREATE DATABASE #{name}"
-      execute "USE #{name}"
+      execute "CREATE DATABASE #{quote_table_name(name)}"
     end
-
-    def rename_table(name, new_name)
-      clear_cached_table(name)
-      execute "EXEC sp_rename '#{name}', '#{new_name}'"
+    
+    def rename_table(table_name, new_table_name)
+      clear_cached_table(table_name)
+      execute "EXEC sp_rename '#{table_name}', '#{new_table_name}'"
     end
 
     # Adds a new column to the named table.
     # See TableDefinition#column for details of the options you can use.
     def add_column(table_name, column_name, type, options = {})
       clear_cached_table(table_name)
-      add_column_sql = "ALTER TABLE #{table_name} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(add_column_sql, options)
       # TODO: Add support to mimic date columns, using constraints to mark them as such in the database
       # add_column_sql << " CONSTRAINT ck__#{table_name}__#{column_name}__date_only CHECK ( CONVERT(CHAR(12), #{quote_column_name(column_name)}, 14)='00:00:00:000' )" if type == :date
       execute(add_column_sql)
     end
 
-    def rename_column(table, column, new_column_name)
-      clear_cached_table(table)
-      execute "EXEC sp_rename '#{table}.#{column}', '#{new_column_name}'"
+    def rename_column(table_name, column_name, new_column_name)
+      clear_cached_table(table_name)
+      execute "EXEC sp_rename '#{table_name}.#{column_name}', '#{new_column_name}', 'COLUMN'"
     end
 
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
@@ -301,10 +440,8 @@ module ArJdbc
 
     def change_column_type(table_name, column_name, type, options = {}) #:nodoc:
       clear_cached_table(table_name)
-      sql = "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-      if options.has_key?(:null)
-        sql += (options[:null] ? " NULL" : " NOT NULL")
-      end
+      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])}"
+      sql += (options[:null] ? " NULL" : " NOT NULL") if options.has_key?(:null)
       execute(sql)
     end
 
@@ -312,16 +449,19 @@ module ArJdbc
       clear_cached_table(table_name)
       remove_default_constraint(table_name, column_name)
       unless default.nil?
-        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
+        execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
       end
     end
     
-    def remove_column(table_name, *column_names) #:nodoc:
+    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?
+      # remove_columns(:posts, :foo, :bar) old syntax : remove_columns(:posts, [:foo, :bar])
       clear_cached_table(table_name)
-      for column_name in column_names.flatten
+      column_names.flatten.each do |column_name|
         remove_check_constraints(table_name, column_name)
         remove_default_constraint(table_name, column_name)
-        execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+        remove_indexes(table_name, column_name) unless sqlserver_2000?
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
       end
     end
 
@@ -355,36 +495,54 @@ module ArJdbc
       end
     end
 
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    def remove_indexes(table_name, column_name)
+      indexes = self.indexes(table_name)
+      indexes.select{ |index| index.columns.include?(column_name.to_s) }.each do |index|
+        remove_index(table_name, { :name => index.name })
+      end
     end
-
-    def table_exists?(name)
-      !! ( jdbc_columns(name) rescue nil )
+    
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{quote_table_name(table_name)}.#{index_name(table_name, options)}"
     end
     
     SKIP_COLUMNS_TABLE_NAMES_RE = /^information_schema\./i # :nodoc:
+    IDENTITY_COLUMN_TYPE_RE = /identity/i # :nodoc:
+    # NOTE: these do not handle = equality as expected {#repair_special_columns}
+    # (TEXT, NTEXT, and IMAGE data types are deprecated)
+    SPECIAL_COLUMN_TYPE_RE = /text|ntext|image|xml/i # :nodoc:
     
-    def columns(table_name, name = nil)
+    EMPTY_ARRAY = [].freeze # :nodoc:
+    
+    def columns(table_name, name = nil, default = EMPTY_ARRAY)
       # It's possible for table_name to be an empty string, or nil, if something 
       # attempts to issue SQL which doesn't involve a table. 
       # IE. "SELECT 1" or "SELECT * FROM someFunction()".
-      return [] if table_name.blank?
+      return default if table_name.blank?
       
       table_name = unquote_table_name(table_name)
 
-      return [] if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
+      return default if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
       
-      unless (@table_columns ||= {})[table_name]
-        @table_columns[table_name] = super
-        @table_columns[table_name].each do |column|
-          column.identity = true if column.sql_type =~ /identity/i
-          column.is_special = true if column.sql_type =~ /text|ntext|image|xml/i
+      unless columns = ( @table_columns ||= {} )[table_name]
+        columns = super(table_name, name)
+        for column in columns
+          column.identity = true if column.sql_type =~ IDENTITY_COLUMN_TYPE_RE
+          column.special = true if column.sql_type =~ SPECIAL_COLUMN_TYPE_RE
         end
+        @table_columns[table_name] = columns
       end
-      @table_columns[table_name]
+      columns
     end
 
+    def clear_cached_table(table_name)
+      ( @table_columns ||= {} ).delete(table_name.to_s)
+    end
+
+    def reset_column_information
+      @table_columns = nil if defined? @table_columns
+    end
+    
     # Turns IDENTITY_INSERT ON for table during execution of the block
     # N.B. This sets the state of IDENTITY_INSERT to OFF after the
     # block has been executed without regard to its previous state
@@ -401,91 +559,107 @@ module ArJdbc
       raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned" + 
             " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
     end
-
-    def identity_column(table_name)
-      for column in columns(table_name)
-        return column.name if column.identity
-      end
-      nil
-    end
     
-    def query_requires_identity_insert?(sql)
+    # @see ArJdbc::MSSQL::LimitHelpers
+    def determine_order_clause(sql)
+      return $1 if sql =~ /ORDER BY (.*)$/i
       table_name = get_table_name(sql)
-      id_column = identity_column(table_name)
-      if sql.strip =~ /insert into [^ ]+ ?\((.+?)\)/i
-        insert_columns = $1.split(/, */).map(&method(:unquote_column_name))
-        return table_name if insert_columns.include?(id_column)
+      # determine primary key for table :
+      columns = self.columns(table_name)
+      primary_column = columns.find { |column| column.primary || column.identity }
+      unless primary_column # look for an id column and return it,
+        # without changing case, to cover DBs with a case-sensitive collation :
+        primary_column = columns.find { |column| column.name =~ /^id$/i }
+        raise "no columns for table: #{table_name}" if columns.empty?
       end
+      # NOTE: if still no PK column simply get something for ORDER BY ...
+      "#{table_name}.#{(primary_column || columns.first).name}"
     end
     
-    def determine_order_clause(sql)
-      return $1 if sql =~ /ORDER BY (.*)$/
-      table_name = get_table_name(sql)
-      "#{table_name}.#{determine_primary_key(table_name)}"
-    end
-
-    def determine_primary_key(table_name)
-      primary_key = columns(table_name).detect { |column| column.primary || column.identity }
-      return primary_key.name if primary_key
-      # Look for an id column and return it, 
-      # without changing case, to cover DBs with a case-sensitive collation :
-      columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
-      # Give up and provide something which is going to crash almost certainly
-      columns(table_name)[0].name
-    end
-
-    def clear_cached_table(name)
-      (@table_columns ||= {}).delete(name.to_s)
+    def exec_proc(proc_name, *variables)
+      vars = 
+        if variables.any? && variables.first.is_a?(Hash)
+          variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+        else
+          variables.map { |v| quote(v) }
+        end.join(', ')
+      sql = "EXEC #{proc_name} #{vars}".strip
+      log(sql, 'Execute Procedure') do
+        result = @connection.execute_query_raw(sql)
+        result.map! do |row| 
+          row = row.is_a?(Hash) ? row.with_indifferent_access : row
+          yield(row) if block_given?
+          row
+        end
+        result
+      end
     end
-
-    def reset_column_information
-      @table_columns = nil if defined? @table_columns
+    alias_method :execute_procedure, :exec_proc # AR-SQLServer-Adapter naming
+    
+    # @override
+    def exec_query(sql, name = 'SQL', binds = []) # :nodoc:
+      # NOTE: we allow to execute SQL as requested returning a results.
+      # e.g. this allows to use SQLServer's EXEC with a result set ...
+      sql = repair_special_columns to_sql(sql, binds)
+      log(sql, name || 'SQL') { @connection.execute_query(sql) }
     end
     
     private
     
-    def sqlserver_2000?
-      sqlserver_version <= '2000'
-    end
-    
     def _execute(sql, name = nil)
       # Match the start of the SQL to determine appropriate behavior.
       # Be aware of multi-line SQL which might begin with 'create stored_proc' 
       # and contain 'insert into ...' lines.
-      # TODO test and refactor using `self.class.insert?(sql)` etc
       # NOTE: ignoring comment blocks prior to the first statement ?!
-      if sql.lstrip =~ /\Ainsert/i # self.class.insert?(sql)
-        if query_requires_identity_insert?(sql)
-          table_name = get_table_name(sql)
-          with_identity_insert_enabled(table_name) do
+      if self.class.insert?(sql)
+        if id_insert_table_name = identity_insert_table_name(sql)
+          with_identity_insert_enabled(id_insert_table_name) do
             @connection.execute_insert(sql)
           end
         else
           @connection.execute_insert(sql)
         end
-      elsif sql.lstrip =~ /\A\(?\s*(select|show)/i # self.class.select?(sql)
-        sql = repair_special_columns(sql)
-        @connection.execute_query(sql)
-      else # sql.lstrip =~ /\A(create|exec)/i
+      elsif self.class.select?(sql)
+        @connection.execute_query_raw repair_special_columns(sql)
+      else # create | exec
         @connection.execute_update(sql)
       end
     end
     
+    def identity_insert_table_name(sql)
+      table_name = get_table_name(sql)
+      id_column = identity_column_name(table_name)
+      if id_column && sql.strip =~ /INSERT INTO [^ ]+ ?\((.+?)\)/i
+        insert_columns = $1.split(/, */).map(&method(:unquote_column_name))
+        return table_name if insert_columns.include?(id_column)
+      end
+    end
+    
+    def identity_column_name(table_name)
+      for column in columns(table_name)
+        return column.name if column.identity
+      end
+      nil
+    end
+    
     def repair_special_columns(sql)
       qualified_table_name = get_table_name(sql, true)
-      special_columns = get_special_columns(qualified_table_name)
-      for column in special_columns.to_a
-        sql.gsub!(Regexp.new(" #{column} = "), " #{column} LIKE ")
-        sql.gsub!(/ORDER BY #{column.to_s}/i, '')
-      end if special_columns
+      if special_columns = special_column_names(qualified_table_name)
+        return sql if special_columns.empty?
+        special_columns = special_columns.sort { |n1, n2| n2.size <=> n1.size }
+        for column in special_columns
+          sql.gsub!(/\s?\[?#{column}\]?\s?=\s?/, " [#{column}] LIKE ")
+          sql.gsub!(/ORDER BY \[?#{column}\]?/i, '') # NOTE: a bit stupid
+        end
+      end
       sql
     end
 
-    def get_special_columns(qualified_table_name)
+    def special_column_names(qualified_table_name)
+      columns = self.columns(qualified_table_name, nil, nil)
+      return columns if ! columns || columns.empty?
       special = []
-      columns(qualified_table_name).each do |column|
-        special << column.name if column.is_special
-      end
+      columns.each { |column| special << column.name if column.special }
       special
     end
     
@@ -496,3 +670,8 @@ module ArJdbc
   end
 end
 
+module ActiveRecord::ConnectionAdapters
+  class MSSQLColumn < JdbcColumn
+    include ArJdbc::MSSQL::Column
+  end
+end