activerecord-jdbcsqlserver-adapter 50.1.0 → 51.0.0

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

@@ -1,3 +1,5 @@
+require 'pry'
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
@@ -90,18 +92,6 @@ module ActiveRecord
           @connection.configure_connection
         end
 
-        # @Overwrite
-        # Had some special logic and skipped using gem's internal query methods
-        def select_rows(sql, name = nil, binds = [])
-
-          # In some cases the limit is converted to a `TOP(1)` but the bind parameter is still in the array
-          if !binds.empty? && sql.include?('TOP(1)')
-            binds = binds.delete_if {|b| b.name == 'LIMIT' }
-          end
-
-          exec_query(sql, name, binds).rows
-        end
-
         # Have to reset this because the default arjdbc functionality is to return false unless a level is passed in
         def supports_transaction_isolation?
           true

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

@@ -16,6 +16,20 @@ module ActiveRecord
           end
         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[:is_identity] == true
+            sql << " IDENTITY(1,1)"
+          end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          sql
+        end
+
         def action_sql(action, dependency)
           case dependency
           when :restrict
@@ -28,6 +42,14 @@ module ActiveRecord
           end
         end
 
+        def options_include_default?(options)
+          super || options_primary_key_with_nil_default?(options)
+        end
+
+        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

@@ -3,13 +3,34 @@ module ActiveRecord
     module SQLServer
       module SchemaDumper
 
+        SQLSEVER_NO_LIMIT_TYPES = [
+          'text',
+          'ntext',
+          'varchar(max)',
+          'nvarchar(max)',
+          'varbinary(max)'
+        ].freeze
+
         private
 
+        def explicit_primary_key_default?(column)
+          column.is_primary? && !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 != collation
         end
 
+        def default_primary_key?(column)
+          super && column.is_primary? && column.is_identity?
+        end
+
       end
     end
   end

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

@@ -7,35 +7,6 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def tables(name = nil)
-          ActiveSupport::Deprecation.warn 'Passing arguments to #tables is deprecated without replacement.' if name
-          tables_sql('BASE TABLE')
-        end
-
-        def table_exists?(table_name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            #table_exists? currently checks both tables and views.
-            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-            Use #data_source_exists? instead.
-          MSG
-          data_source_exists?(table_name)
-        end
-
-        def data_source_exists?(table_name)
-          return false if table_name.blank?
-          unquoted_table_name = SQLServer::Utils.extract_identifiers(table_name).object
-          super(unquoted_table_name)
-        end
-
-        def views
-          tables_sql('VIEW')
-        end
-
-        def view_exists?(table_name)
-          identifier = SQLServer::Utils.extract_identifiers(table_name)
-          super(identifier.object)
-        end
-
         def create_table(table_name, comment: nil, **options)
           res = super
           clear_cache!
@@ -43,7 +14,18 @@ module ActiveRecord
         end
 
         def drop_table(table_name, options = {})
-          if options[:if_exists] && @version_year != 2016
+          # 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']
+              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)}"
           else
             super
@@ -103,10 +85,36 @@ module ActiveRecord
         end
 
         def primary_keys(table_name)
-          primaries = schema_cache.columns(table_name).select(&:is_primary?).map(&:name)
+          primaries = primary_keys_select(table_name)
           primaries.present? ? primaries : identity_columns(table_name).map(&:name)
         end
 
+        def primary_keys_select(table_name)
+          identifier = database_prefix_identifier(table_name)
+          database = identifier.fully_qualified_database_quoted
+          sql = %{
+            SELECT 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
+              AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+              AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
+              AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
+              AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            WHERE KCU.TABLE_NAME = #{prepared_statements ? COLUMN_DEFINITION_BIND_STRING_0 : quote(identifier.object)}
+            AND KCU.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? COLUMN_DEFINITION_BIND_STRING_1 : quote(identifier.schema))}
+            AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
+            ORDER BY KCU.ORDINAL_POSITION ASC
+          }.gsub(/[[:space:]]/, ' ')
+          binds = []
+          if prepared_statements
+            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?
+          end
+          sp_executesql(sql, 'SCHEMA', binds).map { |r| r['name'] }
+        end
+
         def rename_table(table_name, new_name)
           do_execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
           rename_table_indexes(table_name, new_name)
@@ -130,9 +138,11 @@ 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, options[:limit], options[:precision], options[:scale])}"
-          sql_commands[-1] << ' NOT NULL' if !options[:null].nil? && options[:null] == false
-          if options_include_default?(options)
+          sql_commands << "ALTER TABLE #{quote_table_name(table_name)} 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
+          if options.key?(:default) && default_constraint_name(table_name, column_name).present?
+            change_column_default(table_name, column_name, options[:default])
+          elsif 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_expression(options[:default], column_object)} FOR #{quote_column_name(column_name)}"
           end
           # Add any removed indexes back
@@ -140,6 +150,7 @@ module ActiveRecord
             sql_commands << "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index.columns.map { |c| quote_column_name(c) }.join(', ')})"
           end
           sql_commands.each { |c| do_execute(c) }
+          clear_cache!
         end
 
         def change_column_default(table_name, column_name, default_or_changes)
@@ -194,7 +205,7 @@ module ActiveRecord
           end
         end
 
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
           type_limitable = %w(string integer float char nchar varchar nvarchar).include?(type.to_s)
           limit = nil unless type_limitable
           case type.to_s
@@ -240,19 +251,40 @@ module ActiveRecord
           if !allow_null.nil? && allow_null == false && !default.nil?
             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, column.limit, column.precision, column.scale}"
+          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
           do_execute sql
         end
 
+        private
 
-        protected
+        def data_source_sql(name = nil, type: nil)
+          scope = quoted_scope name, type: type
+          table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
+          sql = "SELECT #{table_name}"
+          sql << ' FROM INFORMATION_SCHEMA.TABLES'
+          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
+
+        def quoted_scope(name = nil, type: nil)
+          identifier = SQLServer::Utils.extract_identifiers(name)
+          {}.tap do |scope|
+            scope[:schema] = identifier.schema || 'dbo'
+            scope[:name] = identifier.object if identifier.object
+            scope[:type] = type if type
+          end
+        end
 
         # === SQLServer Specific ======================================== #
 
         def initialize_native_database_types
           {
-            primary_key: 'int NOT NULL IDENTITY(1,1) PRIMARY KEY',
+            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' },
@@ -286,21 +318,11 @@ module ActiveRecord
           }
         end
 
-        def tables_sql(type)
-          tn  = lowercase_schema_reflection_sql 'TABLE_NAME'
-          sql = "SELECT #{tn} FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = '#{type}' ORDER BY TABLE_NAME"
-          select_values sql, 'SCHEMA'
-        end
-
         COLUMN_DEFINITION_BIND_STRING_0 = defined?(JRUBY_VERSION) ? '?' : '@0'
         COLUMN_DEFINITION_BIND_STRING_1 = defined?(JRUBY_VERSION) ? '?' : '@1'
 
         def column_definitions(table_name)
-          identifier = if database_prefix_remote_server?
-            SQLServer::Utils.extract_identifiers("#{database_prefix}#{table_name}")
-          else
-            SQLServer::Utils.extract_identifiers(table_name)
-          end
+          identifier  = database_prefix_identifier(table_name)
           database    = identifier.fully_qualified_database_quoted
           view_exists = view_exists?(table_name)
           view_tblnm  = view_table_name(table_name) if view_exists
@@ -482,7 +504,7 @@ module ActiveRecord
           @view_information ||= {}
           @view_information[table_name] ||= begin
             identifier = SQLServer::Utils.extract_identifiers(table_name)
-            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{identifier.object}'", 'SCHEMA'
+            view_info = select_one "SELECT * FROM INFORMATION_SCHEMA.VIEWS 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
@@ -505,8 +527,6 @@ module ActiveRecord
           match_data ? match_data[1] : column_name
         end
 
-        private
-
         def create_table_definition(*args)
           SQLServer::TableDefinition.new(*args)
         end

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

@@ -5,10 +5,13 @@ module ActiveRecord
       module ColumnMethods
 
         def primary_key(name, type = :primary_key, **options)
-          return super unless type == :uuid
-          options[:default] = options.fetch(:default, 'NEWID()')
-          options[:primary_key] = true
-          column name, type, options
+          if [:integer, :bigint].include?(type)
+            options[:is_identity] = true unless options.key?(:default)
+          elsif type == :uuid
+            options[:default] = options.fetch(:default, 'NEWID()')
+            options[:primary_key] = true
+          end
+          super
         end
 
         def primary_key_nonclustered(*args, **options)
@@ -98,9 +101,14 @@ module ActiveRecord
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
-        def new_column_definition(name, type, options)
-          type = :datetime2 if type == :datetime && options[:precision]
-          super name, type, options
+        def new_column_definition(name, type, **options)
+          case type
+          when :datetime
+            type = :datetime2 if options[:precision]
+          when :primary_key
+            options[:is_identity] = true
+          end
+          super
         end
       end
 

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

@@ -4,10 +4,6 @@ module ActiveRecord
       module Type
         class BigInteger < Integer
 
-          def type
-            :bigint
-          end
-
           def sqlserver_type
             'bigint'.freeze
           end

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

@@ -23,6 +23,11 @@ module ActiveRecord
             @value.inspect
           end
 
+          def eql?(other)
+            self.class == other.class && self.value == other.value
+          end
+          alias :== :eql?
+
         end
       end
     end

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

@@ -51,7 +51,9 @@ module ActiveRecord
           private
 
           def fast_string_to_time(string)
-            fast_string_to_time_zone.strptime(string, fast_string_to_time_format).time
+            time = ActiveSupport::TimeZone['UTC'].strptime(string, fast_string_to_time_format)
+            new_time(time.year, time.month, time.day, time.hour,
+                     time.min, time.sec, Rational(time.nsec, 1_000))
           rescue ArgumentError
             super
           end
@@ -59,11 +61,6 @@ module ActiveRecord
           def fast_string_to_time_format
             "#{::Time::DATE_FORMATS[:_sqlserver_datetime]}.%N".freeze
           end
-
-          def fast_string_to_time_zone
-            ::Time.zone || ActiveSupport::TimeZone['UTC']
-          end
-
         end
       end
     end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -3,6 +3,7 @@ require 'active_record'
 require 'arel_sqlserver'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
+require 'active_record/connection_adapters/sqlserver/core_ext/calculations'
 require 'active_record/connection_adapters/sqlserver/core_ext/explain' unless defined? JRUBY_VERSION
 require 'active_record/connection_adapters/sqlserver/core_ext/explain_subscriber'
 require 'active_record/connection_adapters/sqlserver/core_ext/attribute_methods'
@@ -56,11 +57,13 @@ module ActiveRecord
 
       cattr_accessor :cs_equality_operator, instance_accessor: false
       cattr_accessor :use_output_inserted, instance_accessor: false
+      cattr_accessor :exclude_output_inserted_table_names, instance_accessor: false
       cattr_accessor :showplan_option, instance_accessor: false
       cattr_accessor :lowercase_schema_reflection
 
       self.cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
       self.use_output_inserted = true
+      self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
       def initialize(connection, logger = nil, config = {})
         super(connection, logger, config)
@@ -85,14 +88,6 @@ module ActiveRecord
         SQLServer::SchemaCreation.new self
       end
 
-      def supports_migrations?
-        true
-      end
-
-      def supports_primary_key?
-        true
-      end
-
       def supports_ddl_transactions?
         true
       end
@@ -159,10 +154,10 @@ module ActiveRecord
 
       def disable_referential_integrity
         tables = tables_with_referential_integrity
-        tables.each { |t| do_execute "ALTER TABLE #{t} NOCHECK CONSTRAINT ALL" }
+        tables.each { |t| do_execute "ALTER TABLE #{quote_table_name(t)} NOCHECK CONSTRAINT ALL" }
         yield
       ensure
-        tables.each { |t| do_execute "ALTER TABLE #{t} CHECK CONSTRAINT ALL" }
+        tables.each { |t| do_execute "ALTER TABLE #{quote_table_name(t)} CHECK CONSTRAINT ALL" }
       end
 
       # === Abstract Adapter (Connection Management) ================== #
@@ -242,6 +237,14 @@ module ActiveRecord
         @connection_options[:database_prefix]
       end
 
+      def database_prefix_identifier(name)
+        if database_prefix_remote_server?
+          SQLServer::Utils.extract_identifiers("#{database_prefix}#{name}")
+        else
+          SQLServer::Utils.extract_identifiers(name)
+        end
+      end
+
       def version
         self.class::VERSION
       end
@@ -339,6 +342,20 @@ module ActiveRecord
           NoDatabaseError.new(message)
         when /data would be truncated/
           ValueTooLong.new(message)
+        when /Column '(.*)' is not the same data type as referencing column '(.*)' in foreign key/
+          pk_id, fk_id = SQLServer::Utils.extract_identifiers($1), SQLServer::Utils.extract_identifiers($2)
+          MismatchedForeignKey.new(
+            self,
+            message: message,
+            table: fk_id.schema,
+            foreign_key: fk_id.object,
+            target_table: pk_id.schema,
+            primary_key: pk_id.object
+          )
+        when /Cannot insert the value NULL into column.*does not allow nulls/
+          NotNullViolation.new(message)
+        when /Arithmetic overflow error/
+          RangeError.new(message)
         else
           super
         end