activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

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

@@ -1,32 +1,7 @@
 module ActiveRecord
-  class LostConnection < WrappedDatabaseException
-  end
 
   class DeadlockVictim < WrappedDatabaseException
   end
 
-  module ConnectionAdapters
-    module Sqlserver
-      module Errors
-        LOST_CONNECTION_EXCEPTIONS  = {
-          dblib: ['TinyTds::Error'],
-          odbc: ['ODBC::Error']
-        }.freeze
-
-        LOST_CONNECTION_MESSAGES    = {
-          dblib: [/closed connection/, /dead or not enabled/, /server failed/i],
-          odbc: [/link failure/, /server failed/, /connection was already closed/, /invalid handle/i]
-        }.freeze
 
-        def lost_connection_exceptions
-          exceptions = LOST_CONNECTION_EXCEPTIONS[@connection_options[:mode]]
-          @lost_connection_exceptions ||= exceptions ? exceptions.map { |e| e.constantize rescue nil }.compact : []
-        end
-
-        def lost_connection_messages
-          LOST_CONNECTION_MESSAGES[@connection_options[:mode]]
-        end
-      end
-    end
-  end
 end

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

@@ -1,73 +1,25 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module Quoting
-        QUOTED_TRUE, QUOTED_FALSE = '1', '0'
-        QUOTED_STRING_PREFIX = 'N'
-
-        def quote(value, column = nil)
-          case value
-          when String, ActiveSupport::Multibyte::Chars
-            if column && column.type == :integer && value.blank?
-              value.to_i.to_s
-            elsif column && column.type == :binary
-              column.class.string_to_binary(value)
-            elsif column && [:uuid, :uniqueidentifier].include?(column.type)
-              "'#{quote_string(value)}'"
-            elsif value.is_utf8? || (column && column.type == :string)
-              "#{quoted_string_prefix}'#{quote_string(value)}'"
-            else
-              super
-            end
-          when Date, Time
-            if column && column.sql_type == 'datetime'
-              "'#{quoted_datetime(value)}'"
-            elsif column && (column.sql_type == 'datetimeoffset' || column.sql_type == 'time')
-              "'#{quoted_full_iso8601(value)}'"
-            else
-              super
-            end
-          when nil
-            column.respond_to?(:sql_type) && column.sql_type == 'timestamp' ? 'DEFAULT' : super
-          else
-            super
-          end
-        end
 
-        def quoted_string_prefix
-          QUOTED_STRING_PREFIX
-        end
+        QUOTED_TRUE  = '1'
+        QUOTED_FALSE = '0'
+        QUOTED_STRING_PREFIX = 'N'
 
-        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).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 =~ /\(\)/
             value
           else
-            quote(value)
-          end
-        end
-
-        def substitute_at(column, index)
-          if column.respond_to?(:sql_type) && column.sql_type == 'timestamp'
-            nil
-          else
-            Arel::Nodes::BindParam.new "@#{index}"
+            quote(value, column)
           end
         end
 
@@ -75,47 +27,56 @@ module ActiveRecord
           QUOTED_TRUE
         end
 
+        def unquoted_true
+          1
+        end
+
         def quoted_false
           QUOTED_FALSE
         end
 
-        def quoted_datetime(value)
-          if value.acts_like?(:time)
-            time_zone_qualified_value = quoted_value_acts_like_time_filter(value)
-            if value.is_a?(Date)
-              time_zone_qualified_value.iso8601(3).to(18)
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          SQLServer::Utils.with_sqlserver_db_date_formats do
+            if value.acts_like?(:time) && value.respond_to?(:usec)
+              precision = (BigDecimal(value.usec.to_s) / 1_000_000).round(3).to_s.split('.').last
+              "#{super}.#{precision}"
+            elsif value.acts_like?(:date)
+              value.to_s(:_sqlserver_dateformat)
             else
-              time_zone_qualified_value.iso8601(3).to(22)
+              super
             end
-          else
-            quoted_date(value)
           end
         end
 
-        def quoted_full_iso8601(value)
-          if value.acts_like?(:time)
-            value.is_a?(Date) ? quoted_value_acts_like_time_filter(value).to_time.xmlschema.to(18) : quoted_value_acts_like_time_filter(value).iso8601(7).to(22)
-          else
-            quoted_date(value)
-          end
-        end
 
-        def quoted_date(value)
-          if value.acts_like?(:time) && value.respond_to?(:usec)
-            "#{super}.#{sprintf('%03d', value.usec / 1000)}"
-          elsif value.acts_like?(:date)
-            value.to_s(:_sqlserver_dateformat)
+        private
+
+        def _quote(value)
+          case value
+          when Type::Binary::Data
+            "0x#{value.hex}"
+          when SQLServer::Type::Quoter
+            value.quote_ss_value
+          when String, ActiveSupport::Multibyte::Chars
+            if value.is_utf8?
+              "#{QUOTED_STRING_PREFIX}#{super}"
+            else
+              super
+            end
           else
             super
           end
         end
 
-        protected
-
         def quoted_value_acts_like_time_filter(value)
           zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
           value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
         end
+
       end
     end
   end

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

@@ -1,89 +1,113 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       class SchemaCache < ActiveRecord::ConnectionAdapters::SchemaCache
-        attr_reader :view_information
 
         def initialize(conn)
           super
-          @table_names = nil
-          @view_names = nil
+          @views = {}
           @view_information = {}
-          @quoted_names = {}
         end
 
         # Superclass Overrides
 
+        def primary_keys(table_name)
+          name = key(table_name)
+          @primary_keys[name] ||= table_exists?(table_name) ? connection.primary_key(table_name) : nil
+        end
+
         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)
+          name = key(table_name)
+          prepare_tables_and_views
+          return @tables[name] if @tables.key? name
+          table_exists = @tables[name] = connection.table_exists?(table_name)
+          table_exists || view_exists?(table_name)
+        end
+
+        def tables(name)
+          super(key(name))
+        end
+
+        def columns(table_name)
+          name = key(table_name)
+          @columns[name] ||= connection.columns(table_name)
+        end
+
+        def columns_hash(table_name)
+          name = key(table_name)
+          @columns_hash[name] ||= Hash[columns(table_name).map { |col|
+            [col.name, col]
+          }]
         end
 
         def clear!
           super
-          @table_names = nil
-          @view_names = nil
+          @views.clear
           @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
+        def size
+          super + [@views, @view_information].map{ |x| x.size }.inject(:+)
         end
 
-        # SQL Server Specific
+        def clear_table_cache!(table_name)
+          name = key(table_name)
+          @columns.delete name
+          @columns_hash.delete name
+          @primary_keys.delete name
+          @tables.delete name
+          @views.delete name
+          @view_information.delete name
+        end
 
-        def table_names
-          @table_names ||= connection.tables
+        def marshal_dump
+          super + [@views, @view_information]
         end
 
-        def view_names
-          @view_names ||= connection.views
+        def marshal_load(array)
+          @views, @view_information = array[-2..-1]
+          super(array[0..-3])
         end
 
+        # SQL Server Specific
+
         def view_exists?(table_name)
-          table_exists?(table_name)
+          name = key(table_name)
+          prepare_tables_and_views
+          return @views[name] if @views.key? name
+          @views[name] = connection.views.include?(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)
+          name = key(table_name)
+          return @view_information[name] if @view_information.key? name
+          @view_information[name] = 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
+        private
+
+        def identifier(table_name)
+          SQLServer::Utils.extract_identifiers(table_name)
+        end
+
+        def key(table_name)
+          identifier(table_name).quoted
         end
 
-        private
+        def prepare_tables_and_views
+          prepare_views if @views.empty?
+          prepare_tables if @tables.empty?
+        end
 
-        def quote_name_part(part)
-          part =~ /^\[.*\]$/ ? part : "[#{part.to_s.gsub(']', ']]')}]"
+        def prepare_tables
+          connection.tables.each { |table| @tables[key(table)] = true }
         end
 
-        def table_name_key(table_name)
-          Utils.unqualify_table_name(table_name)
+        def prepare_views
+          connection.views.each { |view| @views[key(view)] = true }
         end
+
       end
     end
   end

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

@@ -1,7 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       class SchemaCreation < AbstractAdapter::SchemaCreation
+
         private
 
         def visit_ColumnDefinition(o)
@@ -13,43 +14,26 @@ module ActiveRecord
           sql
         end
 
-        def add_column_options!(sql, options)
-          column = options.fetch(:column) { return super }
-          if [:uniqueidentifier, :uuid].include?(column.type) && options[:default] =~ /\(\)/
-            sql << " DEFAULT #{options.delete(:default)}"
-            super
+        def visit_TableDefinition(o)
+          if o.as
+            table_name = quote_table_name(o.temporary ? "##{o.name}" : o.name)
+            projections, source = @conn.to_sql(o.as).match(%r{SELECT\s+(.*)?\s+FROM\s+(.*)?}).captures
+            select_into = "SELECT #{projections} INTO #{table_name} FROM #{source}"
           else
+            o.instance_variable_set :@as, nil
             super
           end
         end
 
-        def visit_TableDefinition(o)
-          quoted_name = "#{quote_table_name((o.temporary ? '#' : '') + o.name.to_s)} "
-
-          if o.as
-            if o.as.is_a?(ActiveRecord::Relation)
-              select = o.as.to_sql
-            elsif o.as.is_a?(String)
-              select = o.as
-            else
-              raise 'Only able to generate a table from a SELECT statement passed as a String or ActiveRecord::Relation'
-            end
-
-            create_sql = 'SELECT * INTO '
-            create_sql << quoted_name
-            create_sql << 'FROM ('
-            create_sql << select
-            create_sql << ') AS __sq'
-
+        def add_column_options!(sql, options)
+          column = options.fetch(:column) { return super }
+          if (column.type == :uuid || column.type == :uniqueidentifier) && options[:default] =~ /\(\)/
+            sql << " DEFAULT #{options.delete(:default)}"
           else
-            create_sql = "CREATE TABLE "
-            create_sql << quoted_name
-            create_sql << "(#{o.columns.map { |c| accept c }.join(', ')}) "
-            create_sql << "#{o.options}"
+            super
           end
-
-          create_sql
         end
+
       end
     end
   end

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

@@ -1,7 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Sqlserver
+    module SQLServer
       module SchemaStatements
+
         def native_database_types
           @native_database_types ||= initialize_native_database_types.freeze
         end
@@ -12,7 +13,7 @@ module ActiveRecord
 
         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
 
@@ -31,13 +32,12 @@ module ActiveRecord
             else
               name    = index[:index_name]
               unique  = index[:index_description] =~ /unique/
-              where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}")
               columns = index[:index_keys].split(',').map do |column|
                 column.strip!
                 column.gsub! '(-)', '' if column.ends_with?('(-)')
                 column
               end
-              indexes << IndexDefinition.new(table_name, name, unique, columns, nil, nil, where)
+              indexes << IndexDefinition.new(table_name, name, unique, columns)
             end
           end
         end
@@ -45,18 +45,14 @@ module ActiveRecord
         def columns(table_name, _name = nil)
           return [] if table_name.blank?
           column_definitions(table_name).map 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
+            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :default_function, :table_name
+            cast_type = lookup_cast_type(ci[:type])
+            new_column ci[:name], ci[:default_value], cast_type, ci[:type], ci[:null], sqlserver_options
           end
         end
 
-        # like postgres, sqlserver requires the ORDER BY columns in the select list for distinct queries, and
-        # requires that the ORDER BY include the distinct column. Unfortunately, sqlserver does not support
-        # DISTINCT ON () like Posgres, or FIRST_VALUE() like Oracle (at least before SQL Server 2012). Because
-        # of these facts, we don't actually add any extra columns for distinct, but instead have to create
-        # a subquery with ROW_NUMBER() and DENSE_RANK() in our monkey-patches to Arel.
-        def columns_for_distinct(columns, _orders) #:nodoc:
-          columns
+        def new_column(name, default, cast_type, sql_type = nil, null = true, sqlserver_options={})
+          SQLServerColumn.new name, default, cast_type, sql_type, null, sqlserver_options
         end
 
         def rename_table(table_name, new_name)
@@ -64,7 +60,7 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
+        def remove_column(table_name, column_name, _type = nil)
           raise ArgumentError.new('You must specify at least one column name.  Example: remove_column(:people, :first_name)') if column_name.is_a? Array
           remove_check_constraints(table_name, column_name)
           remove_default_constraint(table_name, column_name)
@@ -76,7 +72,6 @@ module ActiveRecord
           sql_commands = []
           indexes = []
           column_object = schema_cache.columns(table_name).find { |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)
             indexes = indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }
@@ -88,7 +83,6 @@ module ActiveRecord
           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_default_value(options[:default], column_object)} 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.map { |c| quote_column_name(c) }.join(', ')})"
@@ -106,13 +100,16 @@ module ActiveRecord
         def rename_column(table_name, column_name, new_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'"
+          identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{column_name}")
+          execute_procedure :sp_rename, identifier.quoted, new_column_name, 'COLUMN'
           rename_column_indexes(table_name, column_name, new_column_name)
           schema_cache.clear_table_cache!(table_name)
         end
 
         def rename_index(table_name, old_name, new_name)
-          execute "EXEC sp_rename N'#{table_name}.#{old_name}', N'#{new_name}', N'INDEX'"
+          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters" if new_name.length > allowed_index_name_length
+          identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{old_name}")
+          execute_procedure :sp_rename, identifier.quoted, new_name, 'INDEX'
         end
 
         def remove_index!(table_name, index_name)
@@ -135,6 +132,15 @@ module ActiveRecord
           end
         end
 
+        def columns_for_distinct(columns, orders)
+          order_columns = orders.reject(&:blank?).map{ |s|
+              s = s.to_sql unless s.is_a?(String)
+              s.gsub(/\s+(?:ASC|DESC)\b/i, '')
+               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
+            }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
+          [super, *order_columns].join(', ')
+        end
+
         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?
@@ -151,6 +157,7 @@ module ActiveRecord
           tables('VIEW')
         end
 
+
         protected
 
         # === SQLServer Specific ======================================== #
@@ -158,34 +165,39 @@ module ActiveRecord
         def initialize_native_database_types
           {
             primary_key: 'int NOT NULL IDENTITY(1,1) PRIMARY KEY',
-            string: { name: native_string_database_type, limit: 255  },
-            text: { name: native_text_database_type },
             integer: { name: 'int', limit: 4 },
-            float: { name: 'float', limit: 8 },
+            bigint: { name: 'bigint' },
+            boolean: { name: 'bit' },
             decimal: { name: 'decimal' },
+            money: { name: 'money' },
+            smallmoney: { name: 'smallmoney' },
+            float: { name: 'float' },
+            real: { name: 'real' },
+            date: { name: 'date' },
             datetime: { name: 'datetime' },
             timestamp: { name: 'datetime' },
-            time: { name: native_time_database_type },
-            date: { name: native_date_database_type },
-            binary: { name: native_binary_database_type },
-            boolean: { name: 'bit' },
-            uuid: { name: 'uniqueidentifier' },
-            # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
+            time: { name: 'time' },
             char: { name: 'char' },
+            varchar: { name: 'varchar', limit: 8000 },
             varchar_max: { name: 'varchar(max)' },
+            text_basic: { name: 'text' },
             nchar: { name: 'nchar' },
-            nvarchar: { name: 'nvarchar', limit: 255 },
-            nvarchar_max: { name: 'nvarchar(max)' },
+            string: { name: 'nvarchar', limit: 4000 },
+            text: { name: 'nvarchar(max)' },
             ntext: { name: 'ntext' },
+            binary_basic: { name: 'binary' },
+            varbinary: { name: 'varbinary', limit: 8000 },
+            binary: { name: 'varbinary(max)' },
+            uuid: { name: 'uniqueidentifier' },
             ss_timestamp: { name: 'timestamp' }
           }
         end
 
         def column_definitions(table_name)
-          db_name = Utils.unqualify_db_name(table_name)
-          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)
+          identifier  = SQLServer::Utils.extract_identifiers(table_name)
+          database    = "#{identifier.database_quoted}." if identifier.database_quoted
+          view_exists = schema_cache.view_exists?(table_name)
+          view_tblnm  = table_name_or_views_table_name(table_name) if view_exists
           sql = %{
             SELECT DISTINCT
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
@@ -194,10 +206,11 @@ module ActiveRecord
             columns.COLUMN_DEFAULT AS default_value,
             columns.NUMERIC_SCALE AS numeric_scale,
             columns.NUMERIC_PRECISION AS numeric_precision,
+            columns.DATETIME_PRECISION AS datetime_precision,
             columns.ordinal_position,
             CASE
               WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
-              ELSE COL_LENGTH('#{db_name_with_period}'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
+              ELSE COL_LENGTH('#{database}'+columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
             END AS [length],
             CASE
               WHEN columns.IS_NULLABLE = 'YES' THEN 1
@@ -208,63 +221,80 @@ module ActiveRecord
               ELSE NULL
             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
+            FROM #{database}INFORMATION_SCHEMA.COLUMNS columns
+            LEFT OUTER JOIN #{database}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
+            LEFT OUTER JOIN #{database}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
+            INNER JOIN #{identifier.database_quoted}.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
+            INNER JOIN #{identifier.database_quoted}.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
+            INNER JOIN #{identifier.database_quoted}.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'}
+              AND columns.TABLE_SCHEMA = #{identifier.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 = do_exec_query(sql, 'SCHEMA', binds)
+          binds = [[info_schema_table_name_column, identifier.object]]
+          binds << [info_schema_table_schema_column, identifier.schema] unless identifier.schema.blank?
+          results = sp_executesql(sql, 'SCHEMA', binds)
           results.map do |ci|
             ci = ci.symbolize_keys
+            ci[:_type] = ci[:type]
+            ci[:table_name] = view_tblnm || table_name
             ci[:type] = case ci[:type]
                         when /^bit|image|text|ntext|datetime$/
                           ci[:type]
+                        when /^time$/i
+                          "#{ci[:type]}(#{ci[:datetime_precision]})"
                         when /^numeric|decimal$/i
                           "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
                         when /^float|real$/i
-                          "#{ci[:type]}(#{ci[:numeric_precision]})"
-                        when /^char|nchar|varchar|nvarchar|varbinary|bigint|int|smallint$/
+                          "#{ci[:type]}"
+                        when /^char|nchar|varchar|nvarchar|binary|varbinary|bigint|int|smallint$/
                           ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
                         else
                           ci[:type]
                         end
-            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] = select_value col_default_sql, 'SCHEMA'
+            ci[:default_value],
+            ci[:default_function] = begin
+              default = ci[:default_value]
+              if default.nil? && view_exists
+                default = select_value "
+                  SELECT c.COLUMN_DEFAULT
+                  FROM #{database}INFORMATION_SCHEMA.COLUMNS c
+                  WHERE c.TABLE_NAME = '#{view_tblnm}'
+                  AND c.COLUMN_NAME = '#{views_real_column_name(table_name, ci[:name])}'".squish, 'SCHEMA'
+              end
+              case default
+              when nil
+                [nil, nil]
+              when /\A\((\w+\(\))\)\Z/
+                default_function = Regexp.last_match[1]
+                [nil, default_function]
+              when /\A\(N'(.*)'\)\Z/m
+                string_literal = SQLServer::Utils.unquote_string(Regexp.last_match[1])
+                [string_literal, nil]
+              else
+                type = case ci[:type]
+                       when /smallint|int|bigint/ then ci[:_type]
+                       else ci[:type]
+                       end
+                value = default.match(/\A\((.*)\)\Z/m)[1]
+                value = select_value "SELECT CAST(#{value} AS #{type}) AS value", 'SCHEMA'
+                [value, nil]
+              end
             end
-            ci[:default_value] = case ci[:default_value]
-                                 when nil, '(null)', '(NULL)'
-                                   nil
-                                 when /\A\((\w+\(\))\)\Z/
-                                   ci[:default_function] = Regexp.last_match[1]
-                                   nil
-                                 else
-                                   match_data = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/m)
-                                   match_data ? match_data[1].gsub("''", "'") : nil
-                                 end
             ci[:null] = ci[:is_nullable].to_i == 1
             ci.delete(:is_nullable)
             ci[:is_primary] = ci[:is_primary].to_i == 1
@@ -273,6 +303,14 @@ module ActiveRecord
           end
         end
 
+        def info_schema_table_name_column
+          @info_schema_table_name_column ||= new_column 'table_name', nil, lookup_cast_type('nvarchar(128)'), 'nvarchar(128)', true
+        end
+
+        def info_schema_table_schema_column
+          @info_schema_table_schema_column ||= new_column 'table_schema', nil, lookup_cast_type('nvarchar(128)'), 'nvarchar(128)', true
+        end
+
         def remove_check_constraints(table_name, 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|
@@ -298,13 +336,14 @@ module ActiveRecord
         # === SQLServer Specific (Misc Helpers) ========================= #
 
         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
+          tn = if sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)(\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
             Regexp.last_match[3] || Regexp.last_match[4]
           elsif sql =~ /FROM\s+([^\(\s]+)\s*/i
             Regexp.last_match[1]
           else
             nil
           end
+          SQLServer::Utils.extract_identifiers(tn).object
         end
 
         def default_constraint_name(table_name, column_name)
@@ -330,25 +369,24 @@ module ActiveRecord
         end
 
         def view_information(table_name)
-          table_name = Utils.unqualify_table_name(table_name)
-          view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'", 'SCHEMA'
+          identifier = SQLServer::Utils.extract_identifiers(table_name)
+          view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{identifier.object}'", '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
+                select_values("EXEC sp_helptext #{identifier.object_quoted}", 'SCHEMA').join
+              rescue
+                warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                nil
+              end
             end
           end
           view_info
         end
 
         def table_name_or_views_table_name(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
+          schema_cache.view_exists?(table_name) ? view_table_name(table_name) : table_name
         end
 
         def views_real_column_name(table_name, column_name)
@@ -373,51 +411,17 @@ module ActiveRecord
           !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
 
-        def strip_ident_from_update(sql)
-          # We can't update Identiy columns in sqlserver.  So, strip out the id from the update.
-          # There has to be a better way to handle this, but this'll do for now.
-          table_name = get_table_name(sql)
-          id_column = identity_column(table_name)
-
-          if id_column
-            regex_col_name = Regexp.quote(quote_column_name(id_column.name))
-            if sql =~ /, #{regex_col_name} = @?[0-9]*/
-              sql = sql.gsub(/, #{regex_col_name} = @?[0-9]*/, '')
-            elsif sql =~ /\s#{regex_col_name} = @?[0-9]*,/
-              sql = sql.gsub(/\s#{regex_col_name} = @?[0-9]*,/, '')
-            end
-          end
-          sql
-        end
-
-        def update_sql?(sql)
-          !(sql =~ /^\s*(UPDATE|EXEC sp_executesql N'UPDATE)/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)
-          yield
-        ensure
-          set_identity_insert(table_name, false)
-        end
-
-        def set_identity_insert(table_name, enable = true)
-          sql = "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
-          do_execute sql, 'SCHEMA'
-        rescue Exception
-          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
-        end
-
         def identity_column(table_name)
           schema_cache.columns(table_name).find(&:is_identity?)
         end
 
+
         private
 
         def create_table_definition(name, temporary, options, as = nil)
-          TableDefinition.new native_database_types, name, temporary, options, as
+          SQLServer::TableDefinition.new native_database_types, name, temporary, options, as
         end
+
       end
     end
   end