activerecord-sqlserver-adapter 3.1.1 → 3.2.18

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

@@ -2,19 +2,18 @@ module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module SchemaStatements
-        
+
         def native_database_types
           @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)
-          unquoted_table_name = unqualify_table_name(table_name)
+          return false if table_name.blank?
+          unquoted_table_name = Utils.unqualify_table_name(table_name)
           super || tables.include?(unquoted_table_name) || views.include?(unquoted_table_name)
         end
 
@@ -39,70 +38,62 @@ 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?
+          ActiveSupport::Deprecation.warn 'Passing array to remove_columns is deprecated, please use multiple arguments, like: `remove_columns(:posts, :foo, :bar)`', caller if column_names.flatten!
           column_names.flatten.each do |column_name|
             remove_check_constraints(table_name, column_name)
             remove_default_constraint(table_name, column_name)
             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 }
-          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
+          indexes = []
+          column_object = schema_cache.columns[table_name].detect { |c| c.name.to_s == column_name.to_s }
+
           if options_include_default?(options) || (column_object && column_object.type != type.to_sym)
-           	remove_default_constraint(table_name,column_name)
+            remove_default_constraint(table_name,column_name)
+            indexes = indexes(table_name).select{ |index| index.columns.include?(column_name.to_s) }
+            remove_indexes(table_name, column_name)
           end
+          sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(options[:default])} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
+          sql_commands << "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_commands[-1] << " NOT NULL" if !options[:null].nil? && options[:null] == false
           if options_include_default?(options)
             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
+
+          #Add any removed indexes back
+          indexes.each do |index|
+            sql_commands << "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index.columns.collect {|c|quote_column_name(c)}.join(', ')})"
+          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)
+          schema_cache.clear_table_cache!(table_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)
           do_execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
         end
@@ -123,27 +114,27 @@ module ActiveRecord
           end
         end
 
-        def change_column_null(table_name, column_name, null, default = nil)
-          column = detect_column_for!(table_name,column_name)
-          unless null || default.nil?
+        def change_column_null(table_name, column_name, allow_null, default = nil)
+          column = detect_column_for! table_name, column_name
+          if !allow_null.nil? && allow_null == false && !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
           sql = "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql column.type, column.limit, column.precision, column.scale}"
-          sql << " NOT NULL" unless null
+          sql << " NOT NULL" if !allow_null.nil? && allow_null == false
           do_execute sql
         end
-        
+
         # === SQLServer Specific ======================================== #
-        
-        def views(name = nil)
-          @sqlserver_views_cache ||= tables(name,'VIEW')
+
+        def views
+          tables('VIEW')
         end
-        
-        
+
+
         protected
-        
+
         # === SQLServer Specific ======================================== #
-        
+
         def initialize_native_database_types
           {
             :primary_key  => "int NOT NULL IDENTITY(1,1) PRIMARY KEY",
@@ -170,12 +161,12 @@ 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 
+            SELECT DISTINCT
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
             #{lowercase_schema_reflection_sql('columns.COLUMN_NAME')} AS name,
             columns.DATA_TYPE AS type,
@@ -185,28 +176,44 @@ module ActiveRecord
             columns.ordinal_position,
             CASE
               WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
-              ELSE COL_LENGTH(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
+              ELSE COL_LENGTH('#{db_name_with_period}'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
             END AS [length],
             CASE
               WHEN columns.IS_NULLABLE = 'YES' THEN 1
               ELSE NULL
             END AS [is_nullable],
-            CASE 
-              WHEN CCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
-              WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 1 THEN 1
+            CASE
+              WHEN KCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
               ELSE NULL
-            END AS [is_identity]
+            END AS [is_primary],
+            c.is_identity AS [is_identity]
             FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS columns
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC ON TC.TABLE_NAME = columns.TABLE_NAME AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' 
-            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS CCU ON TC.CONSTRAINT_NAME = CCU.CONSTRAINT_NAME AND CCU.COLUMN_NAME = columns.COLUMN_NAME
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
+              ON TC.TABLE_NAME = columns.TABLE_NAME
+              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            LEFT OUTER JOIN #{db_name_with_period}INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
+              ON KCU.COLUMN_NAME = columns.COLUMN_NAME
+              AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
+              AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
+            INNER JOIN #{db_name}.sys.schemas AS s
+              ON s.name = columns.TABLE_SCHEMA
+              AND s.schema_id = s.schema_id
+            INNER JOIN #{db_name}.sys.objects AS o
+              ON s.schema_id = o.schema_id
+              AND o.is_ms_shipped = 0
+              AND o.type IN ('U', 'V')
+              AND o.name = columns.TABLE_NAME
+            INNER JOIN #{db_name}.sys.columns AS c
+              ON o.object_id = c.object_id
+              AND c.name = columns.COLUMN_NAME
             WHERE columns.TABLE_NAME = @0
               AND columns.TABLE_SCHEMA = #{table_schema.blank? ? "schema_name()" : "@1"}
             ORDER BY columns.ordinal_position
-            
           }.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]
@@ -221,11 +228,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)'
@@ -238,13 +245,14 @@ module ActiveRecord
                                    match_data ? match_data[1] : nil
                                  end
             ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
-            ci[:is_identity] = ci[:is_identity].to_i == 1
+            ci[:is_primary] = ci[:is_primary].to_i == 1
+            ci[:is_identity] = ci[:is_identity].to_i == 1 unless [TrueClass, FalseClass].include?(ci[:is_identity].class)
             ci
           end
         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
@@ -252,7 +260,7 @@ module ActiveRecord
 
         def remove_default_constraint(table_name, column_name)
           # If their are foreign keys in this table, we could still get back a 2D array, so flatten just in case.
-          select_all("EXEC sp_helpconstraint '#{quote_string(table_name)}','nomsg'").flatten.select do |row|
+          execute_procedure(:sp_helpconstraint, table_name, 'nomsg').flatten.select do |row|
             row['constraint_type'] == "DEFAULT on column #{column_name}"
           end.each do |row|
             do_execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row['constraint_name']}"
@@ -264,26 +272,9 @@ module ActiveRecord
             remove_index(table_name, {:name => index.name})
           end
         end
-        
-        # === 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
+        # === SQLServer Specific (Misc Helpers) ========================= #
 
-        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
@@ -293,69 +284,57 @@ module ActiveRecord
             nil
           end
         end
-        
+
         def default_constraint_name(table_name, column_name)
           "DF_#{table_name}_#{column_name}"
         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
         end
-        
+
         def lowercase_schema_reflection_sql(node)
           lowercase_schema_reflection ? "LOWER(#{node})" : node
         end
-        
+
         # === 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)
@@ -367,11 +346,11 @@ module ActiveRecord
             false
           end
         end
-        
+
         def insert_sql?(sql)
           !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
-        
+
         def with_identity_insert_enabled(table_name)
           table_name = quote_table_name(table_name_or_views_table_name(table_name))
           set_identity_insert(table_name, true)
@@ -382,13 +361,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(&:primary) || columns(table_name).detect(&:is_identity?)
+          schema_cache.columns[table_name].detect(&:is_identity?)
         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/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/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
+
+