activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/mssql.rb

@@ -1,4 +1,7 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/jtds', 'jdbc-mssql'
-require 'arjdbc/mssql/connection_methods'
+require 'arjdbc'
 require 'arjdbc/mssql/adapter'
+require 'arjdbc/mssql/connection_methods'
+module ArJdbc
+  MsSQL = MSSQL # compatibility with 1.2
+end
+ArJdbc.warn_unsupported_adapter 'mssql', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/mssql/adapter.rb

@@ -1,69 +1,175 @@
-require 'arjdbc/mssql/tsql_helper'
-require 'arjdbc/mssql/limit_helpers'
+# NOTE: file contains code adapted from **sqlserver** adapter, license follows
+=begin
+Copyright (c) 2008-2015
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+ArJdbc.load_java_part :MSSQL
+
+require 'strscan'
+
+module ArJdbc
+  module MSSQL
+
+    require 'arjdbc/mssql/utils'
+    require 'arjdbc/mssql/limit_helpers'
+    require 'arjdbc/mssql/lock_methods'
+    require 'arjdbc/mssql/column'
+    require 'arjdbc/mssql/explain_support'
+    require 'arjdbc/mssql/types' if AR42
+    require 'arel/visitors/sql_server'
 
-module ::ArJdbc
-  module MsSQL
-    include TSqlMethods
     include LimitHelpers
+    include Utils
+    include ExplainSupport
 
-    def self.extended(mod)
-      unless @lob_callback_added
-        ActiveRecord::Base.class_eval do
-          def after_save_with_mssql_lob
-            self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |c|
-              value = self[c.name]
-              value = value.to_yaml if unserializable_attribute?(c.name, c)
-              next if value.nil?  || (value == '')
-
-              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
-            end
-          end
-        end
+    # @private
+    def self.extended(adapter)
+      initialize!
 
-        ActiveRecord::Base.after_save :after_save_with_mssql_lob
-        @lob_callback_added = true
-      end
-      mod.add_version_specific_add_limit_offset
+      version = adapter.config[:sqlserver_version] ||= adapter.sqlserver_version
+      adapter.send(:setup_limit_offset!, version)
     end
 
-    def self.column_selector
-      [/sqlserver|tds|Microsoft SQL/i, lambda {|cfg,col| col.extend(::ArJdbc::MsSQL::Column)}]
+    # @private
+    @@_initialized = nil
+
+    # @private
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+
+      require 'arjdbc/util/serialized_attributes'
+      Util::SerializedAttributes.setup /image/i, 'after_save_with_mssql_lob'
     end
 
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::MssqlJdbcConnection
+    # @private
+    @@update_lob_values = true
+
+    # Updating records with LOB values (binary/text columns) in a separate
+    # statement can be disabled using :
+    #
+    #   ArJdbc::MSSQL.update_lob_values = false
+    #
+    # @note This only applies when prepared statements are not used.
+    def self.update_lob_values?; @@update_lob_values; end
+    # @see #update_lob_values?
+    def self.update_lob_values=(update); @@update_lob_values = update; end
+
+    # @private
+    @@cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
+
+    # Operator for sorting strings in SQLServer, setup as :
+    #
+    #  ArJdbc::MSSQL.cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
+    #
+    def self.cs_equality_operator; @@cs_equality_operator; end
+    # @see #cs_equality_operator
+    def self.cs_equality_operator=(operator); @@cs_equality_operator = operator; end
+
+    # @see #quote
+    # @private
+    BLOB_VALUE_MARKER = "''"
+
+    # @see #update_lob_values?
+    # @see ArJdbc::Util::SerializedAttributes#update_lob_columns
+    def update_lob_value?(value, column = nil)
+      MSSQL.update_lob_values? && ! prepared_statements? # && value
     end
 
-    def arel2_visitors
-      require 'arel/visitors/mssql'
-      visitor_class = sqlserver_version == "2000" ? ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
-      { 'mssql' => visitor_class, 'jdbcmssql' => visitor_class}
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
     end
 
-    def sqlserver_version
-      @sqlserver_version ||= select_value("select @@version")[/Microsoft SQL Server\s+(\d{4})/, 1]
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::MSSQLColumn end
+
+    def configure_connection
+      use_database # config[:database]
     end
 
-    def add_version_specific_add_limit_offset
-      if sqlserver_version == "2000"
-        extend LimitHelpers::SqlServer2000AddLimitOffset
-      else
-        extend LimitHelpers::SqlServerAddLimitOffset
+    def sqlserver_version
+      @sqlserver_version ||= begin
+        config_version = config[:sqlserver_version]
+        config_version ? config_version.to_s :
+          select_value("SELECT @@version")[/(Microsoft SQL Server\s+|Microsoft SQL Azure.+\n.+)(\d{4})/, 2]
       end
     end
 
-    def modify_types(tp) #:nodoc:
-      super(tp)
-      tp[:string] = {:name => "NVARCHAR", :limit => 255}
-      if sqlserver_version == "2000"
-        tp[:text] = {:name => "NTEXT"}
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => 'int NOT NULL IDENTITY(1,1) PRIMARY KEY',
+      :integer   =>  { :name => 'int', }, # :limit => 4
+      :boolean   =>  { :name => 'bit' },
+      :decimal   =>  { :name => 'decimal' },
+      :float     =>  { :name => 'float' },
+      :bigint    =>  { :name => 'bigint' },
+      :real      =>  { :name => 'real' },
+      :date      =>  { :name => 'date' },
+      :time      =>  { :name => 'time' },
+      :datetime  =>  { :name => 'datetime' },
+      :timestamp =>  { :name => 'datetime' },
+
+      :string    =>  { :name => 'nvarchar', :limit => 4000 },
+      #:varchar    =>  { :name => 'varchar' }, # limit: 8000
+      :text      =>  { :name => 'nvarchar(max)' },
+      :text_basic =>  { :name => 'text' },
+      #:ntext      =>  { :name => 'ntext' },
+      :char      =>  { :name => 'char' },
+      #:nchar     =>  { :name => 'nchar' },
+      :binary    =>  { :name => 'image' }, # NOTE: :name => 'varbinary(max)'
+      :binary_basic => { :name => 'binary' },
+      :uuid      =>  { :name => 'uniqueidentifier' },
+      :money     =>  { :name => 'money' },
+      #:smallmoney => { :name => 'smallmoney' },
+    }
+
+    def native_database_types
+      # NOTE: due compatibility we're using the generic type resolution
+      # ... NATIVE_DATABASE_TYPES won't be used at all on SQLServer 2K
+      sqlserver_2000? ? super : super.merge(NATIVE_DATABASE_TYPES)
+    end
+
+    def modify_types(types)
+      if sqlserver_2000?
+        types[:primary_key] = NATIVE_DATABASE_TYPES[:primary_key]
+        types[:string] = NATIVE_DATABASE_TYPES[:string]
+        types[:boolean] = NATIVE_DATABASE_TYPES[:boolean]
+        types[:text] = { :name => "ntext" }
+        types[:integer][:limit] = nil
+        types[:binary] = { :name => "image" }
       else
-        tp[:text] = {:name => "NVARCHAR(MAX)"}
+        # ~ private types for better "native" adapter compatibility
+        types[:varchar_max]   =  { :name => 'varchar(max)' }
+        types[:nvarchar_max]  =  { :name => 'nvarchar(max)' }
+        types[:varbinary_max] =  { :name => 'varbinary(max)' }
       end
-      tp
+      types[:string][:limit] = 255 unless AR40 # backwards compatibility
+      types
     end
 
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+    # @private these cannot specify a limit
+    NO_LIMIT_TYPES = %w( text binary boolean date datetime )
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      type_s = type.to_s
       # MSSQL's NVARCHAR(n | max) column supports either a number between 1 and
       # 4000, or the word "MAX", which corresponds to 2**30-1 UCS-2 characters.
       #
@@ -73,329 +179,436 @@ module ::ArJdbc
       # MSSQL Server 2000 is skipped here because I don't know how it will behave.
       #
       # See: http://msdn.microsoft.com/en-us/library/ms186939.aspx
-      if type.to_s == 'string' and limit == 1073741823 and sqlserver_version != "2000"
+      if type_s == 'string' && limit == 1073741823 && ! sqlserver_2000?
         'NVARCHAR(MAX)'
-      elsif %w( boolean date datetime ).include?(type.to_s)
-        super(type)   # cannot specify limit/precision/scale with these types
+      elsif NO_LIMIT_TYPES.include?(type_s)
+        super(type)
+      elsif type_s == 'integer' || type_s == 'int'
+        if limit.nil? || limit == 4
+          'int'
+        elsif limit == 2
+          'smallint'
+        elsif limit == 1
+          'tinyint'
+        else
+          'bigint'
+        end
+      elsif type_s == 'uniqueidentifier'
+        type_s
       else
         super
       end
     end
 
-    module Column
-      attr_accessor :identity, :is_special
-
-      def simplified_type(field_type)
-        case field_type
-        when /int|bigint|smallint|tinyint/i                        then :integer
-        when /numeric/i                                            then (@scale.nil? || @scale == 0) ? :integer : :decimal
-        when /float|double|decimal|money|real|smallmoney/i         then :decimal
-        when /datetime|smalldatetime/i                             then :datetime
-        when /timestamp/i                                          then :timestamp
-        when /time/i                                               then :time
-        when /date/i                                               then :date
-        when /text|ntext|xml/i                                     then :text
-        when /binary|image|varbinary/i                             then :binary
-        when /char|nchar|nvarchar|string|varchar/i                 then (@limit == 1073741823 ? (@limit = nil; :text) : :string)
-        when /bit/i                                                then :boolean
-        when /uniqueidentifier/i                                   then :string
-        end
-      end
-
-      def default_value(value)
-        return $1 if value =~ /^\(N?'(.*)'\)$/
-        value
-      end
-
-      def type_cast(value)
-        return nil if value.nil? || value == "(null)" || value == "(NULL)"
-        case type
-        when :integer then value.to_i rescue unquote(value).to_i rescue value ? 1 : 0
-        when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
-        when :decimal   then self.class.value_to_decimal(unquote(value))
-        when :datetime  then cast_to_datetime(value)
-        when :timestamp then cast_to_time(value)
-        when :time      then cast_to_time(value)
-        when :date      then cast_to_date(value)
-        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or unquote(value)=="1"
-        when :binary    then unquote value
-        else value
-        end
-      end
+    # @override
+    def quote(value, column = nil)
+      return value.quoted_id if value.respond_to?(:quoted_id)
+      return value if sql_literal?(value)
 
-      def extract_limit(sql_type)
-        case sql_type
-        when /text|ntext|xml|binary|image|varbinary|bit/
-          nil
+      case value
+      # SQL Server 2000 doesn't let you insert an integer into a NVARCHAR
+      when String, ActiveSupport::Multibyte::Chars, Integer
+        value = value.to_s
+        column_type = column && column.type
+        if column_type == :binary
+          if update_lob_value?(value, column)
+            BLOB_VALUE_MARKER
+          else
+            "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+          end
+        elsif column_type == :integer
+          value.to_i.to_s
+        elsif column_type == :float
+          value.to_f.to_s
+        elsif ! column.respond_to?(:is_utf8?) || column.is_utf8?
+          "N'#{quote_string(value)}'" # ' (for ruby-mode)
         else
           super
         end
+      when Date, Time
+        if column && column.type == :time
+          "'#{quoted_time(value)}'"
+        else
+          "'#{quoted_date(value)}'"
+        end
+      when TrueClass  then '1'
+      when FalseClass then '0'
+      else super
       end
+    end
 
-      def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
+    # @override
+    def quoted_date(value)
+      if value.respond_to?(:usec)
+        "#{super}.#{sprintf("%03d", value.usec / 1000)}"
+      else
+        super
       end
+    end
 
-      def unquote(value)
-        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
+    # @private
+    def quoted_time(value)
+      if value.acts_like?(:time)
+        tz_value = get_time(value)
+        usec = value.respond_to?(:usec) ? ( value.usec / 1000 ) : 0
+        sprintf("%02d:%02d:%02d.%03d", tz_value.hour, tz_value.min, tz_value.sec, usec)
+      else
+        quoted_date(value)
       end
+    end
 
-      def cast_to_time(value)
-        return value if value.is_a?(Time)
-        time_array = ParseDate.parsedate(value)
-        return nil if !time_array.any?
-        time_array[0] ||= 2000
-        time_array[1] ||= 1
-        time_array[2] ||= 1
-        return Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
-
-        # Try DateTime instead - the date may be outside the time period support by Time.
-        DateTime.new(*time_array[0..5]) rescue nil
-      end
+    # @deprecated no longer used
+    # @private
+    def quoted_datetime(value)
+      quoted_date(value)
+    end
 
-      def cast_to_date(value)
-        return value if value.is_a?(Date)
-        return Date.parse(value) rescue nil
+    # @deprecated no longer used
+    # @private
+    def quoted_full_iso8601(value)
+      if value.acts_like?(:time)
+        value.is_a?(Date) ?
+          get_time(value).to_time.xmlschema.to(18) :
+            get_time(value).iso8601(7).to(22)
+      else
+        quoted_date(value)
       end
+    end
 
-      def cast_to_datetime(value)
-        if value.is_a?(Time)
-          if value.year != 0 and value.month != 0 and value.day != 0
-            return value
-          else
-            return Time.mktime(2000, 1, 1, value.hour, value.min, value.sec) rescue nil
-          end
-        end
-        if value.is_a?(DateTime)
-          begin
-            # Attempt to convert back to a Time, but it could fail for dates significantly in the past/future.
-            return Time.mktime(value.year, value.mon, value.day, value.hour, value.min, value.sec)
-          rescue ArgumentError
-            return value
-          end
-        end
+    def quote_table_name(name)
+      quote_column_name(name)
+    end
 
-        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
+    def quote_column_name(name)
+      name = name.to_s.split('.')
+      name.map! { |n| quote_name_part(n) } # "[#{name}]"
+      name.join('.')
+    end
 
-        return value.is_a?(Date) ? value : nil
-      end
+    def quote_database_name(name)
+      quote_name_part(name.to_s)
+    end
 
-      # These methods will only allow the adapter to insert binary data with a length of 7K or less
-      # because of a SQL Server statement length policy.
-      def self.string_to_binary(value)
-        ''
+    # Does not quote function default values for UUID columns
+    def quote_default_value(value, column)
+      if column.type == :uuid && value =~ /\(\)/
+        value
+      else
+        quote(value)
       end
-
     end
 
-    def quote(value, column = nil)
-      return value.quoted_id if value.respond_to?(:quoted_id)
+    ADAPTER_NAME = 'MSSQL'.freeze
 
-      case value
-      # SQL Server 2000 doesn't let you insert an integer into a NVARCHAR
-      # column, so we include Integer here.
-      when String, ActiveSupport::Multibyte::Chars, Integer
-        value = value.to_s
-        if column && column.type == :binary
-          "'#{quote_string(ArJdbc::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
-        elsif column && [:integer, :float].include?(column.type)
-          value = column.type == :integer ? value.to_i : value.to_f
-          value.to_s
-        elsif !column.respond_to?(:is_utf8?) || column.is_utf8?
-          "N'#{quote_string(value)}'" # ' (for ruby-mode)
-        else
-          super
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    def change_order_direction(order)
+      asc, desc = /\bASC\b/i, /\bDESC\b/i
+      order.split(",").collect do |fragment|
+        case fragment
+        when desc  then fragment.gsub(desc, "ASC")
+        when asc   then fragment.gsub(asc, "DESC")
+        else "#{fragment.split(',').join(' DESC,')} DESC"
         end
-      when TrueClass             then '1'
-      when FalseClass            then '0'
-      else                       super
-      end
+      end.join(",")
     end
 
-    def quote_string(string)
-      string.gsub(/\'/, "''")
+    # @override
+    def supports_ddl_transactions?; true end
+
+    # @override
+    def supports_views?; true end
+
+    def tables(schema = current_schema)
+      @connection.tables(nil, schema)
     end
 
-    def quote_table_name(name)
-      name
+    # 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 ||=
+        @connection.execute_query_raw(
+          "SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER"
+        ).first['default_schema_name']
     end
+    alias_method :current_schema, :default_schema
 
-    def quote_column_name(name)
-      "[#{name}]"
+    # 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=
 
-    def quoted_true
-      quote true
+    # `SELECT CURRENT_USER`
+    def current_user
+      @current_user ||= @connection.execute_query_raw("SELECT CURRENT_USER").first['']
     end
 
-    def quoted_false
-      quote false
+    def charset
+      select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
     end
 
-    def adapter_name #:nodoc:
-      'MsSQL'
+    def collation
+      select_value "SELECT SERVERPROPERTY('Collation')"
     end
 
-    def change_order_direction(order)
-      order.split(",").collect do |fragment|
-        case fragment
-        when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
-        when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
-        else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
-        end
-      end.join(",")
+    def current_database
+      select_value 'SELECT DB_NAME()'
     end
 
-    def supports_ddl_transactions?
-      true
+    def use_database(database = nil)
+      database ||= config[:database]
+      execute "USE #{quote_database_name(database)}" unless database.blank?
     end
 
-    def recreate_database(name)
+    # @private
+    def recreate_database(name, options = {})
       drop_database(name)
-      create_database(name)
+      create_database(name, options)
+    end
+
+    # @private
+    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}"
+      current_db = current_database
+      use_database('master') if current_db.to_s == name
+      execute "DROP DATABASE #{quote_database_name(name)}"
+    end
+
+    def create_database(name, options = {})
+      execute "CREATE DATABASE #{quote_database_name(name)}"
     end
 
-    def create_database(name)
-      execute "CREATE DATABASE #{name}"
-      execute "USE #{name}"
+    def database_exists?(name)
+      select_value "SELECT name FROM sys.databases WHERE name = '#{name}'"
     end
 
-    def rename_table(name, new_name)
-      clear_cached_table(name)
-      execute "EXEC sp_rename '#{name}', '#{new_name}'"
+    # @override
+    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.
+    # @override
     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}'"
+    # @override
+    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
+
+    # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+    # MSSQL requires the ORDER BY columns in the select list for distinct queries.
+    def distinct(columns, order_by)
+      "DISTINCT #{columns_for_distinct(columns, order_by)}"
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      clear_cached_table(table_name)
+    def columns_for_distinct(columns, orders)
+      return columns if orders.blank?
+
+      # construct a clean list of column names from the ORDER BY clause,
+      # removing any ASC/DESC modifiers
+      order_columns = [ orders ]; order_columns.flatten! # AR 3.x vs 4.x
+      order_columns.map! do |column|
+        column = column.to_sql unless column.is_a?(String) # handle AREL node
+        column.split(',').collect!{ |s| s.split.first }
+      end.flatten!
+      order_columns.reject!(&:blank?)
+      order_columns = order_columns.zip(0...order_columns.size).to_a
+      order_columns = order_columns.map{ |s, i| "#{s}" }
+
+      columns = [ columns ]; columns.flatten!
+      columns.push( *order_columns ).join(', ')
+      # return a DISTINCT clause that's distinct on the columns we want but
+      # includes all the required columns for the ORDER BY to work properly
+    end
+
+    # @override
+    def change_column(table_name, column_name, type, options = {})
+      column = columns(table_name).find { |c| c.name.to_s == column_name.to_s }
+
+      indexes = EMPTY_ARRAY
+      if options_include_default?(options) || (column && column.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)
+      end
+
+      if ! options[:null].nil? && options[:null] == false && ! options[:default].nil?
+        execute "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_value(options[:default], column)} WHERE #{quote_column_name(column_name)} IS NULL"
+        clear_cached_table(table_name)
+      end
       change_column_type(table_name, column_name, type, options)
       change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
-    end
 
-    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")
+      indexes.each do |index| # add any removed indexes back
+        index_columns = index.columns.map { |c| quote_column_name(c) }.join(', ')
+        execute "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index_columns})"
       end
-      execute(sql)
     end
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
+    def change_column_type(table_name, column_name, type, options = {})
+      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)
+      result = execute(sql)
       clear_cached_table(table_name)
+      result
+    end
+
+    def change_column_default(table_name, column_name, default)
       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)}"
+        column = columns(table_name).find { |c| c.name.to_s == column_name.to_s }
+        result = execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote_default_value(default, column)} FOR #{quote_column_name(column_name)}"
+        clear_cached_table(table_name)
+        result
       end
     end
 
-    def remove_column(table_name, column_name)
+    def remove_columns(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)
+
+      column_names = column_names.flatten
+      return do_remove_column(table_name, column_names.first) if column_names.size == 1
+      column_names.each { |column_name| do_remove_column(table_name, column_name) }
+    end
+
+    def do_remove_column(table_name, 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
+    private :do_remove_column
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+
+    # @override
+    def remove_column(table_name, column_name, type = nil, options = {})
+      remove_columns(table_name, column_name)
+    end
+
+    else
+
+    def remove_column(table_name, *column_names); remove_columns(table_name, *column_names) end
+
     end
 
     def remove_default_constraint(table_name, column_name)
       clear_cached_table(table_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|
-        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
-      }
+      if sqlserver_2000?
+        # NOTE: since SQLServer 2005 these are provided as sys.sysobjects etc.
+        # but only due backwards-compatibility views and should be avoided ...
+        defaults = select_values "SELECT d.name" <<
+          " FROM sysobjects d, syscolumns c, sysobjects t" <<
+          " WHERE c.cdefault = d.id AND c.name = '#{column_name}'" <<
+          " AND t.name = '#{table_name}' AND c.id = t.id"
+      else
+        defaults = select_values "SELECT d.name FROM sys.tables t" <<
+          " JOIN sys.default_constraints d ON d.parent_object_id = t.object_id" <<
+          " JOIN sys.columns c ON c.object_id = t.object_id AND c.column_id = d.parent_column_id" <<
+          " WHERE t.name = '#{table_name}' AND c.name = '#{column_name}'"
+      end
+      defaults.each do |def_name|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{def_name}"
+      end
     end
 
     def remove_check_constraints(table_name, column_name)
       clear_cached_table(table_name)
-      # TODO remove all constraints in single method
-      constraints = select "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{table_name}' and COLUMN_NAME = '#{column_name}'"
-      constraints.each do |constraint|
-        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["CONSTRAINT_NAME"]}"
+      constraints = select_values "SELECT constraint_name" <<
+        " FROM information_schema.constraint_column_usage" <<
+        " WHERE table_name = '#{table_name}' AND column_name = '#{column_name}'"
+      constraints.each do |constraint_name|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint_name}"
+      end
+    end
+
+    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 remove_index(table_name, options = {})
-      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+      execute "DROP INDEX #{quote_table_name(table_name)}.#{index_name(table_name, options)}"
     end
 
-    def columns(table_name, name = nil)
-      # 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?
-      table_name = table_name.to_s if table_name.is_a?(Symbol)
+    # @private
+    SKIP_COLUMNS_TABLE_NAMES_RE = /^information_schema\./i
 
-      # Remove []'s from around the table name, valid in a select statement, but not when matching metadata.
-      table_name = table_name.gsub(/[\[\]]/, '')
+    # @private
+    EMPTY_ARRAY = [].freeze
 
-      return [] if table_name =~ /^information_schema\./i
-      @table_columns = {} unless @table_columns
-      unless @table_columns[table_name]
-        @table_columns[table_name] = super
-        @table_columns[table_name].each do |col|
-          col.identity = true if col.sql_type =~ /identity/i
-          col.is_special = true if col.sql_type =~ /text|ntext|image|xml/i
-        end
-      end
-      @table_columns[table_name]
-    end
+    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 default if table_name.blank?
 
-    def _execute(sql, name = nil)
-      # Match the start of the sql to determine appropriate behaviour.  Be aware of
-      # multi-line sql which might begin with 'create stored_proc' and contain 'insert into ...' lines.
-      # Possible improvements include ignoring comment blocks prior to the first statement.
-      if sql.lstrip =~ /\Ainsert/i
-        if query_requires_identity_insert?(sql)
-          table_name = get_table_name(sql)
-          with_identity_insert_enabled(table_name) do
-            id = @connection.execute_insert(sql)
-          end
-        else
-          @connection.execute_insert(sql)
-        end
-      elsif sql.lstrip =~ /\A(create|exec)/i
-        @connection.execute_update(sql)
-      elsif sql.lstrip =~ /\A\(?\s*(select|show)/i
-        repair_special_columns(sql)
-        @connection.execute_query(sql)
-      else
-        @connection.execute_update(sql)
+      table_name = unquote_table_name(table_name)
+
+      return default if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
+
+      unless columns = ( @table_columns ||= {} )[table_name]
+        @table_columns[table_name] = columns = super(table_name, name)
       end
+      columns
     end
 
-    def select(sql, name = nil)
-      log(sql, name) do
-        @connection.execute_query(sql)
-      end
+    def clear_cached_table(table_name)
+      ( @table_columns ||= {} ).delete(table_name.to_s)
     end
 
-    #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
-    def add_lock!(sql, options)
-      sql
+    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
-    def with_identity_insert_enabled(table_name, &block)
+    def with_identity_insert_enabled(table_name)
       set_identity_insert(table_name, true)
       yield
     ensure
@@ -405,68 +618,187 @@ module ::ArJdbc
     def set_identity_insert(table_name, enable = true)
       execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
     rescue Exception => e
-      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned" +
+            " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
+    end
+
+    def disable_referential_integrity
+      execute "EXEC sp_MSforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
+      yield
+    ensure
+      execute "EXEC sp_MSforeachtable 'ALTER TABLE ? CHECK CONSTRAINT ALL'"
     end
 
-    def identity_column(table_name)
-      columns(table_name).each do |col|
-        return col.name if col.identity
+    # @private
+    # @see ArJdbc::MSSQL::LimitHelpers
+    def determine_order_clause(sql)
+      return $1 if sql =~ /ORDER BY (.*)$/i
+      columns = self.columns(table_name = get_table_name(sql))
+      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} (SQL query: ' #{sql} ')" if columns.empty?
       end
-      return nil
+      # NOTE: if still no PK column simply get something for ORDER BY ...
+      "#{quote_table_name(table_name)}.#{quote_column_name((primary_column || columns.first).name)}"
     end
 
-    def query_requires_identity_insert?(sql)
-      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)
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    end
+
+    # Support for executing a stored procedure.
+    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
+    alias_method :execute_procedure, :exec_proc # AR-SQLServer-Adapter naming
 
-    def unquote_column_name(name)
-      if name =~ /^\[.*\]$/
-        name[1..-2]
+    # @override
+    def exec_query(sql, name = 'SQL', binds = [])
+      # 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 = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+
+      sql = repair_special_columns(sql)
+      if prepared_statements?
+        log(sql, name, binds) { @connection.execute_query(sql, binds) }
       else
-        name
+        log(sql, name) { @connection.execute_query(sql) }
       end
     end
 
-    def get_special_columns(table_name)
-      special = []
-      columns(table_name).each do |col|
-        special << col.name if col.is_special
+    # @override
+    def exec_query_raw(sql, name = 'SQL', binds = [], &block)
+      sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+
+      sql = repair_special_columns(sql)
+      if prepared_statements?
+        log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
+      else
+        log(sql, name) { @connection.execute_query_raw(sql, &block) }
       end
-      special
     end
 
-    def repair_special_columns(sql)
-      special_cols = get_special_columns(get_table_name(sql))
-      for col in special_cols.to_a
-        sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
-        sql.gsub!(/ORDER BY #{col.to_s}/i, '')
+    # @override
+    def release_savepoint(name = current_savepoint_name(false))
+      if @connection.jtds_driver?
+        @connection.release_savepoint(name)
+      else # MS invented it's "own" way
+        @connection.rollback_savepoint(name)
       end
-      sql
     end
 
-    def determine_order_clause(sql)
-      return $1 if sql =~ /ORDER BY (.*)$/
+    private
+
+    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.
+      # NOTE: ignoring comment blocks prior to the first statement ?!
+      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 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)
-      "#{table_name}.#{determine_primary_key(table_name)}"
+      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 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.  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
+    def repair_special_columns(sql)
+      qualified_table_name = get_table_name(sql, true)
+      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}([^\.\w]|$)\]?/i, '') # NOTE: a bit stupid
+        end
+      end
+      sql
     end
 
-    def clear_cached_table(name)
-      (@table_columns ||= {}).delete(name.to_s)
+    def special_column_names(qualified_table_name)
+      columns = self.columns(qualified_table_name, nil, nil)
+      return columns if ! columns || columns.empty?
+      special = []
+      columns.each { |column| special << column.name if column.special? }
+      special
     end
+
+    def sqlserver_2000?
+      sqlserver_version <= '2000'
+    end
+
   end
 end
 
+require 'arjdbc/util/quoted_cache'
+
+module ActiveRecord::ConnectionAdapters
+
+  class MSSQLAdapter < JdbcAdapter
+    include ::ArJdbc::MSSQL
+    include ::ArJdbc::Util::QuotedCache
+
+    def initialize(*args)
+      ::ArJdbc::MSSQL.initialize!
+
+      super # configure_connection happens in super
+
+      setup_limit_offset!
+    end
+
+    def arel_visitor # :nodoc:
+      ( config && config[:sqlserver_version].to_s == '2000' ) ?
+          ::Arel::Visitors::SQLServer2000.new(self) :
+          ::Arel::Visitors::SQLServer.new(self)
+    end
+
+    def self.cs_equality_operator; ::ArJdbc::MSSQL.cs_equality_operator end
+    def self.cs_equality_operator=(operator); ::ArJdbc::MSSQL.cs_equality_operator = operator end
+
+  end
+
+  class MSSQLColumn < JdbcColumn
+    include ::ArJdbc::MSSQL::Column
+  end
+
+end