activerecord-sqlserver-adapter 3.1.7 → 3.2.0.rc1

data/CHANGELOG

@@ -1,20 +1,16 @@
 
-* 3.1.7 *
+* 3.2.0 *
 
-* Fix exists? with offset by patching visitor. Fixes #171 and Fixes #167
+* ActiveRecord explain (SHOWPLAN) support. 
+  http://youtu.be/ckb3YYZZZ2Q
 
-* Set default text size to 2147483647 for TinyTDS connections. Fixes #181
+* Remove our log_info_schema_queries config since we are not hooking properly into AR's 'SCHEMA' names.
 
-* Set @config ivar for 3rd party libs. Fixes #177
+* Properly use 'SCHEMA' name arguement in DB statements to comply with ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS.
 
-* Strengthen #query_requires_identity_insert? by looking for VALUES at the end. Fixes #178
+* Make use of the new ConnectionAdapters::SchemaCache for our needs.
 
-* Make #sql_type_for_statement work for integers that may have empty parens or none at all. Fixes #175
-
-
-* 3.1.6 *
-
-* Add explicit order-by clause for windowed results. Fixes #161.
+* New Sqlserver::Utils class for out helpers. Moved table name unquotes there.
 
 
 * 3.1.5 *

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

@@ -1,9 +1,3 @@
-require 'set'
-require 'active_record/base'
-require 'active_record/version'
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
-
 module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
@@ -46,4 +40,3 @@ end
 
 
 ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::ActiveRecord
-

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

@@ -0,0 +1,41 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module CoreExt
+        module Explain
+          
+          SQLSERVER_STATEMENT_PREFIX = "EXEC sp_executesql "
+          SQLSERVER_PARAM_MATCHER = /@\d+ =/
+          
+          def exec_explain(queries)
+            unprepared_queries = queries.map { |sql, bind| [unprepare_sqlserver_statement(sql), bind] }
+            super(unprepared_queries)
+          end
+          
+          private
+          
+          # This is somewhat hacky, but it should reliably reformat our prepared sql statment 
+          # which uses sp_executesql to just the first argument, then unquote it. Likewise our 
+          # do_exec_query method should substitude the @n args withe the quoted values.
+          def unprepare_sqlserver_statement(sql)
+            if sql.starts_with?(SQLSERVER_STATEMENT_PREFIX)
+              executesql = sql.from(SQLSERVER_STATEMENT_PREFIX.length)
+              executesql_args = executesql.split(', ')
+              executesql_args.reject! { |arg| arg =~ SQLSERVER_PARAM_MATCHER }
+              executesql_args.pop if executesql_args.many?
+              executesql = executesql_args.join(', ').strip.match(/N'(.*)'/)[1]
+              Utils.unquote_string(executesql)
+            else
+              sql
+            end
+          end
+          
+          
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::Explain
+ActiveRecord::Relation.send :include, ActiveRecord::ConnectionAdapters::Sqlserver::CoreExt::Explain

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

@@ -40,7 +40,7 @@ module ActiveRecord
         end
 
         def outside_transaction?
-          info_schema_query { select_value("SELECT @@TRANCOUNT") == 0 }
+          select_value('SELECT @@TRANCOUNT', 'SCHEMA') == 0
         end
         
         def supports_statement_cache?
@@ -131,19 +131,17 @@ module ActiveRecord
         
         def user_options
           return {} if sqlserver_azure?
-          info_schema_query do
-            select_rows("dbcc useroptions").inject(HashWithIndifferentAccess.new) do |values,row| 
-              set_option = row[0].gsub(/\s+/,'_')
-              user_value = row[1]
-              values[set_option] = user_value
-              values
-            end
+          select_rows("dbcc useroptions",'SCHEMA').inject(HashWithIndifferentAccess.new) do |values,row| 
+            set_option = row[0].gsub(/\s+/,'_')
+            user_value = row[1]
+            values[set_option] = user_value
+            values
           end
         end
         
         def user_options_dateformat
           if sqlserver_azure?
-            info_schema_query { select_value "SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID" }
+            select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
           else
             user_options['dateformat']
           end
@@ -151,18 +149,16 @@ module ActiveRecord
         
         def user_options_isolation_level
           if sqlserver_azure?
-            info_schema_query do
-              sql = %|SELECT CASE [transaction_isolation_level] 
-                      WHEN 0 THEN NULL
-                      WHEN 1 THEN 'READ UNCOMITTED' 
-                      WHEN 2 THEN 'READ COMITTED' 
-                      WHEN 3 THEN 'REPEATABLE' 
-                      WHEN 4 THEN 'SERIALIZABLE' 
-                      WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level] 
-                      FROM [sys].[dm_exec_sessions] 
-                      WHERE [session_id] = @@SPID|.squish
-              select_value(sql)
-            end
+            sql = %|SELECT CASE [transaction_isolation_level] 
+                    WHEN 0 THEN NULL
+                    WHEN 1 THEN 'READ UNCOMITTED' 
+                    WHEN 2 THEN 'READ COMITTED' 
+                    WHEN 3 THEN 'REPEATABLE' 
+                    WHEN 4 THEN 'SERIALIZABLE' 
+                    WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level] 
+                    FROM [sys].[dm_exec_sessions] 
+                    WHERE [session_id] = @@SPID|.squish
+            select_value sql, 'SCHEMA'
           else
             user_options['isolation_level']
           end
@@ -170,7 +166,7 @@ module ActiveRecord
         
         def user_options_language
           if sqlserver_azure?
-            info_schema_query { select_value "SELECT @@LANGUAGE AS [language]" }
+            select_value 'SELECT @@LANGUAGE AS [language]', 'SCHEMA'
           else
             user_options['language']
           end
@@ -314,15 +310,14 @@ module ActiveRecord
         
         # === SQLServer Specific (Executing) ============================ #
 
-        def do_execute(sql, name = nil)
-          name ||= 'EXECUTE'
+        def do_execute(sql, name = 'SQL')
           log(sql, name) do
             with_sqlserver_error_handling { raw_connection_do(sql) }
           end
         end
         
         def do_exec_query(sql, name, binds)
-          statement = quote(sql)
+          explaining = name == 'EXPLAIN'
           names_and_types = []
           params = []
           binds.each_with_index do |(column,value),index|
@@ -341,10 +336,17 @@ module ActiveRecord
                                  raise "Unknown bind columns. We can account for this."
                                end
             quoted_value = ar_column ? quote(v,column) : quote(v,nil)
-            params << "@#{index} = #{quoted_value}"
+            params << (explaining ? quoted_value : "@#{index} = #{quoted_value}")
+          end
+          if explaining
+            params.each_with_index do |param, index|
+              substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
+              sql.sub! substitute_at_finder, param
+            end
+          else
+            sql = "EXEC sp_executesql #{quote(sql)}"
+            sql << ", #{quote(names_and_types.join(', '))}, #{params.join(', ')}" unless binds.empty?
           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
         
@@ -361,7 +363,7 @@ module ActiveRecord
         
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name=nil, binds=[], options={})
+        def raw_select(sql, name='SQL', binds=[], options={})
           log(sql,name,binds) { _raw_select(sql, options) }
         end
         

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

@@ -42,8 +42,7 @@ module ActiveRecord
         end
 
         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('.')
+          schema_cache.quote_name(name)
         end
 
         def quote_table_name(name)

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

@@ -0,0 +1,85 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      class SchemaCache < ActiveRecord::ConnectionAdapters::SchemaCache
+        
+        attr_reader :view_information
+        
+        def initialize(conn)
+          super
+          @table_names = nil
+          @view_names = nil
+          @view_information = {}
+          @quoted_names = {}
+        end
+        
+        # Superclass Overrides
+        
+        def table_exists?(table_name)
+          return false if table_name.blank?
+          key = table_name_key(table_name)
+          return @tables[key] if @tables.key? key
+          @tables[key] = connection.table_exists?(table_name)
+        end
+        
+        def clear!
+          super
+          @table_names = nil
+          @view_names = nil
+          @view_information.clear
+          @quoted_names.clear
+        end
+        
+        def clear_table_cache!(table_name)
+          key = table_name_key(table_name)
+          super(key)
+          super(table_name)
+          # SQL Server Specific
+          if @table_names
+            @table_names.delete key
+            @table_names.delete table_name
+          end
+          if @view_names
+            @view_names.delete key
+            @view_names.delete table_name
+          end
+          @view_information.delete key
+        end
+        
+        # SQL Server Specific
+        
+        def table_names
+          @table_names ||= connection.tables
+        end
+        
+        def view_names
+          @view_names ||= connection.views
+        end
+        
+        def view_exists?(table_name)
+          table_exists?(table_name)
+        end
+        
+        def view_information(table_name)
+          key = table_name_key(table_name)
+          return @view_information[key] if @view_information.key? key
+          @view_information[key] = connection.send(:view_information, table_name)
+        end
+        
+        def quote_name(name)
+          return @quoted_names[name] if @quoted_names.key? name
+          @quoted_names[name] = name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n.to_s.gsub(']', ']]')}]" }.join('.')
+        end
+        
+        
+        private
+        
+        def table_name_key(table_name)
+          Utils.unqualify_table_name(table_name)
+        end
+        
+      end
+    end
+  end
+end
+

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

@@ -7,15 +7,13 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def tables(name = nil, table_type = 'BASE TABLE')
-          info_schema_query do
-            select_values "SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.TABLES #{"WHERE TABLE_TYPE = '#{table_type}'" if table_type} ORDER BY TABLE_NAME"
-          end
+        def tables(table_type = 'BASE TABLE')
+          select_values "SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.TABLES #{"WHERE TABLE_TYPE = '#{table_type}'" if table_type} ORDER BY TABLE_NAME", 'SCHEMA'
         end
 
         def table_exists?(table_name)
           return false if table_name.blank?
-          unquoted_table_name = unqualify_table_name(table_name)
+          unquoted_table_name = Utils.unqualify_table_name(table_name)
           super || tables.include?(unquoted_table_name) || views.include?(unquoted_table_name)
         end
 
@@ -40,31 +38,16 @@ module ActiveRecord
 
         def columns(table_name, name = nil)
           return [] if table_name.blank?
-          @sqlserver_columns_cache[table_name] ||= column_definitions(table_name).collect do |ci|
+          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
         end
-
-        def create_table(table_name, options = {})
-          super
-          clear_cache!
-        end
         
         def rename_table(table_name, new_name)
           do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
         end
         
-        def drop_table(table_name, options = {})
-          super
-          clear_cache!
-        end
-
-        def add_column(table_name, column_name, type, options = {})
-          super
-          clear_cache!
-        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?
           column_names.flatten.each do |column_name|
@@ -73,12 +56,11 @@ module ActiveRecord
             remove_indexes(table_name, column_name)
             do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
           end
-          clear_cache!
         end
 
         def change_column(table_name, column_name, type, options = {})
           sql_commands = []
-          column_object = columns(table_name).detect { |c| c.name.to_s == column_name.to_s }
+          column_object = schema_cache.columns[table_name].detect { |c| c.name.to_s == column_name.to_s }
           change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
           change_column_sql << " NOT NULL" if options[:null] == false
           sql_commands << change_column_sql
@@ -89,19 +71,16 @@ module ActiveRecord
             sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name,column_name)} DEFAULT #{quote(options[:default])} FOR #{quote_column_name(column_name)}"
           end
           sql_commands.each { |c| do_execute(c) }
-          clear_cache!
         end
 
         def change_column_default(table_name, column_name, default)
           remove_default_constraint(table_name, column_name)
           do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
-          clear_cache!
         end
 
         def rename_column(table_name, column_name, new_column_name)
-          detect_column_for!(table_name,column_name)
+          detect_column_for! table_name, column_name
           do_execute "EXEC sp_rename '#{table_name}.#{column_name}', '#{new_column_name}', 'COLUMN'"
-          clear_cache!
         end
         
         def remove_index!(table_name, index_name)
@@ -125,7 +104,7 @@ module ActiveRecord
         end
 
         def change_column_null(table_name, column_name, null, default = nil)
-          column = detect_column_for!(table_name,column_name)
+          column = detect_column_for! table_name, column_name
           unless null || default.nil?
             do_execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
           end
@@ -136,8 +115,8 @@ module ActiveRecord
         
         # === SQLServer Specific ======================================== #
         
-        def views(name = nil)
-          @sqlserver_views_cache ||= tables(name,'VIEW')
+        def views
+          tables('VIEW')
         end
         
         
@@ -171,10 +150,10 @@ module ActiveRecord
         end
 
         def column_definitions(table_name)
-          db_name = unqualify_db_name(table_name)
+          db_name = Utils.unqualify_db_name(table_name)
           db_name_with_period = "#{db_name}." if db_name
-          table_schema = unqualify_table_schema(table_name)
-          table_name = unqualify_table_name(table_name)
+          table_schema = Utils.unqualify_table_schema(table_name)
+          table_name = Utils.unqualify_table_name(table_name)
           sql = %{
             SELECT DISTINCT 
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
@@ -215,7 +194,7 @@ module ActiveRecord
           }.gsub(/[ \t\r\n]+/,' ')
           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 = do_exec_query(sql, 'SCHEMA', binds)
           results.collect do |ci|
             ci = ci.symbolize_keys
             ci[:type] = case ci[:type]
@@ -230,11 +209,11 @@ module ActiveRecord
                          else
                            ci[:type]
                          end
-            if ci[:default_value].nil? && views.include?(table_name)
+            if ci[:default_value].nil? && schema_cache.view_names.include?(table_name)
               real_table_name = table_name_or_views_table_name(table_name)
               real_column_name = views_real_column_name(table_name,ci[:name])
               col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
-              ci[:default_value] = info_schema_query { select_value(col_default_sql) }
+              ci[:default_value] = select_value col_default_sql, 'SCHEMA'
             end
             ci[:default_value] = case ci[:default_value]
                                  when nil, '(null)', '(NULL)'
@@ -254,7 +233,7 @@ module ActiveRecord
         end
         
         def remove_check_constraints(table_name, column_name)
-          constraints = info_schema_query { select_values("SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'") }
+          constraints = select_values "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'", 'SCHEMA'
           constraints.each do |constraint|
             do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
           end
@@ -277,23 +256,6 @@ module ActiveRecord
         
         # === SQLServer Specific (Misc Helpers) ========================= #
         
-        def info_schema_query
-          log_info_schema_queries ? yield : ActiveRecord::Base.silence{ yield }
-        end
-        
-        def unqualify_table_name(table_name)
-          table_name.to_s.split('.').last.tr('[]','')
-        end
-
-        def unqualify_table_schema(table_name)
-          table_name.to_s.split('.')[-2].gsub(/[\[\]]/,'') rescue nil
-        end
-
-        def unqualify_db_name(table_name)
-          table_names = table_name.to_s.split('.')
-          table_names.length == 3 ? table_names.first.tr('[]','') : nil
-        end
-        
         def get_table_name(sql)
           if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)\s+INTO\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
             $2 || $3
@@ -309,7 +271,7 @@ module ActiveRecord
         end
         
         def detect_column_for!(table_name, column_name)
-          unless column = columns(table_name).detect { |c| c.name == column_name.to_s }
+          unless column = schema_cache.columns[table_name].detect { |c| c.name == column_name.to_s }
             raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
           end
           column
@@ -322,57 +284,45 @@ module ActiveRecord
         # === SQLServer Specific (View Reflection) ====================== #
         
         def view_table_name(table_name)
-          view_info = view_information(table_name)
+          view_info = schema_cache.view_information(table_name)
           view_info ? get_table_name(view_info['VIEW_DEFINITION']) : table_name
         end
         
         def view_information(table_name)
-          table_name = unqualify_table_name(table_name)
-          @sqlserver_view_information_cache[table_name] ||= begin
-            view_info = info_schema_query { select_one("SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'") }
-            if view_info
-              view_info = view_info.with_indifferent_access
-              if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
-                view_info[:VIEW_DEFINITION] = info_schema_query do
-                                                begin
-                                                  select_values("EXEC sp_helptext #{quote_table_name(table_name)}").join
-                                                rescue
-                                                  warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
-                                                end
-                                              end
-              end
+          table_name = Utils.unqualify_table_name(table_name)
+          view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'", 'SCHEMA'
+          if view_info
+            view_info = view_info.with_indifferent_access
+            if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
+              view_info[:VIEW_DEFINITION] = begin
+                                              select_values("EXEC sp_helptext #{quote_table_name(table_name)}", 'SCHEMA').join
+                                            rescue
+                                              warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                                              nil
+                                            end
             end
-            view_info
           end
+          view_info
         end
         
         def table_name_or_views_table_name(table_name)
-          unquoted_table_name = unqualify_table_name(table_name)
-          views.include?(unquoted_table_name) ? view_table_name(unquoted_table_name) : unquoted_table_name
+          unquoted_table_name = Utils.unqualify_table_name(table_name)
+          schema_cache.view_names.include?(unquoted_table_name) ? view_table_name(unquoted_table_name) : unquoted_table_name
         end
         
         def views_real_column_name(table_name,column_name)
-          view_definition = view_information(table_name)[:VIEW_DEFINITION]
+          view_definition = schema_cache.view_information(table_name)[:VIEW_DEFINITION]
           match_data = view_definition.match(/([\w-]*)\s+as\s+#{column_name}/im)
           match_data ? match_data[1] : column_name
         end
         
-        # === SQLServer Specific (Column/View Caches) =================== #
-
-        def initialize_sqlserver_caches
-          @sqlserver_columns_cache = {}
-          @sqlserver_views_cache = nil
-          @sqlserver_view_information_cache = {}
-          @sqlserver_quoted_column_and_table_names = {}
-        end
-        
         # === SQLServer Specific (Identity Inserts) ===================== #
 
         def query_requires_identity_insert?(sql)
           if insert_sql?(sql)
             table_name = get_table_name(sql)
             id_column = identity_column(table_name)
-            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\).*?VALUES/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
@@ -392,13 +342,13 @@ module ActiveRecord
 
         def set_identity_insert(table_name, enable = true)
           sql = "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-          do_execute sql,'InfoSchema::SetIdentityInsert'
+          do_execute sql, 'SCHEMA'
         rescue Exception => e
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end
 
         def identity_column(table_name)
-          columns(table_name).detect(&:is_identity?)
+          schema_cache.columns[table_name].detect(&:is_identity?)
         end
 
       end

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

@@ -0,0 +1,67 @@
+require 'active_record/connection_adapters/sqlserver/showplan/printer_table'
+require 'active_record/connection_adapters/sqlserver/showplan/printer_xml'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module Showplan
+        
+        OPTION_ALL  = 'SHOWPLAN_ALL'
+        OPTION_TEXT = 'SHOWPLAN_TEXT'
+        OPTION_XML  = 'SHOWPLAN_XML'
+        OPTIONS = [OPTION_ALL, OPTION_TEXT, OPTION_XML]
+        
+        def explain(arel, binds = [])
+          sql = to_sql(arel)
+          result = with_showplan_on { do_exec_query(sql, 'EXPLAIN', binds) }
+          printer = showplan_printer.new(result)
+          printer.pp
+        end
+        
+        
+        protected
+        
+        def with_showplan_on
+          set_showplan_option(true)
+          yield
+        ensure
+          set_showplan_option(false)
+        end
+        
+        def set_showplan_option(enable = true)
+          sql = "SET #{option} #{enable ? 'ON' : 'OFF'}"
+          raw_connection_do(sql)
+        rescue Exception => e
+          raise ActiveRecordError, "#{option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
+        end
+        
+        def option
+          (SQLServerAdapter.showplan_option || OPTION_ALL).tap do |opt|
+            raise(ArgumentError, "Unknown SHOWPLAN option #{opt.inspect} found.") if OPTIONS.exclude?(opt)
+          end
+        end
+        
+        def showplan_all?
+          option == OPTION_ALL
+        end
+        
+        def showplan_text?
+          option == OPTION_TEXT
+        end
+        
+        def showplan_xml?
+          option == OPTION_XML
+        end
+        
+        def showplan_printer
+          case option
+          when OPTION_XML then PrinterXml
+          when OPTION_ALL, OPTION_TEXT then PrinterTable
+          else PrinterTable
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver/showplan/printer_table.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module Showplan
+        class PrinterTable
+          
+          cattr_accessor :max_column_width, :cell_padding
+          self.max_column_width = 50
+          self.cell_padding = 1
+          
+          attr_reader :result
+          
+          def initialize(result)
+            @result = result
+          end
+          
+          def pp
+            @widths = compute_column_widths
+            @separator = build_separator
+            pp = []
+            pp << @separator
+            pp << build_cells(result.columns)
+            pp << @separator
+            result.rows.each do |row|
+              pp << build_cells(row)
+            end
+            pp << @separator
+            pp.join("\n") + "\n"
+          end
+          
+          private
+
+          def compute_column_widths
+            [].tap do |computed_widths|
+              result.columns.each_with_index do |column, i|
+                cells_in_column = [column] + result.rows.map { |r| cast_item(r[i]) }
+                computed_width = cells_in_column.map(&:length).max
+                final_width = computed_width > max_column_width ? max_column_width : computed_width
+                computed_widths << final_width
+              end
+            end
+          end
+          
+          def build_separator
+            '+' + @widths.map {|w| '-' * (w + (cell_padding*2))}.join('+') + '+'
+          end
+          
+          def build_cells(items)
+            cells = []
+            items.each_with_index do |item, i|
+              cells << cast_item(item).ljust(@widths[i])
+            end
+            "| #{cells.join(' | ')} |"
+          end
+          
+          def cast_item(item)
+            case item
+            when NilClass then 'NULL'
+            when Float then item.to_s.to(9)
+            else item.to_s.truncate(max_column_width)
+            end
+          end
+          
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver/showplan/printer_xml.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module Showplan
+        class PrinterXml
+          
+          def initialize(result)
+            @result = result
+          end
+          
+          def pp
+            xml = @result.rows.first.first
+            if defined?(Nokogiri)
+              Nokogiri::XML(xml).to_xml :indent => 2, :encoding => 'UTF-8'
+            else
+              xml
+            end
+          end
+          
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      class Utils
+        
+        class << self
+          
+          def unquote_string(string)
+            string.to_s.gsub(/\'\'/, "'")
+          end
+          
+          def unqualify_table_name(table_name)
+            table_name.to_s.split('.').last.tr('[]','')
+          end
+
+          def unqualify_table_schema(table_name)
+            table_name.to_s.split('.')[-2].gsub(/[\[\]]/,'') rescue nil
+          end
+
+          def unqualify_db_name(table_name)
+            table_names = table_name.to_s.split('.')
+            table_names.length == 3 ? table_names.first.tr('[]','') : nil
+          end
+          
+        end
+        
+      end
+    end
+  end
+end
+
+

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

@@ -3,7 +3,7 @@ module ActiveRecord
     module Sqlserver
       module Version
         
-        VERSION = '3.1.7'
+        VERSION = '3.2.0.rc1'
         
       end
     end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,17 +1,22 @@
+require 'base64'
 require 'arel/visitors/sqlserver'
 require 'active_record'
+require 'active_record/base'
+require 'active_support/concern'
+require 'active_support/core_ext/string'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
 require 'active_record/connection_adapters/sqlserver/core_ext/database_statements'
+require 'active_record/connection_adapters/sqlserver/core_ext/explain'
 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/schema_cache'
 require 'active_record/connection_adapters/sqlserver/schema_statements'
+require 'active_record/connection_adapters/sqlserver/showplan'
 require 'active_record/connection_adapters/sqlserver/quoting'
+require 'active_record/connection_adapters/sqlserver/utils'
 require 'active_record/connection_adapters/sqlserver/version'
-require 'active_support/core_ext/kernel/requires'
-require 'active_support/core_ext/string'
-require 'base64'
 
 module ActiveRecord
   
@@ -32,7 +37,7 @@ module ActiveRecord
       else
         raise ArgumentError, "Unknown connection mode in #{config.inspect}."
       end
-      ConnectionAdapters::SQLServerAdapter.new(logger,config.merge(:mode=>mode))
+      ConnectionAdapters::SQLServerAdapter.new(nil, logger, nil, config.merge(:mode=>mode))
     end
     
     protected
@@ -91,7 +96,7 @@ module ActiveRecord
       
       def sql_type_for_statement
         if is_integer? || is_real?
-          sql_type.sub(/\((\d+)?\)/,'')
+          sql_type.sub(/\(\d+\)/,'')
         else
           sql_type
         end
@@ -168,6 +173,7 @@ module ActiveRecord
       
       include Sqlserver::Quoting
       include Sqlserver::DatabaseStatements
+      include Sqlserver::Showplan
       include Sqlserver::SchemaStatements
       include Sqlserver::DatabaseLimits
       include Sqlserver::Errors
@@ -180,25 +186,22 @@ module ActiveRecord
       attr_reader :database_version, :database_year, :spid, :product_level, :product_version, :edition
       
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
-                     :log_info_schema_queries, :enable_default_unicode_types, :auto_connect, :retry_deadlock_victim,
-                     :cs_equality_operator, :lowercase_schema_reflection, :auto_connect_duration
+                     :enable_default_unicode_types, :auto_connect, :retry_deadlock_victim,
+                     :cs_equality_operator, :lowercase_schema_reflection, :auto_connect_duration,
+                     :showplan_option
       
       self.enable_default_unicode_types = true
       
-      class << self
-        
-        def visitor_for(pool)
-          Arel::Visitors::SQLServer.new(pool)
-        end
-        
-      end
       
-      def initialize(logger,config)
+      def initialize(connection, logger, pool, config)
+        super(connection, logger, pool)
+        # AbstractAdapter Responsibility
+        @schema_cache = Sqlserver::SchemaCache.new self
+        @visitor = Arel::Visitors::SQLServer.new self
+        # Our Responsibility
         @connection_options = config
         connect
-        super(@connection, logger)
-        @config = config
-        @database_version = info_schema_query { select_value('SELECT @@version') }
+        @database_version = select_value 'SELECT @@version', 'SCHEMA'
         @database_year = begin
                            if @database_version =~ /Microsoft SQL Azure/i
                              @sqlserver_azure = true
@@ -210,11 +213,10 @@ module ActiveRecord
                          rescue
                            0
                          end
-        @product_level    = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('productlevel') AS VARCHAR(128))") }
-        @product_version  = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('productversion') AS VARCHAR(128))") }
-        @edition          = info_schema_query { select_value("SELECT CAST(SERVERPROPERTY('edition') AS VARCHAR(128))") }
+        @product_level    = select_value "SELECT CAST(SERVERPROPERTY('productlevel') AS VARCHAR(128))", 'SCHEMA'
+        @product_version  = select_value "SELECT CAST(SERVERPROPERTY('productversion') AS VARCHAR(128))", 'SCHEMA'
+        @edition          = select_value "SELECT CAST(SERVERPROPERTY('edition') AS VARCHAR(128))", 'SCHEMA'
         initialize_dateformatter
-        initialize_sqlserver_caches
         use_database
         unless SUPPORTED_VERSIONS.include?(@database_year)
           raise NotImplementedError, "Currently, only #{SUPPORTED_VERSIONS.to_sentence} are supported. We got back #{@database_version}."
@@ -243,10 +245,22 @@ module ActiveRecord
         true
       end
       
+      def supports_bulk_alter?
+        false
+      end
+      
       def supports_savepoints?
         true
       end
       
+      def supports_index_sort_order?
+        true
+      end
+      
+      def supports_explain?
+        true
+      end
+      
       def disable_referential_integrity
         do_execute "EXEC sp_MSforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
         yield
@@ -287,10 +301,6 @@ module ActiveRecord
         remove_database_connections_and_rollback { }
       end
       
-      def clear_cache!
-        initialize_sqlserver_caches
-      end
-      
       # === Abstract Adapter (Misc Support) =========================== #
       
       def pk_and_sequence_for(table_name)
@@ -299,7 +309,7 @@ module ActiveRecord
       end
 
       def primary_key(table_name)
-        identity_column(table_name).try(:name) || columns(table_name).detect(&:is_primary?).try(:name)
+        identity_column(table_name).try(:name) || schema_cache.columns[table_name].detect(&:is_primary?).try(:name)
       end
       
       # === SQLServer Specific (DB Reflection) ======================== #
@@ -392,7 +402,7 @@ module ActiveRecord
       
       def connect
         config = @connection_options
-        @connection = case @connection_options[:mode]
+        @connection = case config[:mode]
                       when :dblib
                         appname = config[:appname] || configure_application_name || Rails.application.class.name.split('::').first rescue nil
                         login_timeout = config[:login_timeout].present? ? config[:login_timeout].to_i : nil
@@ -424,7 +434,6 @@ module ActiveRecord
                             client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
                             client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
                           end
-                          client.execute("SET TEXTSIZE 2147483647").do
                         end
                       when :odbc
                         if config[:dsn].include?(';')
@@ -444,7 +453,7 @@ module ActiveRecord
                           end
                         end
                       end
-        @spid             = _raw_select("SELECT @@SPID", :fetch => :rows).first.first
+        @spid = _raw_select("SELECT @@SPID", :fetch => :rows).first.first
         configure_connection
       rescue
         raise unless @auto_connecting

data/lib/arel/visitors/sqlserver.rb

@@ -154,8 +154,9 @@ module Arel
           projections = projections.map { |x| projection_without_expression(x) }
         end
         [ ("SELECT" if !windowed),
+          (visit(core.set_quantifier) if core.set_quantifier),
           (visit(o.limit) if o.limit && !windowed),
-          (projections.map{ |x| v = visit(x); v == "1" ? "1 AS [__wrp]" : v }.join(', ')),
+          (projections.map{ |x| visit(x) }.join(', ')),
           (source_with_lock_for_select_statement(o)),
           ("WHERE #{core.wheres.map{ |x| visit(x) }.join ' AND ' }" unless core.wheres.empty?),
           ("GROUP BY #{groups.map { |x| visit x }.join ', ' }" unless groups.empty?),
@@ -165,7 +166,6 @@ module Arel
       end
 
       def visit_Arel_Nodes_SelectStatementWithOffset(o)
-        o.limit ||= Arel::Nodes::Limit.new(9223372036854775807)
         orders = rowtable_orders(o)
         [ "SELECT",
           (visit(o.limit) if o.limit && !windowed_single_distinct_select_statement?(o)),
@@ -175,7 +175,6 @@ module Arel
             visit_Arel_Nodes_SelectStatementWithOutOffset(o,true),
           ") AS [__rnt]",
           (visit(o.offset) if o.offset),
-          "ORDER BY [__rnt].[__rn] ASC"
         ].compact.join ' '
       end
 

metadata

@@ -1,10 +1,17 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
-version: !ruby/object:Gem::Version
-  version: 3.1.7
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: 15424087
+  prerelease: 6
+  segments: 
+  - 3
+  - 2
+  - 0
+  - rc
+  - 1
+  version: 3.2.0.rc1
 platform: ruby
-authors:
+authors: 
 - Ken Collins
 - Murray Steele
 - Shawn Balestracci
@@ -13,61 +20,90 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-13 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-01-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activerecord
-  requirement: &70306769696760 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.1.0
+      - !ruby/object:Gem::Version 
+        hash: 15424087
+        segments: 
+        - 3
+        - 2
+        - 0
+        - rc
+        - 1
+        version: 3.2.0.rc1
   type: :runtime
-  prerelease: false
-  version_requirements: *70306769696760
+  version_requirements: *id001
 description: SQL Server 2005 and 2008 Adapter For ActiveRecord
 email: ken@metaskills.net
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - CHANGELOG
 - MIT-LICENSE
 - lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/database_statements.rb
+- lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/odbc.rb
 - 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/quoting.rb
+- lib/active_record/connection_adapters/sqlserver/schema_cache.rb
 - lib/active_record/connection_adapters/sqlserver/schema_statements.rb
+- lib/active_record/connection_adapters/sqlserver/showplan/printer_table.rb
+- lib/active_record/connection_adapters/sqlserver/showplan/printer_xml.rb
+- lib/active_record/connection_adapters/sqlserver/showplan.rb
+- lib/active_record/connection_adapters/sqlserver/utils.rb
 - lib/active_record/connection_adapters/sqlserver/version.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-sqlserver-adapter.rb
 - lib/arel/visitors/sqlserver.rb
 homepage: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-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
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
+
 rubyforge_project: activerecord-sqlserver-adapter
-rubygems_version: 1.8.17
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
 summary: SQL Server 2005 and 2008 Adapter For ActiveRecord.
 test_files: []
+