activerecord-sqlserver-adapter 3.0.19 → 3.1.0.beta1

data/CHANGELOG

@@ -1,32 +1,7 @@
 
-* 3.0.19 *
+* 3.1.0.beta1 *
 
-* Create a #configure_connection method that can be overridden. Think "SET TEXTSIZE...".
-
-* Create a #configure_application_name method that can be overridden for unique TinyTDS app names
-  to show up in SQL Server's activity monitor.
-
-* Fixed the #finish_statement_handle to cancel the TinyTDS connection if needed.
-
-* Fix the #indexes method to fail gracefully if sp_helptext permissions fail.
-
-
-
-* 3.0.18 *
-
-* Make #rollback_db_transaction smarter.
-
-
-* 3.0.17 *
-
-* Allow :limit/:offset to be used with fully qualified table and column in :select.
-
-* Fix test_count_explicit_columns.
-
-
-* 3.0.16 *
-
-* Allow complex order objects to not be molested by our visitor overrides. Fixes #99
+It just works! Uses "EXEC sp_executesql ..." for just about everything now!
 
 
 * 3.0.15 *

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

@@ -1,21 +1,25 @@
+require 'set'
+require 'active_record/base'
 require 'active_record/version'
-require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module CoreExt
         module ActiveRecord
-
-          def self.included(klass)
-            klass.extend ClassMethods
-            class << klass
-              alias_method_chain :reset_column_information, :sqlserver_cache_support
-            end
+          
+          extend ActiveSupport::Concern
+          
+          included do
+            class_attribute :coerced_sqlserver_date_columns, :coerced_sqlserver_time_columns
+            self.coerced_sqlserver_date_columns = Set.new
+            self.coerced_sqlserver_time_columns = Set.new
           end
 
           module ClassMethods
-
+            
             def execute_procedure(proc_name, *variables)
               if connection.respond_to?(:execute_procedure)
                 connection.execute_procedure(proc_name,*variables)
@@ -25,24 +29,11 @@ module ActiveRecord
             end
 
             def coerce_sqlserver_date(*attributes)
-              write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
+              self.coerced_sqlserver_date_columns += attributes.map(&:to_s)
             end
 
             def coerce_sqlserver_time(*attributes)
-              write_inheritable_attribute :coerced_sqlserver_time_columns, Set.new(attributes.map(&:to_s))
-            end
-
-            def coerced_sqlserver_date_columns
-              read_inheritable_attribute(:coerced_sqlserver_date_columns) || []
-            end
-
-            def coerced_sqlserver_time_columns
-              read_inheritable_attribute(:coerced_sqlserver_time_columns) || []
-            end
-
-            def reset_column_information_with_sqlserver_cache_support
-              connection.send(:initialize_sqlserver_caches) if connection.respond_to?(:sqlserver?)
-              reset_column_information_without_sqlserver_cache_support
+              self.coerced_sqlserver_time_columns += attributes.map(&:to_s)
             end
 
           end

data/lib/active_record/connection_adapters/sqlserver/core_ext/odbc.rb

@@ -4,22 +4,13 @@ module ActiveRecord
       module CoreExt
         module ODBC
 
-          module TimeStamp
-            
-            def to_sqlserver_string
-              date, time, nanoseconds = to_s.split(' ')
-              "#{date} #{time}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
-            end
-            
-          end
-
           module Statement
             
             def finished?
               begin
                 connected?
                 false
-              rescue *Database.parent_modules_error_exceptions
+              rescue ::ODBC::Error
                 true
               end
             end
@@ -28,14 +19,6 @@ module ActiveRecord
 
           module Database
             
-            def self.parent_modules
-              @parent_module ||= ['ODBC','ODBC_UTF8','ODBC_NONE'].map{ |odbc_ns| odbc_ns.constantize rescue nil }.compact
-            end
-            
-            def self.parent_modules_error_exceptions
-              @parent_modules_error_exceptions ||= parent_modules.map { |odbc_ns| "::#{odbc_ns}::Error".constantize }
-            end
-            
             def run_block(*args)
               yield sth = run(*args)
               sth.drop
@@ -49,9 +32,7 @@ module ActiveRecord
   end
 end
 
-['ODBC','ODBC_UTF8','ODBC_NONE'].map{ |odbc_ns| odbc_ns.constantize rescue nil }.compact.each do |ns|
-  ns::TimeStamp.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::TimeStamp
-  ns::Statement.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Statement
-  ns::Database.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Database
-end
+
+ODBC::Statement.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Statement
+ODBC::Database.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ODBC::Database
 

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

@@ -3,26 +3,47 @@ module ActiveRecord
     module Sqlserver
       module DatabaseStatements
         
-        def select_one(sql, name = nil)
-          result = raw_select sql, name, :fetch => :one
-          (result && result.first.present?) ? result.first : nil
-        end
-        
         def select_rows(sql, name = nil)
-          raw_select sql, name, :fetch => :rows
+          raw_select sql, name, [], :fetch => :rows
         end
 
-        def execute(sql, name = nil, skip_logging = false)
+        def execute(sql, name = nil)
           if id_insert_table_name = query_requires_identity_insert?(sql)
             with_identity_insert_enabled(id_insert_table_name) { do_execute(sql,name) }
           else
             do_execute(sql,name)
           end
         end
+        
+        def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
+          if id_insert_table_name = sqlserver_options[:insert] ? query_requires_identity_insert?(sql) : nil
+            with_identity_insert_enabled(id_insert_table_name) { do_exec_query(sql, name, binds) }
+          else
+            do_exec_query(sql, name, binds)
+          end
+        end
+        
+        def exec_insert(sql, name, binds)
+          exec_query sql, name, binds, :insert => true
+        end
+        
+        def exec_delete(sql, name, binds)
+          sql << "; SELECT @@ROWCOUNT AS AffectedRows"
+          super.rows.first.first
+        end
+
+        def exec_update(sql, name, binds)
+          sql << "; SELECT @@ROWCOUNT AS AffectedRows"
+          super.rows.first.first
+        end
 
         def outside_transaction?
           info_schema_query { select_value("SELECT @@TRANCOUNT") == 0 }
         end
+        
+        def supports_statement_cache?
+          true
+        end
 
         def begin_db_transaction
           do_execute "BEGIN TRANSACTION"
@@ -33,7 +54,7 @@ module ActiveRecord
         end
 
         def rollback_db_transaction
-          do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
+          do_execute "ROLLBACK TRANSACTION" rescue nil
         end
 
         def create_savepoint
@@ -55,15 +76,8 @@ module ActiveRecord
           "DEFAULT VALUES"
         end
 
-        def case_sensitive_equality_operator
-          cs_equality_operator
-        end
-
-        def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-          match_data = where_sql.match(/^(.*?[\]\) ])WHERE[\[\( ]/)
-          limit = match_data[1]
-          where_sql.sub!(limit,'')
-          "WHERE #{quoted_primary_key} IN (SELECT #{limit} #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
+        def case_sensitive_modifier(node)
+          node.acts_like?(:string) ? Arel::Nodes::Bin.new(node) : node
         end
         
         # === SQLServer Specific ======================================== #
@@ -190,29 +204,17 @@ module ActiveRecord
         
         protected
         
-        def select(sql, name = nil)
-          raw_select sql, name, :fetch => :all
+        def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds).to_a
         end
         
-        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-          @insert_sql = true
-          case @connection_options[:mode]
-          when :dblib
-            execute(sql, name) || id_value
-          else
-            super || select_value("SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
-          end
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+          sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"# unless binds.empty?
+          super
         end
-        
-        def update_sql(sql, name = nil)
-          @update_sql = true
-          case @connection_options[:mode]
-          when :dblib
-            execute(sql, name)
-          else
-            execute(sql, name)
-            select_value('SELECT @@ROWCOUNT AS AffectedRows')
-          end
+
+        def last_inserted_id(result)
+          super || select_value("SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
         end
         
         # === SQLServer Specific ======================================== #
@@ -230,24 +232,50 @@ module ActiveRecord
           end
         end
         
+        def do_exec_query(sql, name, binds)
+          statement = quote(sql)
+          names_and_types = []
+          params = []
+          binds.each_with_index do |(column,value),index|
+            ar_column = column.is_a?(ActiveRecord::ConnectionAdapters::Column)
+            next if ar_column && column.sql_type == 'timestamp'
+            v = value
+            names_and_types << if ar_column
+                                 v = value.to_i if column.is_integer?
+                                 "@#{index} #{column.sql_type_for_statement}"
+                               elsif column.acts_like?(:string)
+                                 "@#{index} nvarchar(max)"
+                               elsif column.is_a?(Fixnum)
+                                 v = value.to_i
+                                 "@#{index} int"
+                               else
+                                 raise "Unknown bind columns. We can account for this."
+                               end
+            quoted_value = ar_column ? quote(v,column) : quote(v,nil)
+            params << "@#{index} = #{quoted_value}"
+          end
+          sql = "EXEC sp_executesql #{statement}"
+          sql << ", #{quote(names_and_types.join(', '))}, #{params.join(', ')}" unless binds.empty?
+          raw_select sql, name, binds, :ar_result => true
+        end
+        
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
-            @insert_sql ? @connection.execute(sql).insert : @connection.execute(sql).do
+            @connection.execute(sql).do
           when :odbc
             @connection.do(sql)
           else :adonet
             @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
           end
         ensure
-          @insert_sql = false
           @update_sql = false
         end
         
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name=nil, options={})
-          log(sql,name) do
+        def raw_select(sql, name=nil, binds=[], options={})
+          log(sql,name,binds) do
             begin
               handle = raw_connection_run(sql)
               handle_to_names_and_values(handle, options)
@@ -294,56 +322,25 @@ module ActiveRecord
         def handle_to_names_and_values_dblib(handle, options={})
           query_options = {}.tap do |qo|
             qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
-            qo[:first] = true if options[:fetch] == :one
-            qo[:as] = options[:fetch] == :rows ? :array : :hash
+            qo[:as] = (options[:ar_result] || options[:fetch] == :rows) ? :array : :hash
           end
-          handle.each(query_options)
+          results = handle.each(query_options)
+          options[:ar_result] ? ActiveRecord::Result.new(handle.fields, results) : results
         end
         
         def handle_to_names_and_values_odbc(handle, options={})
-          @connection.use_utc = ActiveRecord::Base.default_timezone == :utc if @connection_supports_native_types
-          case options[:fetch]
-          when :all, :one
-            if @connection_supports_native_types
-              if options[:fetch] == :all
-                handle.each_hash || []
-              else
-                row = handle.fetch_hash
-                rows = row ? [row] : [[]]                    
-              end
-            else
-              rows = if options[:fetch] == :all
-                       handle.fetch_all || []
-                     else
-                       row = handle.fetch
-                       row ? [row] : [[]]                     
-                     end
-              names = handle.columns(true).map{ |c| c.name }
-              names_and_values = []
-              rows.each do |row|
-                h = {}
-                i = 0
-                while i < row.size
-                  v = row[i]
-                  h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
-                  i += 1
-                end
-                names_and_values << h
-              end
-              names_and_values
-            end
-          when :rows
+          @connection.use_utc = ActiveRecord::Base.default_timezone == :utc
+          if options[:ar_result]
+            columns = handle.columns(true).map { |c| c.name }
             rows = handle.fetch_all || []
-            return rows if @connection_supports_native_types
-            rows.each do |row|
-              i = 0
-              while i < row.size
-                v = row[i]
-                row[i] = v.to_sqlserver_string if v.respond_to?(:to_sqlserver_string)
-                i += 1
-              end
+            ActiveRecord::Result.new(columns, rows)
+          else
+            case options[:fetch]
+            when :all
+              handle.each_hash || []
+            when :rows
+              handle.fetch_all || []
             end
-            rows
           end
         end
 
@@ -352,7 +349,6 @@ module ActiveRecord
             names = []
             rows = []
             fields_named = options[:fetch] == :rows
-            one_row_only = options[:fetch] == :one
             while handle.read
               row = []
               handle.visible_field_count.times do |row_index|
@@ -371,7 +367,6 @@ module ActiveRecord
                         end
                 row << value
                 names << handle.get_name(row_index).to_s unless fields_named
-                break if one_row_only
               end
               rows << row
               fields_named = true
@@ -398,8 +393,7 @@ module ActiveRecord
         
         def finish_statement_handle(handle)
           case @connection_options[:mode]
-          when :dblib
-            handle.cancel if handle
+          when :dblib  
           when :odbc
             handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
           when :adonet

data/lib/active_record/connection_adapters/sqlserver/errors.rb

@@ -9,7 +9,7 @@ module ActiveRecord
         
         LOST_CONNECTION_EXCEPTIONS  = {
           :dblib  => ['TinyTds::Error'],
-          :odbc   => ['ODBC::Error','ODBC_UTF8::Error','ODBC_NONE::Error'],
+          :odbc   => ['ODBC::Error'],
           :adonet => ['TypeError','System::Data::SqlClient::SqlException']
         }.freeze
         

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -15,6 +15,8 @@ module ActiveRecord
             else
               super
             end
+          when nil
+            column.respond_to?(:sql_type) && column.sql_type == 'timestamp' ? 'DEFAULT' : super
           else
             super
           end
@@ -26,12 +28,20 @@ module ActiveRecord
 
         def quote_column_name(name)
           @sqlserver_quoted_column_and_table_names[name] ||= 
-            name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n.to_s.gsub(']', ']]')}]" }.join('.')
+            name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n}]" }.join('.')
         end
 
         def quote_table_name(name)
           quote_column_name(name)
         end
+        
+        def substitute_at(column, index)
+          if column.respond_to?(:sql_type) && column.sql_type == 'timestamp'
+            nil
+          else
+            Arel.sql "@#{index}"
+          end
+        end
 
         def quoted_true
           QUOTED_TRUE

data/lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -20,8 +20,7 @@ module ActiveRecord
 
         def indexes(table_name, name = nil)
           unquoted_table_name = unqualify_table_name(table_name)
-          data = select("EXEC sp_helpindex #{quote_table_name(unquoted_table_name)}",name) rescue []
-          data.inject([]) do |indexes,index|
+          select("EXEC sp_helpindex #{quote_table_name(unquoted_table_name)}",name).inject([]) do |indexes,index|
             index = index.with_indifferent_access
             if index[:index_description] =~ /primary key/
               indexes
@@ -40,8 +39,8 @@ module ActiveRecord
 
         def columns(table_name, name = nil)
           return [] if table_name.blank?
-          cache_key = columns_cache_key(table_name)
-          @sqlserver_columns_cache[cache_key] ||= column_definitions(table_name).collect do |ci|
+          cache_key = unqualify_table_name(table_name)
+          column_definitions(table_name).collect do |ci|
             sqlserver_options = ci.except(:name,:default_value,:type,:null).merge(:database_year=>database_year)
             SQLServerColumn.new ci[:name], ci[:default_value], ci[:type], ci[:null], sqlserver_options
           end
@@ -199,11 +198,13 @@ module ActiveRecord
               ELSE 1
             END as is_identity
             FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
-            WHERE columns.TABLE_NAME = '#{table_name}'
-              AND columns.TABLE_SCHEMA = #{table_schema.nil? ? "schema_name() " : "'#{table_schema}' "}
+            WHERE columns.TABLE_NAME = @0
+              AND columns.TABLE_SCHEMA = #{table_schema.blank? ? "schema_name()" : "@1"}
             ORDER BY columns.ordinal_position
           }.gsub(/[ \t\r\n]+/,' ')
-          results = info_schema_query { select(sql,nil) }
+          binds = [['table_name', table_name]]
+          binds << ['table_schema',table_schema] unless table_schema.blank?
+          results = info_schema_query { do_exec_query(sql, 'InfoSchema::ColumnDefinitions', binds) }
           results.collect do |ci|
             ci = ci.symbolize_keys
             ci[:type] = case ci[:type]
@@ -279,9 +280,9 @@ module ActiveRecord
         end
         
         def get_table_name(sql)
-          if sql =~ /^\s*insert\s+into\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
-            $1 || $2
-          elsif sql =~ /from\s+([^\(\s]+)\s*/i
+          if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)\s+INTO\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+            $2 || $3
+          elsif sql =~ /FROM\s+([^\(\s]+)\s*/i
             $1
           else
             nil
@@ -352,12 +353,10 @@ module ActiveRecord
 
         def remove_sqlserver_columns_cache_for(table_name)
           cache_key = unqualify_table_name(table_name)
-          @sqlserver_columns_cache[cache_key] = nil
           initialize_sqlserver_caches(false)
         end
 
         def initialize_sqlserver_caches(reset_columns=true)
-          @sqlserver_columns_cache = {} if reset_columns
           @sqlserver_views_cache = nil
           @sqlserver_view_information_cache = {}
           @sqlserver_quoted_column_and_table_names = {}
@@ -369,14 +368,14 @@ module ActiveRecord
           if insert_sql?(sql)
             table_name = get_table_name(sql)
             id_column = identity_column(table_name)
-            id_column && sql =~ /^\s*INSERT[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
           else
             false
           end
         end
         
         def insert_sql?(sql)
-          !(sql =~ /^\s*INSERT/i).nil?
+          !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
         
         def with_identity_insert_enabled(table_name)
@@ -389,7 +388,7 @@ module ActiveRecord
 
         def set_identity_insert(table_name, enable = true)
           sql = "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-          do_execute(sql,'IDENTITY_INSERT')
+          do_execute sql,'InfoSchema::SetIdentityInsert'
         rescue Exception => e
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -5,7 +5,6 @@ require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
 require 'active_record/connection_adapters/sqlserver/database_limits'
 require 'active_record/connection_adapters/sqlserver/database_statements'
 require 'active_record/connection_adapters/sqlserver/errors'
-require 'active_record/connection_adapters/sqlserver/query_cache'
 require 'active_record/connection_adapters/sqlserver/schema_statements'
 require 'active_record/connection_adapters/sqlserver/quoting'
 require 'active_support/core_ext/kernel/requires'
@@ -26,16 +25,7 @@ module ActiveRecord
         warn("TinyTds v0.4.3 or higher required. Using #{TinyTds::VERSION}") unless TinyTds::Client.instance_methods.map(&:to_s).include?("active?")
       when :odbc
         raise ArgumentError, 'Missing :dsn configuration.' unless config.has_key?(:dsn)
-        if RUBY_VERSION < '1.9'
-          require_library_or_gem 'odbc'
-        else
-          begin
-            # TODO: [ODBC] Change this to 'odbc_utf8'
-            require_library_or_gem 'odbc'
-          rescue LoadError
-            require_library_or_gem 'odbc'
-          end
-        end unless ['::ODBC','::ODBC_UTF8','::ODBC_NONE'].any? { |odbc_ns| odbc_ns.constantize rescue nil }
+        require_library_or_gem 'odbc'
         require 'active_record/connection_adapters/sqlserver/core_ext/odbc'
       when :adonet
         require 'System.Data'
@@ -61,7 +51,7 @@ module ActiveRecord
   module ConnectionAdapters
     
     class SQLServerColumn < Column
-            
+
       def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
         @sqlserver_options = sqlserver_options.symbolize_keys
         super(name, default, sql_type, null)
@@ -87,6 +77,14 @@ module ActiveRecord
         @sql_type =~ /nvarchar|ntext|nchar/i
       end
       
+      def is_integer?
+        @sql_type =~ /int/i
+      end
+      
+      def sql_type_for_statement
+        is_integer? ? sql_type.sub(/\(\d+\)/,'') : sql_type
+      end
+      
       def default_function
         @sqlserver_options[:default_function]
       end
@@ -160,11 +158,10 @@ module ActiveRecord
       include Sqlserver::DatabaseStatements
       include Sqlserver::SchemaStatements
       include Sqlserver::DatabaseLimits
-      include Sqlserver::QueryCache
       include Sqlserver::Errors
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '3.0.19'.freeze
+      VERSION                     = '3.1.0.beta1'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+"?(\d{4}|\w+)"?/
       SUPPORTED_VERSIONS          = [2005,2008,2010,2011].freeze
       
@@ -265,6 +262,11 @@ module ActiveRecord
         remove_database_connections_and_rollback { }
       end
       
+      def clear_cache!
+        # This requires db admin perms and I'm not even sure it is a good idea.
+        # raw_connection_do "DBCC FREEPROCCACHE WITH NO_INFOMSGS" rescue nil
+      end
+      
       # === Abstract Adapter (Misc Support) =========================== #
       
       def pk_and_sequence_for(table_name)
@@ -331,7 +333,7 @@ module ActiveRecord
       end
       
       def cs_equality_operator
-        @@cs_equality_operator || 'COLLATE Latin1_General_CS_AS_WS ='
+        @@cs_equality_operator || 'COLLATE Latin1_General_CS_AS_WS'
       end
       
       
@@ -358,7 +360,7 @@ module ActiveRecord
         config = @connection_options
         @connection = case @connection_options[:mode]
                       when :dblib
-                        appname = config[:appname] || configure_application_name || Rails.application.class.name.split('::').first rescue nil
+                        appname = config[:appname] || Rails.application.class.name.split('::').first rescue nil
                         login_timeout = config[:login_timeout].present? ? config[:login_timeout].to_i : nil
                         timeout = config[:timeout].present? ? config[:timeout].to_i/1000 : nil
                         encoding = config[:encoding].present? ? config[:encoding] : nil
@@ -390,20 +392,20 @@ module ActiveRecord
                           end
                         end
                       when :odbc
-                        odbc = ['::ODBC','::ODBC_UTF8','::ODBC_NONE'].detect{ |odbc_ns| odbc_ns.constantize rescue nil }.constantize
                         if config[:dsn].include?(';')
-                          driver = odbc::Driver.new.tap do |d|
+                          driver = ODBC::Driver.new.tap do |d|
                             d.name = config[:dsn_name] || 'Driver1'
                             d.attrs = config[:dsn].split(';').map{ |atr| atr.split('=') }.reject{ |kv| kv.size != 2 }.inject({}){ |h,kv| k,v = kv ; h[k] = v ; h }
                           end
-                          odbc::Database.new.drvconnect(driver)
+                          ODBC::Database.new.drvconnect(driver)
                         else
-                          odbc.connect config[:dsn], config[:username], config[:password]
-                        end.tap do |c|
-                          if c.respond_to?(:use_time)
+                          ODBC.connect config[:dsn], config[:username], config[:password]
+                        end.tap do |c|  
+                          begin
                             c.use_time = true
                             c.use_utc = ActiveRecord::Base.default_timezone == :utc
-                            @connection_supports_native_types = true
+                          rescue Exception => e
+                            warn "Ruby ODBC v0.99992 or higher is required."
                           end
                         end
                       when :adonet
@@ -423,24 +425,10 @@ module ActiveRecord
                           connection.open
                         end
                       end
-        configure_connection
       rescue
         raise unless @auto_connecting
       end
       
-      # Override this method so every connection can be configured to your needs.
-      # For example: 
-      #    do_execute "SET TEXTSIZE #{64.megabytes}"
-      #    do_execute "SET CONCAT_NULL_YIELDS_NULL ON"
-      def configure_connection
-      end
-      
-      # Override this method so every connection can have a unique name. Max 30 characters. Used by TinyTDS only.
-      # For example:
-      #    "myapp_#{$$}_#{Thread.current.object_id}".to(29)
-      def configure_application_name
-      end
-      
       def remove_database_connections_and_rollback(database=nil)
         database ||= current_database
         do_execute "ALTER DATABASE #{quote_table_name(database)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"

data/lib/arel/visitors/sqlserver.rb

@@ -4,10 +4,6 @@ module Arel
 
   module Nodes
 
-    # See the SelectManager#lock method on why this custom class is needed.
-    class LockWithSQLServer < Arel::Nodes::Unary
-    end
-
     # Extending the Ordering class to be comparrison friendly which allows us to call #uniq on a
     # collection of them. See SelectManager#order for more details.
     class Ordering < Arel::Nodes::Binary
@@ -26,8 +22,6 @@ module Arel
 
   class SelectManager < Arel::TreeManager
 
-    alias :lock_without_sqlserver :lock
-
     # Getting real Ordering objects is very important for us. We need to be able to call #uniq on
     # a colleciton of them reliably as well as using their true object attributes to mutate them
     # to grouping objects for the inner sql during a select statment with an offset/rownumber. So this
@@ -41,8 +35,6 @@ module Arel
           table = Arel::Table.new(x.relation.table_alias || x.relation.name)
           expr = table[x.name]
           Arel::Nodes::Ordering.new expr
-        when Arel::Nodes::Ordering
-          x
         when String
           x.split(',').map do |s|
             expr, direction = s.split
@@ -60,9 +52,17 @@ module Arel
 
     # A friendly over ride that allows us to put a special lock object that can have a default or pass
     # custom string hints down. See the visit_Arel_Nodes_LockWithSQLServer delegation method.
+    alias :lock_without_sqlserver :lock
     def lock(locking=true)
       if Arel::Visitors::SQLServer === @visitor
-        @ast.lock = Arel::Nodes::LockWithSQLServer.new(locking)
+        case locking
+        when true
+          locking = Arel.sql('WITH(HOLDLOCK, ROWLOCK)')
+        when Arel::Nodes::SqlLiteral
+        when String
+          locking = Arel.sql locking
+        end
+        @ast.lock = Arel::Nodes::Lock.new(locking)
         self
       else
         lock_without_sqlserver(locking)
@@ -96,22 +96,14 @@ module Arel
         "TOP (#{visit o.expr})"
       end
 
-      def visit_Arel_Nodes_Lock o
-        "WITH(HOLDLOCK, ROWLOCK)"
+      def visit_Arel_Nodes_Lock(o)
+        visit o.expr
       end
 
-      def visit_Arel_Nodes_LockWithSQLServer o
-        case o.expr
-        when TrueClass
-          "WITH(HOLDLOCK, ROWLOCK)"
-        when String
-          o.expr
-        else
-          ""
-        end
+      def visit_Arel_Nodes_Bin(o)
+        "#{visit o.expr} #{@engine.connection.cs_equality_operator}"
       end
 
-
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatementWithOutOffset(o, windowed=false)
@@ -129,6 +121,8 @@ module Arel
             expr = Arel.sql projection_without_expression(x.expr)
             x.descending? ? Arel::Nodes::Max.new([expr]) : Arel::Nodes::Min.new([expr])
           end
+        elsif top_one_everything_for_through_join?(o)
+          projections = projections.map { |x| projection_without_expression(x) }
         end
         [ ("SELECT" if !windowed),
           (visit(o.limit) if o.limit && !windowed),
@@ -178,9 +172,8 @@ module Arel
       # SQLServer Helpers
 
       def source_with_lock_for_select_statement(o)
-        # TODO: [ARel 2.2] Use #from/#source vs. #froms
         core = o.cores.first
-        source = "FROM #{visit core.froms}" if core.froms
+        source = visit(core.source).strip if core.source
         if source && o.lock
           lock = visit o.lock
           index = source.match(/FROM [\w\[\]\.]+/)[0].length
@@ -220,11 +213,21 @@ module Arel
           ((p1.respond_to?(:distinct) && p1.distinct) ||
             p1.respond_to?(:include?) && p1.include?('DISTINCT'))
       end
+      
+      def single_distinct_select_everything_statement?(o)
+        single_distinct_select_statement?(o) && visit(o.cores.first.projections.first).ends_with?(".*")
+      end
+      
+      def top_one_everything_for_through_join?(o)
+        single_distinct_select_everything_statement?(o) && 
+          (o.limit && !o.offset) && 
+          join_in_select_statement?(o)
+      end
 
       def all_projections_aliased_in_select_statement?(o)
         projections = o.cores.first.projections
         projections.all? do |x|
-          x.split(',').all? { |y| y.include?(' AS ') }
+          visit(x).split(',').all? { |y| y.include?(' AS ') }
         end
       end
 
@@ -235,14 +238,15 @@ module Arel
 
       def eager_limiting_select_statement?(o)
         core = o.cores.first
-        single_distinct_select_statement?(o) && (o.limit && !o.offset) && core.groups.empty?
+        single_distinct_select_statement?(o) && 
+          (o.limit && !o.offset) && 
+          core.groups.empty? && 
+          !single_distinct_select_everything_statement?(o)
       end
 
       def join_in_select_statement?(o)
         core = o.cores.first
-        # TODO: [ARel 2.2] Use #from/#source vs. #froms
-        # core.source.right.any? { |x| Arel::Nodes::Join === x }
-        Arel::Nodes::Join === core.froms
+        core.source.right.any? { |x| Arel::Nodes::Join === x }
       end
 
       def complex_count_sql?(o)
@@ -291,11 +295,20 @@ module Arel
           end
         elsif join_in_select_statement?(o) && all_projections_aliased_in_select_statement?(o)
           core.projections.map do |x|
-            Arel.sql x.split(',').map{ |y| y.split(' AS ').last.strip }.join(', ')
+            Arel.sql visit(x).split(',').map{ |y| y.split(' AS ').last.strip }.join(', ')
           end
+        elsif function_select_statement?(o)
+          [Arel.star]
         else
-          # TODO: [ARel 2.2] Use Arel.star
-          [Arel.sql('[__rnt].*')]
+          core.projections.map do |x|
+            if x.respond_to?(:relation)
+              x = x.dup
+              x.relation = x.relation.dup
+              x.relation.instance_variable_set :@table_alias, Arel.sql('[__rnt].*')
+            else
+              x
+            end
+          end
         end
       end
 
@@ -312,7 +325,7 @@ module Arel
 
       # TODO: We use this for grouping too, maybe make Grouping objects vs SqlLiteral.
       def projection_without_expression(projection)
-        Arel.sql(projection.split(',').map do |x|
+        Arel.sql(visit(projection).split(',').map do |x|
           x.strip!
           x.sub!(/^(COUNT|SUM|MAX|MIN|AVG)\s*(\((.*)\))?/,'\3')
           x.sub!(/^DISTINCT\s*/,'')

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
-version: !ruby/object:Gem::Version 
-  hash: 33
-  prerelease: 
-  segments: 
-  - 3
-  - 0
-  - 19
-  version: 3.0.19
+version: !ruby/object:Gem::Version
+  version: 3.1.0.beta1
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Ken Collins
 - Murray Steele
 - Shawn Balestracci
@@ -18,51 +13,38 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-23 00:00:00 -04:00
+date: 2011-05-06 00:00:00.000000000 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2171145400 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 3
-        - 0
-        - 3
+      - !ruby/object:Gem::Version
         version: 3.0.3
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: arel
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2171145400
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: &2171144680 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 1
-        segments: 
-        - 2
-        - 0
-        - 7
+      - !ruby/object:Gem::Version
         version: 2.0.7
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *2171144680
 description: SQL Server 2005 and 2008 Adapter For ActiveRecord
 email: ken@metaskills.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - CHANGELOG
 - MIT-LICENSE
 - README.rdoc
@@ -71,7 +53,6 @@ files:
 - lib/active_record/connection_adapters/sqlserver/database_limits.rb
 - lib/active_record/connection_adapters/sqlserver/database_statements.rb
 - lib/active_record/connection_adapters/sqlserver/errors.rb
-- lib/active_record/connection_adapters/sqlserver/query_cache.rb
 - lib/active_record/connection_adapters/sqlserver/quoting.rb
 - lib/active_record/connection_adapters/sqlserver/schema_statements.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
@@ -80,37 +61,28 @@ files:
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: activerecord-sqlserver-adapter
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: SQL Server 2005 and 2008 Adapter For ActiveRecord.
 test_files: []
-

data/lib/active_record/connection_adapters/sqlserver/query_cache.rb

@@ -1,17 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module Sqlserver
-      module QueryCache
-        
-        def select_one(*args)
-          if @query_cache_enabled
-            cache_sql(args.first) { super }
-          else
-            super
-          end
-        end
-        
-      end
-    end
-  end
-end