activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/lib/arjdbc/jdbc/extension.rb

@@ -1,17 +1,17 @@
 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. 
+
+  # 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 
+  # 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+ 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 
+  # +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:
@@ -39,14 +39,14 @@ module ArJdbc
       end
     end unless mod.respond_to?(:adapter_matcher)
   end
-  
+
   private
   def self.discover_extensions
-    if defined?(::Gem) && ::Gem.respond_to?(:find_files)
-      files = ::Gem.find_files('arjdbc/discover')
+    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')
+      files = $LOAD_PATH.map do |path|
+        discover = File.join(path, 'arjdbc', 'discover.rb')
         File.exist?(discover) ? discover : nil
       end.compact
     end
@@ -55,5 +55,5 @@ module ArJdbc
       require file
     end
   end
-  
+
 end

data/lib/arjdbc/jdbc/java.rb

@@ -4,9 +4,12 @@ require 'arjdbc/jdbc/adapter_java'
 module ActiveRecord
   module ConnectionAdapters
     module Jdbc
-      DriverManager = java.sql.DriverManager
-      Types = java.sql.Types
+      # @private
+      DriverManager = ::Java::JavaSql::DriverManager
+      # @private
+      Types = ::Java::JavaSql::Types
     end
+    # @private JdbcConnectionFactory
     java_import "arjdbc.jdbc.JdbcConnectionFactory"
   end
-end
+end

data/lib/arjdbc/jdbc/jdbc.rake

@@ -1,3 +1,3 @@
 # @deprecated
-warn "[DEPRECATED] load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"
+warn "DEPRECATED: load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"
 load 'arjdbc/tasks.rb'

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -12,9 +12,9 @@ module ArJdbc
         pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
       end
       if meth
-        base.module_eval <<-PK, __FILE__, __LINE__
+        base.module_eval <<-PK, __FILE__, __LINE__ + 1
           alias :#{meth}_pre_pk :#{meth}
-          def #{meth}(include_primary_key = true, *args) #:nodoc:
+          def #{meth}(include_primary_key = true, *args)
             aq = #{meth}_pre_pk(include_primary_key, *args)
             if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
               aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -1,3 +1,3 @@
 # @deprecated
-warn "[DEPRECATED] load 'arjdbc/tasks.rb' instead of 'arjdbc/jdbc/rake_tasks.rb'"
+warn "DEPRECATED: load 'arjdbc/tasks.rb' instead of 'arjdbc/jdbc/rake_tasks.rb'"
 load 'arjdbc/tasks.rb'

data/lib/arjdbc/jdbc/type_converter.rb

@@ -44,16 +44,19 @@ module ActiveRecord
         :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^datetime$/i},
                           lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^timestamp$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^time$/i},
-                          lambda {|r| r['type_name'] =~ /^datetime/i},  # For Informix
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime.+/i},  # For Informix
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
         :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},

data/lib/arjdbc/mssql/adapter.rb

@@ -2,34 +2,33 @@ ArJdbc.load_java_part :MSSQL
 
 require 'strscan'
 require 'arjdbc/mssql/utils'
-require 'arjdbc/mssql/tsql_methods'
 require 'arjdbc/mssql/limit_helpers'
-require 'arjdbc/mssql/lock_helpers'
+require 'arjdbc/mssql/lock_methods'
+require 'arjdbc/mssql/column'
 require 'arjdbc/mssql/explain_support'
 
 module ArJdbc
   module MSSQL
+    include LimitHelpers
     include Utils
-    include TSqlMethods
-    
+
     include ExplainSupport
-    
-    def self.extended(adapter) # :nodoc:
+
+    # @private
+    def self.extended(adapter)
       initialize!
-      
-      if ( version = adapter.sqlserver_version ) == '2000'
-        extend LimitHelpers::SqlServer2000AddLimitOffset
-      else
-        extend LimitHelpers::SqlServerAddLimitOffset
-      end
-      adapter.config[:sqlserver_version] ||= version
+
+      version = adapter.config[:sqlserver_version] ||= adapter.sqlserver_version
+      adapter.send(:setup_limit_offset!, version)
     end
 
+    # @private
     @@_initialized = nil
-    
+
+    # @private
     def self.initialize!
       return if @@_initialized; @@_initialized = true
-      
+
       require 'arjdbc/jdbc/serialized_attributes_helper'
       ActiveRecord::Base.class_eval do
         def after_save_with_mssql_lob
@@ -37,38 +36,39 @@ module ArJdbc
             value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
             next if value.nil? || (value == '')
 
-            self.class.connection.write_large_object(
-              column.type == :binary, column.name, 
-              self.class.table_name, self.class.primary_key, 
-              self.class.connection.quote(id), value
-            )
+            self.class.connection.update_lob_value(self, column, value)
           end
         end
       end
       ActiveRecord::Base.after_save :after_save_with_mssql_lob
     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
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class
       ::ActiveRecord::ConnectionAdapters::MSSQLColumn
     end
-    
-    def self.arel2_visitors(config)
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config)
       require 'arel/visitors/sql_server'
-      visitors = config[:sqlserver_version] == '2000' ? 
+      ( config && config[:sqlserver_version].to_s == '2000' ) ?
         ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
-      { 'mssql' => visitors, 'jdbcmssql' => visitors, 'sqlserver' => visitors }
+    end
+
+    # @deprecated no longer used
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#arel2_visitors
+    def self.arel2_visitors(config)
+      visitor = arel_visitor_type(config)
+      { 'mssql' => visitor, 'jdbcmssql' => visitor, 'sqlserver' => visitor }
+    end
+
+    def configure_connection
+      use_database # config[:database]
     end
 
     def sqlserver_version
@@ -79,8 +79,7 @@ module ArJdbc
       end
     end
 
-    def modify_types(types) #:nodoc:
-      super(types)
+    def modify_types(types)
       types[:string] = { :name => "NVARCHAR", :limit => 255 }
       if sqlserver_2000?
         types[:text] = { :name => "NTEXT" }
@@ -94,7 +93,11 @@ module ArJdbc
       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.
       #
@@ -104,126 +107,28 @@ 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' && limit == 1073741823 && ! sqlserver_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
-      else
-        super # TSqlMethods#type_to_sql
-      end
-    end
-
-    module Column
-      include LockHelpers::SqlServerAddLock
-
-      attr_accessor :identity, :special
-      alias_method :is_special, :special # #deprecated
-
-      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|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
-        else
-          super
-        end
-      end
-
-      def default_value(value)
-        return $1 if value =~ /^\(N?'(.*)'\)$/
-        value
-      end
-
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :integer then value.delete('()').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
-
-      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
+      elsif NO_LIMIT_TYPES.include?(type_s)
+        super(type)
+      elsif type_s == 'integer'
+        if limit.nil? || limit == 4
+          'int'
+        elsif limit == 2
+          'smallint'
+        elsif limit == 1
+          'tinyint'
         else
-          super
-        end
-      end
-
-      def is_utf8?
-        !!( sql_type =~ /nvarchar|ntext|nchar/i )
-      end
-
-      def unquote(value)
-        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
-      end
-
-      def cast_to_time(value)
-        return value if value.is_a?(Time)
-        DateTime.parse(value).to_time rescue nil
-      end
-
-      def cast_to_date(value)
-        return value if value.is_a?(Date)
-        return Date.parse(value) rescue nil
-      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
+          'bigint'
         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
-
-        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
-
-        return value.is_a?(Date) ? value : nil
-      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)
-        ''
+      elsif type_s == 'uniqueidentifier'
+        type_s
+      else
+        super
       end
-
     end
 
+    # @override
     def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
 
@@ -234,7 +139,7 @@ module ArJdbc
         value = value.to_s
         column_type = column && column.type
         if column_type == :binary
-          "'#{quote_string(ArJdbc::MSSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
+          "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
         elsif column_type == :integer
           value.to_i.to_s
         elsif column_type == :float
@@ -247,19 +152,16 @@ module ArJdbc
       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
+          "'#{quoted_date(value)}'"
         end
       when TrueClass  then '1'
       when FalseClass then '0'
       else super
       end
     end
-    
+
+    # @override
     def quoted_date(value)
       if value.respond_to?(:usec)
         "#{super}.#{sprintf("%03d", value.usec / 1000)}"
@@ -268,55 +170,39 @@ module ArJdbc
       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
-    
+    # @private
     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)
+        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
-    
+
+    # @deprecated no longer used
+    # @private
+    def quoted_datetime(value)
+      quoted_date(value)
+    end
+
+    # @deprecated no longer used
+    # @private
     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)
+        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 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_table_name_for_assignment(table, attr)
-#      quote_column_name(attr)
-#    end if ::ActiveRecord::VERSION::MAJOR > 3
-    
+
     def quote_column_name(name)
       name.to_s.split('.').map do |n| # "[#{name}]"
         n =~ /^\[.*\]$/ ? n : "[#{n.gsub(']', ']]')}]"
@@ -324,8 +210,8 @@ module ArJdbc
     end
 
     ADAPTER_NAME = 'MSSQL'.freeze
-    
-    def adapter_name # :nodoc:
+
+    def adapter_name
       ADAPTER_NAME
     end
 
@@ -344,24 +230,28 @@ module ArJdbc
       true
     end
 
+    def tables(schema = current_schema)
+      @connection.tables(nil, schema)
+    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 
+    #
+    # 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 
+    # 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 ||= 
+      @default_schema ||=
         @connection.execute_query_raw(
           "SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER"
         ).first['default_schema_name']
@@ -377,12 +267,12 @@ module ArJdbc
       @default_schema = nil if defined?(@default_schema)
     end
     alias_method :current_schema=, :default_schema=
-    
+
     # `SELECT CURRENT_USER`
     def current_user
       @current_user ||= @connection.execute_query_raw("SELECT CURRENT_USER").first['']
     end
-    
+
     def charset
       select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
     end
@@ -390,21 +280,23 @@ module ArJdbc
     def collation
       select_value "SELECT SERVERPROPERTY('Collation')"
     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
-    
+
+    # @private
     def recreate_database(name, options = {})
       drop_database(name)
       create_database(name, options)
     end
 
+    # @private
     def recreate_database!(database = nil)
       current_db = current_database
       database ||= current_db
@@ -414,8 +306,10 @@ module ArJdbc
     ensure
       use_database(current_db) if this_db
     end
-    
+
     def drop_database(name)
+      current_db = current_database
+      use_database('master') if current_db.to_s == name
       execute "DROP DATABASE #{quote_table_name(name)}"
     end
 
@@ -426,14 +320,15 @@ module ArJdbc
     def database_exists?(name)
       select_value "SELECT name FROM sys.databases WHERE name = '#{name}'"
     end
-    
+
+    # @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 #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
@@ -443,32 +338,34 @@ module ArJdbc
       execute(add_column_sql)
     end
 
+    # @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
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # @override
+    def change_column(table_name, column_name, type, options = {})
       clear_cached_table(table_name)
       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:
+    def change_column_type(table_name, column_name, type, options = {})
       clear_cached_table(table_name)
       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
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
+    def change_column_default(table_name, column_name, default)
       clear_cached_table(table_name)
       remove_default_constraint(table_name, column_name)
       unless default.nil?
         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)
       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])
@@ -517,29 +414,34 @@ module ArJdbc
         remove_index(table_name, { :name => index.name })
       end
     end
-    
+
     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}
+
+    # @private
+    SKIP_COLUMNS_TABLE_NAMES_RE = /^information_schema\./i
+    # @private
+    IDENTITY_COLUMN_TYPE_RE = /identity/i
+    # NOTE: these do not handle = equality as expected
+    # see {#repair_special_columns}
     # (TEXT, NTEXT, and IMAGE data types are deprecated)
-    SPECIAL_COLUMN_TYPE_RE = /text|ntext|image|xml/i # :nodoc:
-    
-    EMPTY_ARRAY = [].freeze # :nodoc:
-    
+    # @private
+    SPECIAL_COLUMN_TYPE_RE = /text|ntext|image|xml/i
+
+    # @private
+    EMPTY_ARRAY = [].freeze
+
     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. 
+      # 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?
-      
+
       table_name = unquote_table_name(table_name)
 
       return default if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
-      
+
       unless columns = ( @table_columns ||= {} )[table_name]
         columns = super(table_name, name)
         for column in columns
@@ -558,7 +460,7 @@ module ArJdbc
     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
@@ -572,10 +474,11 @@ 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" + 
+      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned" +
             " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
     end
-    
+
+    # @private
     # @see ArJdbc::MSSQL::LimitHelpers
     def determine_order_clause(sql)
       return $1 if sql =~ /ORDER BY (.*)$/i
@@ -591,9 +494,10 @@ module ArJdbc
       # NOTE: if still no PK column simply get something for ORDER BY ...
       "#{table_name}.#{(primary_column || columns.first).name}"
     end
-    
+
+    # Support for executing a stored procedure.
     def exec_proc(proc_name, *variables)
-      vars = 
+      vars =
         if variables.any? && variables.first.is_a?(Hash)
           variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
         else
@@ -602,7 +506,7 @@ module ArJdbc
       sql = "EXEC #{proc_name} #{vars}".strip
       log(sql, 'Execute Procedure') do
         result = @connection.execute_query_raw(sql)
-        result.map! do |row| 
+        result.map! do |row|
           row = row.is_a?(Hash) ? row.with_indifferent_access : row
           yield(row) if block_given?
           row
@@ -611,9 +515,9 @@ module ArJdbc
       end
     end
     alias_method :execute_procedure, :exec_proc # AR-SQLServer-Adapter naming
-    
+
     # @override
-    def exec_query(sql, name = 'SQL', binds = []) # :nodoc:
+    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 = repair_special_columns to_sql(sql, binds)
@@ -624,9 +528,9 @@ module ArJdbc
         log(sql, name) { @connection.execute_query(sql) }
       end
     end
-    
+
     # @override
-    def exec_query_raw(sql, name = 'SQL', binds = [], &block) # :nodoc:
+    def exec_query_raw(sql, name = 'SQL', binds = [], &block)
       sql = repair_special_columns to_sql(sql, binds)
       if prepared_statements?
         log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
@@ -635,12 +539,12 @@ module ArJdbc
         log(sql, name) { @connection.execute_query_raw(sql, &block) }
       end
     end
-    
+
     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' 
+      # 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)
@@ -657,7 +561,7 @@ module ArJdbc
         @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)
@@ -666,14 +570,14 @@ module ArJdbc
         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)
       if special_columns = special_column_names(qualified_table_name)
@@ -681,7 +585,7 @@ module ArJdbc
         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
+          sql.gsub!(/ORDER BY \[?#{column}([^\.\w]|$)\]?/i, '') # NOTE: a bit stupid
         end
       end
       sql
@@ -694,58 +598,34 @@ module ArJdbc
       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
-      
-      if ( version = self.sqlserver_version ) == '2000'
-        extend LimitHelpers::SqlServer2000AddLimitOffset
-      else
-        extend LimitHelpers::SqlServerAddLimitOffset
-      end
-      config[:sqlserver_version] ||= version
-    end
-    
-    # some QUOTING caching :
 
-    @@quoted_table_names = {}
+      super # configure_connection happens in super
 
-    def quote_table_name(name)
-      unless quoted = @@quoted_table_names[name]
-        quoted = super
-        @@quoted_table_names[name] = quoted.freeze
-      end
-      quoted
+      setup_limit_offset!
     end
 
-    @@quoted_column_names = {}
-
-    def quote_column_name(name)
-      unless quoted = @@quoted_column_names[name]
-        quoted = super
-        @@quoted_column_names[name] = quoted.freeze
-      end
-      quoted
-    end
-    
   end
-  
+
   class MSSQLColumn < JdbcColumn
-    include ArJdbc::MSSQL::Column
+    include ::ArJdbc::MSSQL::Column
   end
-  
+
 end