activerecord-sqlserver-adapter 5.2.1 → 6.0.0.rc1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
@@ -7,13 +9,13 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def create_table(table_name, comment: nil, **options)
+        def create_table(table_name, **options)
           res = super
           clear_cache!
           res
         end
 
-        def drop_table(table_name, options = {})
+        def drop_table(table_name, **options)
           # Mimic CASCADE option as best we can.
           if options[:force] == :cascade
             execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
@@ -66,14 +68,13 @@ 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
+            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :table_name
             sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
             new_column(
               ci[:name],
               ci[:default_value],
               sql_type_metadata,
               ci[:null],
-              ci[:table_name],
               ci[:default_function],
               ci[:collation],
               nil,
@@ -82,16 +83,16 @@ module ActiveRecord
           end
         end
 
-        def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+        def new_column(name, default, sql_type_metadata, null, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
           SQLServerColumn.new(
             name,
             default,
             sql_type_metadata,
-            null, table_name,
+            null,
             default_function,
-            collation,
-            comment,
-            sqlserver_options
+            collation: collation,
+            comment: comment,
+            **sqlserver_options
           )
         end
 
@@ -153,8 +154,9 @@ module ActiveRecord
             remove_indexes(table_name, column_name)
           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?
-          sql_commands << "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])}"
-          sql_commands.last << ' NOT NULL' if !options[:null].nil? && options[:null] == false
+          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
+          sql_commands << alter_command
           if without_constraints
             default = quote_default_expression(default, column_object || column_for(table_name, column_name))
             sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{default} FOR #{quote_column_name(column_name)}"
@@ -237,7 +239,7 @@ module ActiveRecord
               if (0..7) === precision
                 column_type_sql << "(#{precision})"
               else
-                raise(ActiveRecordError, "The dattime2 type has precision of #{precision}. The allowed range of precision is from 0 to 7")
+                raise(ActiveRecordError, "The datetime2 type has precision of #{precision}. The allowed range of precision is from 0 to 7")
               end
             end
             column_type_sql
@@ -268,7 +270,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
 
@@ -282,12 +284,12 @@ module ActiveRecord
           scope = quoted_scope name, type: type
           table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
           sql = "SELECT #{table_name}"
-          sql << ' FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)'
-          sql << ' WHERE TABLE_CATALOG = DB_NAME()'
-          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]
-          sql << " ORDER BY #{table_name}"
+          sql += ' FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)'
+          sql += ' WHERE TABLE_CATALOG = DB_NAME()'
+          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]
+          sql += " ORDER BY #{table_name}"
           sql
         end
 
@@ -343,55 +345,9 @@ module ActiveRecord
           database    = identifier.fully_qualified_database_quoted
           view_exists = view_exists?(table_name)
           view_tblnm  = view_table_name(table_name) if view_exists
-          sql = %{
-            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,
-            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.COLLATION_NAME AS [collation],
-            columns.ordinal_position,
-            CASE
-              WHEN columns.DATA_TYPE IN ('nchar','nvarchar','char','varchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
-              ELSE COL_LENGTH('#{database}.'+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 KCU.COLUMN_NAME IS NOT NULL AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY' THEN 1
-              ELSE NULL
-            END AS [is_primary],
-            c.is_identity AS [is_identity]
-            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.TABLE_SCHEMA = columns.TABLE_SCHEMA
-              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
-            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 #{database}.sys.schemas AS s
-              ON s.name = columns.TABLE_SCHEMA
-              AND s.schema_id = s.schema_id
-            INNER JOIN #{database}.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 #{database}.sys.columns AS c
-              ON o.object_id = c.object_id
-              AND c.name = columns.COLUMN_NAME
-            WHERE columns.TABLE_NAME = #{prepared_statements ? '@0' : quote(identifier.object)}
-              AND columns.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? '@1' : quote(identifier.schema))}
-            ORDER BY columns.ordinal_position
-          }.gsub(/[ \t\r\n]+/, ' ').strip
+
+          sql = column_definitions_sql(database, identifier)
+
           binds = []
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
           binds << Relation::QueryAttribute.new('TABLE_NAME', identifier.object, nv128)
@@ -458,6 +414,73 @@ module ActiveRecord
           end
         end
 
+        def column_definitions_sql(database, identifier)
+          object_name = prepared_statements ? '@0' : quote(identifier.object)
+          schema_name = if identifier.schema.blank? 
+                          'schema_name()' 
+                        else
+                          prepared_statements ? '@1' : quote(identifier.schema)
+                        end
+
+          %{
+            SELECT
+              #{lowercase_schema_reflection_sql('o.name')} AS [table_name],
+              #{lowercase_schema_reflection_sql('c.name')} AS [name],
+              t.name AS [type],
+              d.definition AS [default_value],
+              CASE
+                WHEN t.name IN ('decimal', 'bigint', 'int', 'money', 'numeric', 'smallint', 'smallmoney', 'tinyint')
+                THEN c.scale
+              END AS [numeric_scale],
+              CASE
+                WHEN t.name IN ('decimal', 'bigint', 'int', 'money', 'numeric', 'smallint', 'smallmoney', 'tinyint', 'real', 'float')
+                THEN c.precision
+              END AS [numeric_precision],
+              CASE
+                WHEN t.name IN ('date', 'datetime', 'datetime2', 'datetimeoffset', 'smalldatetime', 'time')
+                THEN c.scale
+              END AS [datetime_precision],
+              c.collation_name  AS [collation],
+              ROW_NUMBER() OVER (ORDER BY c.column_id) AS [ordinal_position],
+              CASE
+                WHEN t.name IN ('nchar', 'nvarchar') AND c.max_length > 0
+                THEN c.max_length / 2
+                ELSE c.max_length
+              END AS [length],
+              CASE c.is_nullable
+                WHEN 1
+                THEN 1
+              END AS [is_nullable],
+              CASE
+                WHEN ic.object_id IS NOT NULL
+                THEN 1
+              END AS [is_primary],
+              c.is_identity AS [is_identity]
+            FROM #{database}.sys.columns c
+            INNER JOIN #{database}.sys.objects o
+              ON c.object_id = o.object_id
+            INNER JOIN #{database}.sys.schemas s
+              ON o.schema_id = s.schema_id
+            INNER JOIN #{database}.sys.types t
+              ON c.system_type_id = t.system_type_id
+              AND c.user_type_id = t.user_type_id
+            LEFT OUTER JOIN #{database}.sys.default_constraints d
+              ON c.object_id = d.parent_object_id
+              AND c.default_object_id = d.object_id
+            LEFT OUTER JOIN #{database}.sys.key_constraints k
+              ON c.object_id = k.parent_object_id
+            LEFT OUTER JOIN #{database}.sys.index_columns ic
+              ON k.parent_object_id = ic.object_id
+              AND k.unique_index_id = ic.index_id
+              AND c.column_id = ic.column_id
+            WHERE
+              o.name = #{object_name}
+              AND s.name = #{schema_name}
+            ORDER BY
+              c.column_id
+          }.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.each do |constraint|
@@ -535,8 +558,8 @@ module ActiveRecord
           match_data ? match_data[1] : column_name
         end
 
-        def create_table_definition(*args)
-          SQLServer::TableDefinition.new(*args)
+        def create_table_definition(*args, **options)
+          SQLServer::TableDefinition.new(self, *args, **options)
         end
 
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/sqlserver/showplan/printer_table'
 require 'active_record/connection_adapters/sqlserver/showplan/printer_xml'
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
@@ -14,86 +16,86 @@ module ActiveRecord
           super
         end
 
-        def primary_key_nonclustered(*args, **options)
-          args.each { |name| column(name, :primary_key_nonclustered, options) }
+        def primary_key_nonclustered(*names, **options)
+          names.each { |name| column(name, :primary_key_nonclustered, **options) }
         end
 
-        def real(*args, **options)
-          args.each { |name| column(name, :real, options) }
+        def real(*names, **options)
+          names.each { |name| column(name, :real, **options) }
         end
 
-        def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
+        def money(*names, **options)
+          names.each { |name| column(name, :money, **options) }
         end
 
-        def smalldatetime(*args, **options)
-          args.each { |name| column(name, :smalldatetime, options) }
+        def smalldatetime(*names, **options)
+          names.each { |name| column(name, :smalldatetime, **options) }
         end
 
-        def datetime(*args, **options)
-          args.each do |name|
+        def datetime(*names, **options)
+          names.each do |name|
             if options[:precision]
-              datetime2(name, options)
+              datetime2(name, **options)
             else
-              column(name, :datetime, options)
+              column(name, :datetime, **options)
             end
           end
         end
 
-        def datetime2(*args, **options)
-          args.each { |name| column(name, :datetime2, options) }
+        def datetime2(*names, **options)
+          names.each { |name| column(name, :datetime2, **options) }
         end
 
-        def datetimeoffset(*args, **options)
-          args.each { |name| column(name, :datetimeoffset, options) }
+        def datetimeoffset(*names, **options)
+          names.each { |name| column(name, :datetimeoffset, **options) }
         end
 
-        def smallmoney(*args, **options)
-          args.each { |name| column(name, :smallmoney, options) }
+        def smallmoney(*names, **options)
+          names.each { |name| column(name, :smallmoney, **options) }
         end
 
-        def char(*args, **options)
-          args.each { |name| column(name, :char, options) }
+        def char(*names, **options)
+          names.each { |name| column(name, :char, **options) }
         end
 
-        def varchar(*args, **options)
-          args.each { |name| column(name, :varchar, options) }
+        def varchar(*names, **options)
+          names.each { |name| column(name, :varchar, **options) }
         end
 
-        def varchar_max(*args, **options)
-          args.each { |name| column(name, :varchar_max, options) }
+        def varchar_max(*names, **options)
+          names.each { |name| column(name, :varchar_max, **options) }
         end
 
-        def text_basic(*args, **options)
-          args.each { |name| column(name, :text_basic, options) }
+        def text_basic(*names, **options)
+          names.each { |name| column(name, :text_basic, **options) }
         end
 
-        def nchar(*args, **options)
-          args.each { |name| column(name, :nchar, options) }
+        def nchar(*names, **options)
+          names.each { |name| column(name, :nchar, **options) }
         end
 
-        def ntext(*args, **options)
-          args.each { |name| column(name, :ntext, options) }
+        def ntext(*names, **options)
+          names.each { |name| column(name, :ntext, **options) }
         end
 
-        def binary_basic(*args, **options)
-          args.each { |name| column(name, :binary_basic, options) }
+        def binary_basic(*names, **options)
+          names.each { |name| column(name, :binary_basic, **options) }
         end
 
-        def varbinary(*args, **options)
-          args.each { |name| column(name, :varbinary, options) }
+        def varbinary(*names, **options)
+          names.each { |name| column(name, :varbinary, **options) }
         end
 
-        def uuid(*args, **options)
-          args.each { |name| column(name, :uniqueidentifier, options) }
+        def uuid(*names, **options)
+          names.each { |name| column(name, :uniqueidentifier, **options) }
         end
 
-        def ss_timestamp(*args, **options)
-          args.each { |name| column(name, :ss_timestamp, options) }
+        def ss_timestamp(*names, **options)
+          names.each { |name| column(name, :ss_timestamp, **options) }
         end
 
-        def json(*args, **options)
-          args.each { |name| column(name, :text, options) }
+        def json(*names, **options)
+          names.each { |name| column(name, :text, **options) }
         end
 
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/abstract/transaction'
 
 module ActiveRecord
@@ -32,7 +34,7 @@ module ActiveRecord
 
       attr_reader :starting_isolation_level
 
-      def initialize(connection, options, *args)
+      def initialize(connection, options, **args)
         @connection = connection
         @starting_isolation_level = current_isolation_level if options[:isolation]
         super

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/type'
 # Behaviors
 require 'active_record/connection_adapters/sqlserver/type/data'

data/lib/active_record/connection_adapters/sqlserver/type/big_integer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
@@ -5,7 +7,7 @@ module ActiveRecord
         class BigInteger < Integer
 
           def sqlserver_type
-            'bigint'.freeze
+            "bigint"
           end
 
         end