Single PORO for decomposing and quoting SQL Server names/identifiers.

Please read this article for all details:
http://technet.microsoft.com/en-us/library/ms187879(v=sql.105).aspx

Author: metaskills

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -116,8 +116,8 @@ def execute_procedure(proc_name, *variables)
 
         def use_database(database = nil)
           return if sqlserver_azure?
-          database ||= @connection_options[:database]
-          do_execute "USE #{quote_database_name(database)}" unless database.blank?
+          name = Sqlserver::Utils.extract_identifiers(database || @connection_options[:database])
+          do_execute "USE #{name}" unless database.blank?
         end
 
         def user_options
@@ -258,7 +258,7 @@ def drop_database(database)
           retry_count = 0
           max_retries = 1
           begin
-            do_execute "DROP DATABASE #{quote_database_name(database)}"
+            do_execute "DROP DATABASE #{Sqlserver::Utils.extract_identifiers(database)}"
           rescue ActiveRecord::StatementInvalid => err
             if err.message =~ /because it is currently in use/i
               raise if retry_count >= max_retries
@@ -274,10 +274,11 @@ def drop_database(database)
         end
 
         def create_database(database, collation = @connection_options[:collation])
+          name = Sqlserver::Utils.extract_identifiers(database)
           if collation
-            do_execute "CREATE DATABASE #{quote_database_name(database)} COLLATE #{collation}"
+            do_execute "CREATE DATABASE #{name} COLLATE #{collation}"
           else
-            do_execute "CREATE DATABASE #{quote_database_name(database)}"
+            do_execute "CREATE DATABASE #{name}"
           end
         end
 

lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -38,22 +38,18 @@ def quoted_string_prefix
           QUOTED_STRING_PREFIX
         end
 
-        def quote_string(string)
-          string.to_s.gsub(/\'/, "''")
+        def quote_string(s)
+          Sqlserver::Utils.quote_string(s)
         end
 
         def quote_column_name(name)
-          schema_cache.quote_name(name)
+          Sqlserver::Utils.extract_identifiers(name).object_quoted
         end
 
         def quote_table_name(name)
           quote_column_name(name)
         end
 
-        def quote_database_name(name)
-          schema_cache.quote_name(name, false)
-        end
-
         # Does not quote function default values for UUID columns
         def quote_default_value(value, column)
           if column.type == :uuid && value =~ /\(\)/

lib/active_record/connection_adapters/sqlserver/schema_cache.rb

@@ -2,14 +2,14 @@ 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
@@ -26,7 +26,6 @@ def clear!
           @table_names = nil
           @view_names = nil
           @view_information.clear
-          @quoted_names.clear
         end
 
         def clear_table_cache!(table_name)
@@ -65,25 +64,13 @@ def view_information(table_name)
           @view_information[key] = connection.send(:view_information, table_name)
         end
 
-        def quote_name(name, split_on_dots = true)
-          return @quoted_names[name] if @quoted_names.key? name
-
-          @quoted_names[name] = if split_on_dots
-                                  name.to_s.split('.').map { |n| quote_name_part(n) }.join('.')
-                                else
-                                  quote_name_part(name.to_s)
-                                end
-        end
 
         private
 
-        def quote_name_part(part)
-          part =~ /^\[.*\]$/ ? part : "[#{part.to_s.gsub(']', ']]')}]"
-        end
-
         def table_name_key(table_name)
-          Utils.unqualify_table_name(table_name)
+          Sqlserver::Utils.extract_identifiers(table_name).object
         end
+
       end
     end
   end

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -12,7 +12,7 @@ def tables(table_type = 'BASE TABLE')
 
         def table_exists?(table_name)
           return false if table_name.blank?
-          unquoted_table_name = Utils.unqualify_table_name(table_name)
+          unquoted_table_name = Sqlserver::Utils.extract_identifiers(table_name).object
           super || tables.include?(unquoted_table_name) || views.include?(unquoted_table_name)
         end
 
@@ -181,10 +181,10 @@ def initialize_native_database_types
         end
 
         def column_definitions(table_name)
-          db_name = Utils.unqualify_db_name(table_name)
+          db_name = Sqlserver::Utils.extract_identifiers(table_name).database
           db_name_with_period = "#{db_name}." if db_name
-          table_schema = Utils.unqualify_table_schema(table_name)
-          table_name = Utils.unqualify_table_name(table_name)
+          table_schema = Sqlserver::Utils.extract_identifiers(table_name).schema
+          table_name = Sqlserver::Utils.extract_identifiers(table_name).object
           sql = %{
             SELECT DISTINCT
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
@@ -329,7 +329,7 @@ def view_table_name(table_name)
         end
 
         def view_information(table_name)
-          table_name = Utils.unqualify_table_name(table_name)
+          table_name = Sqlserver::Utils.extract_identifiers(table_name).object
           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
@@ -346,7 +346,7 @@ def view_information(table_name)
         end
 
         def table_name_or_views_table_name(table_name)
-          unquoted_table_name = Utils.unqualify_table_name(table_name)
+          unquoted_table_name = Sqlserver::Utils.extract_identifiers(table_name).object
           schema_cache.view_names.include?(unquoted_table_name) ? view_table_name(unquoted_table_name) : unquoted_table_name
         end
 

lib/active_record/connection_adapters/sqlserver/utils.rb

@@ -1,25 +1,117 @@
+require 'strscan'
+
 module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
-      class Utils
-        class << self
-          def unquote_string(string)
-            string.to_s.gsub(/\'\'/, "'")
+      module Utils
+
+        # Value object to return identifiers from SQL Server names http://bit.ly/1CZ3EiL
+        # Inspiried from Rails PostgreSQL::Name adapter object in their own Utils.
+        #
+        class Name
+
+          SEPARATOR = "."
+          SCANNER   = /\]?\./
+
+          attr_reader :server, :database, :schema, :object
+          attr_reader :raw_name
+
+          def initialize(name)
+            @raw_name = name.to_s
+            parse_raw_name
+          end
+
+          def object_quoted
+            quote object
+          end
+
+          def schema_quoted
+            schema ? quote(schema) : schema
           end
 
-          def unqualify_table_name(table_name)
-            table_name.to_s.split('.').last.tr('[]', '')
+          def database_quoted
+            database ? quote(database) : database
           end
 
-          def unqualify_table_schema(table_name)
-            table_name.to_s.split('.')[-2].gsub(/[\[\]]/, '') rescue nil
+          def server_quoted
+            server ? quote(server) : server
           end
 
-          def unqualify_db_name(table_name)
-            table_names = table_name.to_s.split('.')
-            table_names.length == 3 ? table_names.first.tr('[]', '') : nil
+          def to_s
+            quoted
           end
+
+          def quoted
+            parts.map{ |p| quote(p) if p }.join SEPARATOR
+          end
+
+          def ==(o)
+            o.class == self.class && o.parts == parts
+          end
+          alias_method :eql?, :==
+
+          def hash
+            parts.hash
+          end
+
+          protected
+
+          def parse_raw_name
+            @parts = []
+            return if raw_name.blank?
+            scanner = StringScanner.new(raw_name)
+            matched = scanner.scan_until(SCANNER)
+            while matched
+              part = matched[0..-2]
+              @parts << (part.blank? ? nil : unquote(part))
+              matched = scanner.scan_until(SCANNER)
+            end
+            case @parts.length
+            when 3
+              @server, @database, @schema = @parts
+            when 2
+              @database, @schema = @parts
+            when 1
+              @schema = @parts.first
+            end
+            rest = scanner.rest
+            rest = rest.starts_with?('.') ? rest[1..-1] : rest[0..-1]
+            @object = unquote(rest)
+            @parts << @object
+          end
+
+          def quote(part)
+            part =~ /\A\[.*\]\z/ ? part : "[#{part.to_s.gsub(']', ']]')}]"
+          end
+
+          def unquote(part)
+            if part && part.start_with?('[')
+              part[1..-2]
+            else
+              part
+            end
+          end
+
+          def parts
+            @parts
+          end
+
         end
+
+        extend self
+
+        def quote_string(s)
+          s.gsub /\'/, "''"
+        end
+
+        def unquote_string(s)
+          s.to_s.gsub(/\'\'/, "'")
+        end
+
+        def extract_identifiers(name)
+          Sqlserver::Utils::Name.new(name)
+        end
+
       end
     end
   end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -373,12 +373,12 @@ def initialize_dateformatter
       end
 
       def remove_database_connections_and_rollback(database = nil)
-        database ||= current_database
-        do_execute "ALTER DATABASE #{quote_database_name(database)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
+        name = Sqlserver::Utils.extract_identifiers(database || current_database)
+        do_execute "ALTER DATABASE #{name} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
         begin
           yield
         ensure
-          do_execute "ALTER DATABASE #{quote_database_name(database)} SET MULTI_USER"
+          do_execute "ALTER DATABASE #{name} SET MULTI_USER"
         end if block_given?
       end
 

test/cases/adapter_test_sqlserver.rb

@@ -112,41 +112,6 @@ class AdapterTestSqlserver < ActiveRecord::TestCase
 
     end
 
-    context 'for Utils.unqualify_table_name and Utils.unqualify_db_name' do
-
-      setup do
-        @expected_table_name = 'baz'
-        @expected_db_name = 'foo'
-        @first_second_table_names = ['[baz]','baz','[bar].[baz]','bar.baz']
-        @third_table_names = ['[foo].[bar].[baz]','foo.bar.baz']
-        @qualifed_table_names = @first_second_table_names + @third_table_names
-      end
-
-      should 'return clean table_name from Utils.unqualify_table_name' do
-        @qualifed_table_names.each do |qtn|
-          assert_equal @expected_table_name,
-            ActiveRecord::ConnectionAdapters::Sqlserver::Utils.unqualify_table_name(qtn),
-            "This qualifed_table_name #{qtn} did not unqualify correctly."
-        end
-      end
-
-      should 'return nil from Utils.unqualify_db_name when table_name is less than 2 qualified' do
-        @first_second_table_names.each do |qtn|
-          assert_equal nil, ActiveRecord::ConnectionAdapters::Sqlserver::Utils.unqualify_db_name(qtn),
-            "This qualifed_table_name #{qtn} did not return nil."
-        end
-      end
-
-      should 'return clean db_name from Utils.unqualify_db_name when table is thrid level qualified' do
-        @third_table_names.each do |qtn|
-          assert_equal @expected_db_name,
-            ActiveRecord::ConnectionAdapters::Sqlserver::Utils.unqualify_db_name(qtn),
-            "This qualifed_table_name #{qtn} did not unqualify the db_name correctly."
-        end
-      end
-
-    end
-
     should 'return true to #insert_sql? for inserts only' do
       assert @connection.send(:insert_sql?,'INSERT...')
       assert @connection.send(:insert_sql?, "EXEC sp_executesql N'INSERT INTO [fk_test_has_fks] ([fk_id]) VALUES (@0); SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident', N'@0 int', @0 = 0")

test/cases/schema_test_sqlserver.rb

@@ -8,10 +8,6 @@ class SchemaTestSqlserver < ActiveRecord::TestCase
     @connection = ActiveRecord::Base.connection
   end
 
-  def read_schema_name(table_name)
-    ActiveRecord::ConnectionAdapters::Sqlserver::Utils.unqualify_table_schema(table_name)
-  end
-
   context 'When table is dbo schema' do
 
     should 'find primary key for tables with odd schema' do
@@ -50,14 +46,6 @@ def read_schema_name(table_name)
       assert_equal 1, columns.select{ |c| c.primary }.size
     end
 
-    should "return schema name in all cases" do
-      assert_nil read_schema_name("table")
-      assert_equal "schema1", read_schema_name("schema1.table")
-      assert_equal "schema2", read_schema_name("database.schema2.table")
-      assert_equal "schema3", read_schema_name("server.database.schema3.table")
-      assert_equal "schema3", read_schema_name("[server].[database].[schema3].[table]")
-    end
-
     should "return correct varchar and nvarchar column limit (length) when table is in non dbo schema" do
       columns = @connection.columns("test.sql_server_schema_columns")
       assert_equal 255, columns.find {|c| c.name == 'name'}.limit