activerecord-sqlserver-adapter 6.0.0.rc1 → 6.1.0.0.rc1

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

@@ -4,21 +4,20 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Quoting
-
-        QUOTED_TRUE  = '1'.freeze
-        QUOTED_FALSE = '0'.freeze
-        QUOTED_STRING_PREFIX = 'N'.freeze
+        QUOTED_TRUE  = "1".freeze
+        QUOTED_FALSE = "0".freeze
+        QUOTED_STRING_PREFIX = "N".freeze
 
         def fetch_type_metadata(sql_type, sqlserver_options = {})
           cast_type = lookup_cast_type(sql_type)
-          SQLServer::SqlTypeMetadata.new(
+          simple_type = SqlTypeMetadata.new(
             sql_type: sql_type,
             type: cast_type.type,
             limit: cast_type.limit,
             precision: cast_type.precision,
-            scale: cast_type.scale,
-            sqlserver_options: sqlserver_options
+            scale: cast_type.scale
           )
+          SQLServer::TypeMetadata.new(simple_type, sqlserver_options: sqlserver_options)
         end
 
         def quote_string(s)
@@ -63,10 +62,12 @@ module ActiveRecord
         end
 
         def quoted_date(value)
-          if value.acts_like?(:date)
-            Type::Date.new.serialize(value)
-          else value.acts_like?(:time)
+          if value.acts_like?(:time)
             Type::DateTime.new.serialize(value)
+          elsif value.acts_like?(:date)
+            Type::Date.new.serialize(value)
+          else
+            value
           end
         end
 
@@ -82,8 +83,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+AS\s+(?:\w+|\[\w+\]))?
           )
@@ -95,8 +96,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+ASC|\s+DESC)?
             (?:\s+NULLS\s+(?:FIRST|LAST))?
@@ -130,7 +131,6 @@ module ActiveRecord
             super
           end
         end
-
       end
     end
   end

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

@@ -3,10 +3,13 @@
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      class SchemaCreation < AbstractAdapter::SchemaCreation
-
+      class SchemaCreation < SchemaCreation
         private
 
+        def supports_index_using?
+          false
+        end
+
         def visit_TableDefinition(o)
           if_not_exists = o.if_not_exists
 
@@ -30,11 +33,28 @@ module ActiveRecord
           sql
         end
 
+        def visit_CreateIndexDefinition(o)
+          if_not_exists = o.if_not_exists
+
+          o.if_not_exists = false
+
+          sql = super
+
+          if if_not_exists
+            sql = "IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = '#{o.index.name}') #{sql}"
+          end
+
+          sql
+        end
+
         def add_column_options!(sql, options)
           sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
           if options[:null] == false
             sql << " NOT NULL"
           end
+          if options[:collation].present?
+            sql << " COLLATE #{options[:collation]}"
+          end
           if options[:is_identity] == true
             sql << " IDENTITY(1,1)"
           end
@@ -63,7 +83,6 @@ module ActiveRecord
         def options_primary_key_with_nil_default?(options)
           options[:primary_key] && options.include?(:default) && options[:default].nil?
         end
-
       end
     end
   end

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

@@ -4,35 +4,41 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       class SchemaDumper < ConnectionAdapters::SchemaDumper
-
         SQLSEVER_NO_LIMIT_TYPES = [
-          'text',
-          'ntext',
-          'varchar(max)',
-          'nvarchar(max)',
-          'varbinary(max)'
+          "text",
+          "ntext",
+          "varchar(max)",
+          "nvarchar(max)",
+          "varbinary(max)"
         ].freeze
 
         private
 
         def explicit_primary_key_default?(column)
-          column.is_primary? && !column.is_identity?
+          column.type == :integer && !column.is_identity?
         end
 
         def schema_limit(column)
           return if SQLSEVER_NO_LIMIT_TYPES.include?(column.sql_type)
+
           super
         end
 
         def schema_collation(column)
           return unless column.collation
-          column.collation if column.collation != @connection.collation
+
+          # use inspect to ensure collation is dumped as string. Without this it's dumped as
+          # a constant ('collation: SQL_Latin1_General_CP1_CI_AS')
+          collation = column.collation.inspect
+          # use inspect to ensure string comparison
+          default_collation = @connection.collation.inspect
+
+          collation if collation != default_collation
         end
 
         def default_primary_key?(column)
-          super && column.is_primary? && column.is_identity?
+          super && column.is_identity?
         end
-
       end
     end
   end

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

@@ -4,7 +4,6 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module SchemaStatements
-
         def native_database_types
           @native_database_types ||= initialize_native_database_types.freeze
         end
@@ -19,16 +18,16 @@ module ActiveRecord
           # Mimic CASCADE option as best we can.
           if options[:force] == :cascade
             execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
-              fktable = fkdata['FKTABLE_NAME']
-              fkcolmn = fkdata['FKCOLUMN_NAME']
-              pktable = fkdata['PKTABLE_NAME']
-              pkcolmn = fkdata['PKCOLUMN_NAME']
-              remove_foreign_key fktable, name: fkdata['FK_NAME']
+              fktable = fkdata["FKTABLE_NAME"]
+              fkcolmn = fkdata["FKCOLUMN_NAME"]
+              pktable = fkdata["PKTABLE_NAME"]
+              pkcolmn = fkdata["PKCOLUMN_NAME"]
+              remove_foreign_key fktable, name: fkdata["FK_NAME"]
               do_execute "DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )"
             end
           end
           if options[:if_exists] && @version_year < 2016
-            execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}"
+            execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}", "SCHEMA"
           else
             super
           end
@@ -49,11 +48,11 @@ module ActiveRecord
               orders  = {}
               columns = []
 
-              index[:index_keys].split(',').each do |column|
+              index[:index_keys].split(",").each do |column|
                 column.strip!
 
-                if column.ends_with?('(-)')
-                  column.gsub! '(-)', ''
+                if column.end_with?("(-)")
+                  column.gsub! "(-)", ""
                   orders[column] = :desc
                 end
 
@@ -67,6 +66,7 @@ module ActiveRecord
 
         def columns(table_name)
           return [] if table_name.blank?
+
           column_definitions(table_name).map do |ci|
             sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :table_name
             sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
@@ -105,7 +105,7 @@ module ActiveRecord
           identifier = database_prefix_identifier(table_name)
           database = identifier.fully_qualified_database_quoted
           sql = %{
-            SELECT KCU.COLUMN_NAME AS [name]
+            SELECT #{lowercase_schema_reflection_sql('KCU.COLUMN_NAME')} AS [name]
             FROM #{database}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
             LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
               ON KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
@@ -117,12 +117,12 @@ module ActiveRecord
             AND KCU.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? '@1' : quote(identifier.schema))}
             AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
             ORDER BY KCU.ORDINAL_POSITION ASC
-          }.gsub(/[[:space:]]/, ' ')
+          }.gsub(/[[:space:]]/, " ")
           binds = []
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
-          binds << Relation::QueryAttribute.new('TABLE_NAME', identifier.object, nv128)
-          binds << Relation::QueryAttribute.new('TABLE_SCHEMA', identifier.schema, nv128) unless identifier.schema.blank?
-          sp_executesql(sql, 'SCHEMA', binds).map { |r| r['name'] }
+          binds << Relation::QueryAttribute.new("TABLE_NAME", identifier.object, nv128)
+          binds << Relation::QueryAttribute.new("TABLE_SCHEMA", identifier.schema, nv128) unless identifier.schema.blank?
+          sp_executesql(sql, "SCHEMA", binds).map { |r| r["name"] }
         end
 
         def rename_table(table_name, new_name)
@@ -130,8 +130,10 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
-          raise ArgumentError.new('You must specify at least one column name.  Example: remove_column(:people, :first_name)') if column_name.is_a? Array
+        def remove_column(table_name, column_name, type = nil, **options)
+          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_name.is_a? Array
+          return if options[:if_exists] == true && !column_exists?(table_name, column_name)
+
           remove_check_constraints(table_name, column_name)
           remove_default_constraint(table_name, column_name)
           remove_indexes(table_name, column_name)
@@ -144,10 +146,10 @@ module ActiveRecord
           column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
           without_constraints = options.key?(:default) || options.key?(:limit)
           default = if !options.key?(:default) && column_object
-            column_object.default
-          else
-            options[:default]
-          end
+                      column_object.default
+                    else
+                      options[:default]
+                    end
           if without_constraints || (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) }
@@ -155,7 +157,8 @@ module ActiveRecord
           end
           sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
           alter_command = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, limit: options[:limit], precision: options[:precision], scale: options[:scale])}"
-          alter_command += ' NOT NULL' if !options[:null].nil? && options[:null] == false
+          alter_command += " COLLATE #{options[:collation]}" if options[:collation].present?
+          alter_command += " NOT NULL" if !options[:null].nil? && options[:null] == false
           sql_commands << alter_command
           if without_constraints
             default = quote_default_expression(default, column_object || column_for(table_name, column_name))
@@ -173,6 +176,7 @@ module ActiveRecord
           clear_cache!
           column = column_for(table_name, column_name)
           return unless column
+
           remove_default_constraint(table_name, column_name)
           default = extract_new_default_value(default_or_changes)
           do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(default, column)} FOR #{quote_column_name(column_name)}"
@@ -182,15 +186,16 @@ module ActiveRecord
         def rename_column(table_name, column_name, new_column_name)
           clear_cache!
           identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{column_name}")
-          execute_procedure :sp_rename, identifier.quoted, new_column_name, 'COLUMN'
+          execute_procedure :sp_rename, identifier.quoted, new_column_name, "COLUMN"
           rename_column_indexes(table_name, column_name, new_column_name)
           clear_cache!
         end
 
         def rename_index(table_name, old_name, new_name)
-          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
+          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters" if new_name.length > index_name_length
+
           identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{old_name}")
-          execute_procedure :sp_rename, identifier.quoted, new_name, 'INDEX'
+          execute_procedure :sp_rename, identifier.quoted, new_name, "INDEX"
         end
 
         def remove_index!(table_name, index_name)
@@ -202,13 +207,13 @@ module ActiveRecord
           fk_info = execute_procedure :sp_fkeys, nil, identifier.schema, nil, identifier.object, identifier.schema
           fk_info.map do |row|
             from_table = identifier.object
-            to_table = row['PKTABLE_NAME']
+            to_table = row["PKTABLE_NAME"]
             options = {
-              name: row['FK_NAME'],
-              column: row['FKCOLUMN_NAME'],
-              primary_key: row['PKCOLUMN_NAME'],
-              on_update: extract_foreign_key_action('update', row['FK_NAME']),
-              on_delete: extract_foreign_key_action('delete', row['FK_NAME'])
+              name: row["FK_NAME"],
+              column: row["FKCOLUMN_NAME"],
+              primary_key: row["PKCOLUMN_NAME"],
+              on_update: extract_foreign_key_action("update", row["FK_NAME"]),
+              on_delete: extract_foreign_key_action("delete", row["FK_NAME"])
             }
             ForeignKeyDefinition.new from_table, to_table, options
           end
@@ -216,8 +221,8 @@ module ActiveRecord
 
         def extract_foreign_key_action(action, fk_name)
           case select_value("SELECT #{action}_referential_action_desc FROM sys.foreign_keys WHERE name = '#{fk_name}'")
-          when 'CASCADE' then :cascade
-          when 'SET_NULL' then :nullify
+          when "CASCADE" then :cascade
+          when "SET_NULL" then :nullify
           end
         end
 
@@ -225,15 +230,15 @@ module ActiveRecord
           type_limitable = %w(string integer float char nchar varchar nvarchar).include?(type.to_s)
           limit = nil unless type_limitable
           case type.to_s
-          when 'integer'
+          when "integer"
             case limit
-            when 1          then  'tinyint'
-            when 2          then  'smallint'
-            when 3..4, nil  then  'integer'
-            when 5..8       then  'bigint'
+            when 1          then  "tinyint"
+            when 2          then  "smallint"
+            when 3..4, nil  then  "integer"
+            when 5..8       then  "bigint"
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
             end
-          when 'datetime2'
+          when "datetime2"
             column_type_sql = super
             if precision
               if (0..7) === precision
@@ -249,11 +254,11 @@ module ActiveRecord
         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}" }
+          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}" }
 
           (order_columns << super).join(", ")
         end
@@ -270,7 +275,7 @@ module ActiveRecord
             do_execute("UPDATE #{table_id} SET #{column_id}=#{quote(default)} WHERE #{column_id} IS NULL")
           end
           sql = "ALTER TABLE #{table_id} ALTER COLUMN #{column_id} #{type_to_sql column.type, limit: column.limit, precision: column.precision, scale: column.scale}"
-          sql += ' NOT NULL' if !allow_null.nil? && allow_null == false
+          sql += " NOT NULL" if !allow_null.nil? && allow_null == false
           do_execute sql
         end
 
@@ -278,14 +283,33 @@ module ActiveRecord
           SQLServer::SchemaDumper.create(self, options)
         end
 
+        def create_schema(schema_name, authorization = nil)
+          sql = "CREATE SCHEMA [#{schema_name}]"
+          sql += " AUTHORIZATION [#{authorization}]" if authorization
+
+          execute sql
+        end
+
+        def change_table_schema(schema_name, table_name)
+          execute "ALTER SCHEMA [#{schema_name}] TRANSFER [#{table_name}]"
+        end
+
+        def drop_schema(schema_name)
+          execute "DROP SCHEMA [#{schema_name}]"
+        end
+
         private
 
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope name, type: type
+
           table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
+          database = scope[:database].present? ? "#{scope[:database]}." : ""
+          table_catalog = scope[:database].present? ? quote(scope[:database]) : "DB_NAME()"
+
           sql = "SELECT #{table_name}"
-          sql += ' FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)'
-          sql += ' WHERE TABLE_CATALOG = DB_NAME()'
+          sql += " FROM #{database}INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
+          sql += " WHERE TABLE_CATALOG = #{table_catalog}"
           sql += " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
           sql += " AND TABLE_NAME = #{quote(scope[:name])}" if scope[:name]
           sql += " AND TABLE_TYPE = #{quote(scope[:type])}" if scope[:type]
@@ -296,7 +320,8 @@ module ActiveRecord
         def quoted_scope(name = nil, type: nil)
           identifier = SQLServer::Utils.extract_identifiers(name)
           {}.tap do |scope|
-            scope[:schema] = identifier.schema || 'dbo'
+            scope[:database] = identifier.database if identifier.database
+            scope[:schema] = identifier.schema || "dbo"
             scope[:name] = identifier.object if identifier.object
             scope[:type] = type if type
           end
@@ -306,37 +331,37 @@ module ActiveRecord
 
         def initialize_native_database_types
           {
-            primary_key: 'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
-            primary_key_nonclustered: 'int NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED',
-            integer: { name: 'int', limit: 4 },
-            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' },
-            datetime2: { name: 'datetime2' },
-            datetimeoffset: { name: 'datetimeoffset' },
-            smalldatetime: { name: 'smalldatetime' },
-            timestamp: { name: 'datetime' },
-            time: { name: 'time' },
-            char: { name: 'char' },
-            varchar: { name: 'varchar', limit: 8000 },
-            varchar_max: { name: 'varchar(max)' },
-            text_basic: { name: 'text' },
-            nchar: { name: 'nchar' },
-            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' },
-            json: { name: 'nvarchar(max)' }
+            primary_key: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY",
+            primary_key_nonclustered: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED",
+            integer: { name: "int", limit: 4 },
+            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" },
+            datetime2: { name: "datetime2" },
+            datetimeoffset: { name: "datetimeoffset" },
+            smalldatetime: { name: "smalldatetime" },
+            timestamp: { name: "datetime" },
+            time: { name: "time" },
+            char: { name: "char" },
+            varchar: { name: "varchar", limit: 8000 },
+            varchar_max: { name: "varchar(max)" },
+            text_basic: { name: "text" },
+            nchar: { name: "nchar" },
+            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" },
+            json: { name: "nvarchar(max)" }
           }
         end
 
@@ -350,9 +375,9 @@ module ActiveRecord
 
           binds = []
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
-          binds << Relation::QueryAttribute.new('TABLE_NAME', identifier.object, nv128)
-          binds << Relation::QueryAttribute.new('TABLE_SCHEMA', identifier.schema, nv128) unless identifier.schema.blank?
-          results = sp_executesql(sql, 'SCHEMA', binds)
+          binds << Relation::QueryAttribute.new("TABLE_NAME", identifier.object, nv128)
+          binds << Relation::QueryAttribute.new("TABLE_SCHEMA", identifier.schema, nv128) unless identifier.schema.blank?
+          results = sp_executesql(sql, "SCHEMA", binds)
           results.map do |ci|
             ci = ci.symbolize_keys
             ci[:_type] = ci[:type]
@@ -383,7 +408,7 @@ module ActiveRecord
                   WHERE
                     c.TABLE_NAME = '#{view_tblnm}'
                     AND c.COLUMN_NAME = '#{views_real_column_name(table_name, ci[:name])}'
-                }.squish, 'SCHEMA'
+                }.squish, "SCHEMA"
               end
               case default
               when nil
@@ -402,7 +427,7 @@ module ActiveRecord
                        else ci[:type]
                        end
                 value = default.match(/\A\((.*)\)\Z/m)[1]
-                value = select_value("SELECT CAST(#{value} AS #{type}) AS value", 'SCHEMA')
+                value = select_value("SELECT CAST(#{value} AS #{type}) AS value", "SCHEMA")
                 [value, nil]
               end
             end
@@ -415,11 +440,11 @@ module ActiveRecord
         end
 
         def column_definitions_sql(database, identifier)
-          object_name = prepared_statements ? '@0' : quote(identifier.object)
-          schema_name = if identifier.schema.blank? 
-                          'schema_name()' 
+          object_name = prepared_statements ? "@0" : quote(identifier.object)
+          schema_name = if identifier.schema.blank?
+                          "schema_name()"
                         else
-                          prepared_statements ? '@1' : quote(identifier.schema)
+                          prepared_statements ? "@1" : quote(identifier.schema)
                         end
 
           %{
@@ -469,6 +494,7 @@ module ActiveRecord
               AND c.default_object_id = d.object_id
             LEFT OUTER JOIN #{database}.sys.key_constraints k
               ON c.object_id = k.parent_object_id
+              AND k.type = 'PK'
             LEFT OUTER JOIN #{database}.sys.index_columns ic
               ON k.parent_object_id = ic.object_id
               AND k.unique_index_id = ic.index_id
@@ -478,11 +504,11 @@ module ActiveRecord
               AND s.name = #{schema_name}
             ORDER BY
               c.column_id
-          }.gsub(/[ \t\r\n]+/, ' ').strip
+          }.gsub(/[ \t\r\n]+/, " ").strip
         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 = 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
@@ -490,8 +516,8 @@ 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.
-          execute_procedure(:sp_helpconstraint, table_name, 'nomsg').flatten.select do |row|
-            row['constraint_type'] == "DEFAULT on column #{column_name}"
+          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']}"
           end
@@ -507,12 +533,12 @@ module ActiveRecord
 
         def get_table_name(sql)
           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
+                 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
 
@@ -528,22 +554,22 @@ module ActiveRecord
 
         def view_table_name(table_name)
           view_info = view_information(table_name)
-          view_info ? get_table_name(view_info['VIEW_DEFINITION']) : table_name
+          view_info ? get_table_name(view_info["VIEW_DEFINITION"]) : table_name
         end
 
         def view_information(table_name)
           @view_information ||= {}
           @view_information[table_name] ||= begin
             identifier = SQLServer::Utils.extract_identifiers(table_name)
-            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WITH (NOLOCK) WHERE TABLE_NAME = #{quote(identifier.object)}", 'SCHEMA'
+            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WITH (NOLOCK) WHERE TABLE_NAME = #{quote(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 #{identifier.object_quoted}", 'SCHEMA').join
-                rescue
-                  warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
-                  nil
+                  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
@@ -554,6 +580,7 @@ module ActiveRecord
         def views_real_column_name(table_name, column_name)
           view_definition = view_information(table_name)[:VIEW_DEFINITION]
           return column_name unless view_definition
+
           match_data = view_definition.match(/([\w-]*)\s+as\s+#{column_name}/im)
           match_data ? match_data[1] : column_name
         end
@@ -561,7 +588,6 @@ module ActiveRecord
         def create_table_definition(*args, **options)
           SQLServer::TableDefinition.new(self, *args, **options)
         end
-
       end
     end
   end