activerecord-sqlserver-adapter 5.0.8 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 604d2ce1e9d4b4cef171d452d9b3efa245c81a1d
-  data.tar.gz: e2140ae987d61715d208c777e80c0cd906806aed
+  metadata.gz: 13700d5c59ccddfde7189f1bf0dfac4bbd276777
+  data.tar.gz: e9cafb310dfe9904c39dbf77ccc5bb86687f231a
 SHA512:
-  metadata.gz: b35a88380f1e42ef73aecd645b0967216e1537536c3df627a85597ecf851e0171106cfa056d6cfdc7c3b41d8be72104f55ce2b998e09053d6f464c7566bc7a9c
-  data.tar.gz: 3a82c5f018c28e58294766ad56777b023dda712fe0da2702b060351afa9935d8109c415605ae6a1efc08fc754554094c141894bbc61f783afa9d99586e15ab12
+  metadata.gz: 2cbb63f122e3ad2657532e7649c33728a0790f945043a12afdb078d171122970636a81dfa621485aa6a8abe7d30b9ab3892d2fef76fefd0a7ed6019fbda543dd
+  data.tar.gz: 220bc1f5a936151978885af18c38f7a25d7e684f0d7199c64d21d30922c4b33b8312e2a0db924f59d3040b0b147bbc6fa4dc564b5e1fbe6bb190daa522b322b4

data/BACKERS.md

@@ -0,0 +1,32 @@
+# Backers
+
+You can join in supporting TinyTDS and the Rails SQL Server Adapter development by [pledging on Patreon](https://www.patreon.com/metaskills)! Backers in the same pledge level appear in the order of pledge date.
+
+### $2000
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611218)
+
+
+### $500
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611209)
+
+
+### $250
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611199)
+
+
+### $100
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611196)
+
+
+### $50+
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611186)
+
+
+### $10+
+
+[It could be you!](https://www.patreon.com/bePatron?c=765225&rid=1611149)

data/CHANGELOG.md

@@ -1,120 +1,12 @@
-## v5.0.8
-
-* Memorized SQL Server Version to prevent a flood of SELECT @@version queries. Fixes #632
-
-## v5.0.7
-
-* Add `WITH NO_INFOMSGS` to `user_options` method. Fixes #580
-
-
-## v5.0.6
-
-#### Fixed
-
-* Performance w/inserts. Check binds & use schema cache for id inserts.
-  Fixes #572. Thanks @noelr.
-* Add smalldatetime type for migrations. Fixes #507
-
-#### Changed
-
-* Misc index enhancements or testing. Fixes #570
-  Enable `supports_index_sort_order?`, test `supports_partial_index?`, test how expression indexes work.
-
-#### Added
-
-* New `primary_key_nonclustered` type for easy In-Memory table creation.
-* Examples for an In-Memory table.
-
-```ruby
-create_table :in_memory_table, id: false,
-             options: 'WITH (MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA)' do |t|
-  t.primary_key_nonclustered :id
-  t.string :name
-  t.timestamps
-end
-```
-
-* Enable supports_json? Fixes #577.
-
-```ruby
-create_table :users do |t|
-  t.string :name, :email
-  t.json :data # Creates a nvarchar(max) column.
- end
-
-class Users < ActiveRecord::Base
-  attribute :data, ActiveRecord::Type::SQLServer::Json.new
-end
-
-User.create! name: 'Ken Collins', data: { 'admin' => true, 'foo' => 'bar' }
-
-admin = User.where("JSON_VALUE(data, '$.admin') = CAST(1 AS BIT)").first
-admin.data['foo'] # => "bar"
-```
-
-
-## v5.0.5
-
-#### Changed
-
-* Add TinyTDS as a runtime dependency.
-
-
-## v5.0.4
+## v5.1.0
 
 #### Fixed
 
-* Allow `datetimeoffset` to be used in migrations and represented in schema.
-* Using transactions and resetting isolation level correctly when `READ_COMMITTED_SNAPSHOT` is set to `ON` Fixes #520
-
-
-## v5.0.3
-
-#### Changed
-
-* Reduce view information reflection to per table vs. column. Fixes #552
-* The `user_options` parsing. Works for hash/array. Fixes #535
-* Pass the `:contained` option to TinyTDS. Fixes #527
-
-
-## v5.0.2
-
-#### Fixed
-
-* Filter table constraints with matching table schema to column. Fixes #478
-
-
-## v5.0.1
-
 #### Changed
 
-* Set `tds_version` fallback to `7.3`.
-
-#### Fixed
-
-* Support 2014, 2012 drop table statement.
-
-
-## v5.0.0
+* The `drop_table` with force cascade option now mimics in via pure SQL for us.
 
 #### Added
 
-* Support for `supports_datetime_with_precision`.
-* Support for `unprepared_statement` blocks on the connection.
-
-#### Changed
-
-* Major refactoring of all type objects. Especially time types.
-
-#### Deprecated
-
-* Support for a handful of standard Rails deprecations in 5-0-stable suite.
-
-#### Removed
-
-* ODBC connection mode. Not been maintained since Rails 4.0.
-* View table name detection in `with_identity_insert_enabled` method for fixtures. Perf hit.
-
-#### Fixed
+* Support MismatchedForeignKey exception.
 
-* Do not output column collation in schema when same as database.

data/RAILS5-TODO.md

@@ -2,4 +2,24 @@
 ## Rails v5.1
 
 * BIGINT PK support. https://github.com/rails/rails/pull/26266
-
+* Raise `ActiveRecord::NotNullViolation` when a record cannot be inserted
+  or updated because it would violate a not null constraint.
+* Raise `ActiveRecord::RangeError` when values that executed are out of range.
+* Allow passing extra flags to `db:structure:load` and `db:structure:dump`
+  Introduces `ActiveRecord::Tasks::DatabaseTasks.structure_(load|dump)_flags` to customize the
+  eventual commands run against the database, e.g. mysqldump/pg_dump.
+* Set `:time` as a timezone aware type and remove deprecation when
+  `config.active_record.time_zone_aware_types` is not explicitly set.
+* Remove deprecated support to passing a column to `#quote`.
+* `#tables` and `#table_exists?` return only tables and not views.
+  All the deprecations on those methods were removed.
+* Remove deprecated `original_exception` argument in `ActiveRecord::StatementInvalid#initialize`
+  and `ActiveRecord::StatementInvalid#original_exception`.
+* Remove deprecated tasks: `db:test:clone`, `db:test:clone_schema`, `db:test:clone_structure`.
+* Make `table_name=` reset current statement cache,
+  so queries are not run against the previous table name.
+* Deprecate using `#quoted_id` in quoting.
+* Deprecate `supports_migrations?` on connection adapters.
+* Dig moving `Column#sqlserver_options` to `sql_type_metadata` delegate.
+* Should we do like PG and add `options[:collation]` before `#add_column_options!`?
+* Translated exceptions: `SerializationFailure` and `RangeError`.

data/README.md

@@ -1,5 +1,3 @@
-[![Support via Gratipay](https://cdn.rawgit.com/gratipay/gratipay-badge/2.3.0/dist/gratipay.svg)](https://gratipay.com/metaskills/)
-
 # ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
 
 * [![TravisCI](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter.svg?branch=master)](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter) - TravisCI
@@ -9,6 +7,12 @@
 * [![Dependency Status](https://dependencyci.com/github/rails-sqlserver/activerecord-sqlserver-adapter/badge)](https://dependencyci.com/github/rails-sqlserver/activerecord-sqlserver-adapter) - Dependency Status
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
 
+## Supporting TinyTDS/Adapter
+
+Both TinyTDS and the Rails SQL Server Adapter are MIT-licensed open source projects. Its ongoing development is made possible thanks to the support by these awesome [backers](https://github.com/rails-sqlserver/tiny_tds/blob/master/BACKERS.md). If you'd like to join them, check out our [Patreon Campaign](https://www.patreon.com/metaskills).
+
+
+## About The Adapter
 
 The SQL Server adapter for ActiveRecord v5.0 using SQL Server 2012 or higher.
 
@@ -129,7 +133,7 @@ If you would like to contribute a feature or bugfix, thanks! To make sure your f
 Many many people have contributed. If you do not see your name here and it should be let us know. Also, many thanks go out to those that have pledged financial contributions.
 
 
-## Contributers
+## Contributors
 
 Up-to-date list of contributors: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter/contributors
 

data/VERSION

@@ -1 +1 @@
-5.0.8
+5.1.0

data/activerecord-sqlserver-adapter.gemspec

@@ -16,6 +16,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.add_dependency 'activerecord', '~> 5.0.0'
+  spec.add_dependency 'activerecord', '~> 5.1.0'
   spec.add_dependency 'tiny_tds'
 end

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

@@ -3,10 +3,6 @@ module ActiveRecord
     module SQLServer
       module DatabaseStatements
 
-        def select_rows(sql, name = nil, binds = [])
-          sp_executesql sql, name, binds, fetch: :rows
-        end
-
         def execute(sql, name = nil)
           if id_insert_table_name = query_requires_identity_insert?(sql)
             with_identity_insert_enabled(id_insert_table_name) { do_execute(sql, name) }
@@ -19,22 +15,22 @@ module ActiveRecord
           sp_executesql(sql, name, binds, prepare: prepare)
         end
 
-        def exec_insert(sql, name, binds, pk = nil, _sequence_name = nil)
+        def exec_insert(sql, name = nil, binds = [], pk = nil, _sequence_name = nil)
           if id_insert_table_name = exec_insert_requires_identity?(sql, pk, binds)
-            with_identity_insert_enabled(id_insert_table_name) { exec_query(sql, name, binds) }
+            with_identity_insert_enabled(id_insert_table_name) { super(sql, name, binds, pk) }
           else
-            exec_query(sql, name, binds)
+            super(sql, name, binds, pk)
           end
         end
 
         def exec_delete(sql, name, binds)
-          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
-          super.rows.first.first
+          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super(sql, name, binds).rows.first.first
         end
 
         def exec_update(sql, name, binds)
-          sql << '; SELECT @@ROWCOUNT AS AffectedRows'
-          super.rows.first.first
+          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          super(sql, name, binds).rows.first.first
         end
 
         def supports_statement_cache?
@@ -80,7 +76,7 @@ module ActiveRecord
         end
 
         def case_sensitive_comparison(table, attribute, column, value)
-          if value && value.acts_like?(:string)
+          if column.collation && !column.case_sensitive?
             table[attribute].eq(Arel::Nodes::Bin.new(Arel::Nodes::BindParam.new))
           else
             super
@@ -198,7 +194,7 @@ module ActiveRecord
           end
           sql = if pk && self.class.use_output_inserted && !database_prefix_remote_server?
                   quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-                  sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                  sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
                 else
                   "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
                 end
@@ -261,7 +257,7 @@ module ActiveRecord
           if name == 'EXPLAIN'
             params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
-              sql.sub! substitute_at_finder, param.to_s
+              sql = sql.sub substitute_at_finder, param.to_s
             end
           else
             types = quote(types.join(', '))

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,6 +14,17 @@ module ActiveRecord
         end
 
         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|
+              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
@@ -103,10 +85,34 @@ 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 ? '@0' : quote(identifier.object)}
+            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:]]/, ' ')
+          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'] }
+        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 +136,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 +148,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 +203,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 +249,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,18 +316,8 @@ 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
-
         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
@@ -475,7 +495,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
@@ -498,8 +518,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_adapter.rb

@@ -73,14 +73,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
@@ -147,10 +139,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) ================== #
@@ -230,6 +222,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
@@ -327,6 +327,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
@@ -418,14 +432,11 @@ module ActiveRecord
       end
 
       def version_year
-        return @version_year if defined?(@version_year)
-        @version_year = begin
-          vstring = _raw_select('SELECT @@version', fetch: :rows).first.first.to_s
-          return 2016 if vstring =~ /vNext/
-          /SQL Server (\d+)/.match(vstring).to_a.last.to_s.to_i
-        rescue Exception => e
-          2016
-        end
+        vstring = _raw_select('SELECT @@version', fetch: :rows).first.first.to_s
+        return 2016 if vstring =~ /vNext/
+        /SQL Server (\d+)/.match(vstring).to_a.last.to_s.to_i
+      rescue Exception => e
+        2016
       end
 
     end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -48,7 +48,7 @@ module ActiveRecord
         create true
       end
 
-      def structure_dump(filename)
+      def structure_dump(filename, extra_flags)
         command = [
           "defncopy",
           "-S #{Shellwords.escape(configuration['host'])}",
@@ -71,7 +71,7 @@ module ActiveRecord
         File.open(filename, "w") { |file| file.puts dump }
       end
 
-      def structure_load(filename)
+      def structure_load(filename, extra_flags)
         connection.execute File.read(filename)
       end
 

data/lib/arel/visitors/sqlserver.rb

@@ -190,7 +190,8 @@ module Arel
 
       def primary_Key_From_Table t
         return unless t
-        column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.try(:second).try(:name)
+        column_name = @connection.schema_cache.primary_keys(t.name) ||
+          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
         column_name ? t[column_name] : nil
       end
 

data/test/cases/adapter_test_sqlserver.rb

@@ -37,10 +37,6 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert_equal 'SQLServer', connection.adapter_name
   end
 
-  it 'supports migrations' do
-    assert connection.supports_migrations?
-  end
-
   it 'support DDL in transactions' do
     assert connection.supports_ddl_transactions?
   end
@@ -265,23 +261,23 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'create integers when limit is 4' do
-      assert_equal 'integer', connection.type_to_sql(:integer, 4)
+      assert_equal 'integer', connection.type_to_sql(:integer, limit: 4)
     end
 
     it 'create integers when limit is 3' do
-      assert_equal 'integer', connection.type_to_sql(:integer, 3)
+      assert_equal 'integer', connection.type_to_sql(:integer, limit: 3)
     end
 
     it 'create smallints when limit is less than 3' do
-      assert_equal 'smallint', connection.type_to_sql(:integer, 2)
-      assert_equal 'smallint', connection.type_to_sql(:integer, 1)
+      assert_equal 'smallint', connection.type_to_sql(:integer, limit: 2)
+      assert_equal 'smallint', connection.type_to_sql(:integer, limit: 1)
     end
 
     it 'create bigints when limit is greateer than 4' do
-      assert_equal 'bigint', connection.type_to_sql(:integer, 5)
-      assert_equal 'bigint', connection.type_to_sql(:integer, 6)
-      assert_equal 'bigint', connection.type_to_sql(:integer, 7)
-      assert_equal 'bigint', connection.type_to_sql(:integer, 8)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 5)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 6)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 7)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 8)
     end
 
     it 'create floats when no limit supplied' do

data/test/cases/coerced_tests.rb

@@ -31,6 +31,9 @@ end
 require 'models/event'
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
+    # I really dont think we can support legacy binds.
+    coerce_tests! :test_select_all_with_legacy_binds
+
     # As far as I can tell, SQL Server does not support null bytes in strings.
     coerce_tests! :test_update_prepared_statement
 
@@ -52,14 +55,14 @@ end
 
 require 'models/topic'
 class AttributeMethodsTest < ActiveRecord::TestCase
-  coerce_tests! :test_typecast_attribute_from_select_to_false
+  coerce_tests! %r{typecast attribute from select to false}
   def test_typecast_attribute_from_select_to_false_coerced
     Topic.create(:title => 'Budget')
     topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 2, 1, 0) as is_test").first
     assert !topic.is_test?
   end
 
-  coerce_tests! :test_typecast_attribute_from_select_to_true
+  coerce_tests! %r{typecast attribute from select to true}
   def test_typecast_attribute_from_select_to_true_coerced
     Topic.create(:title => 'Budget')
     topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 1, 1, 0) as is_test").first
@@ -118,6 +121,15 @@ end
 
 
 class CalculationsTest < ActiveRecord::TestCase
+  # This fails randomly due to schema cache being lost?
+  coerce_tests! :test_offset_is_kept
+  def test_offset_is_kept_coerced
+    Account.first
+    queries = assert_sql { Account.offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/OFFSET/, queries.first)
+  end
+
   # Are decimal, not integer.
   coerce_tests! :test_should_return_decimal_average_of_integer_field
   def test_should_return_decimal_average_of_integer_field_coerced
@@ -161,6 +173,29 @@ end
 
 
 
+module ActiveRecord
+  module ConnectionAdapters
+    class QuoteARBaseTest < ActiveRecord::TestCase
+
+      # Use our date format.
+      coerce_tests! :test_quote_ar_object
+      def test_quote_ar_object_coerced
+        value = DatetimePrimaryKey.new(id: @time)
+        assert_equal "'02-14-2017 12:34:56.79'",  @connection.quote(value)
+      end
+
+      # Use our date format.
+      coerce_tests! :test_type_cast_ar_object
+      def test_type_cast_ar_object_coerced
+        value = DatetimePrimaryKey.new(id: @time)
+        assert_equal "02-14-2017 12:34:56.79",  @connection.type_cast(value)
+      end
+
+    end
+  end
+end
+
+
 
 module ActiveRecord
   class Migration
@@ -289,6 +324,10 @@ end
 
 
 module ActiveRecord
+  class DatabaseTasksDumpSchemaCacheTest < ActiveRecord::TestCase
+    # Skip this test with /tmp/my_schema_cache.yml path on Windows.
+    coerce_tests! :test_dump_schema_cache if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  end
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     # We extend `local_database?` so that common VM IPs can be used.
     coerce_tests! :test_ignores_remote_databases, :test_warning_for_remote_databases
@@ -375,12 +414,6 @@ class FinderTest < ActiveRecord::TestCase
     end
   end
 
-  coerce_tests! :test_string_sanitation
-  def test_string_sanitation_coerced
-    assert_not_equal "'something ' 1=1'", ActiveRecord::Base.sanitize("something ' 1=1")
-    assert_equal "N'something; select table'", ActiveRecord::Base.sanitize("something; select table")
-  end
-
   coerce_tests! :test_take_and_first_and_last_with_integer_should_use_sql_limit
   def test_take_and_first_and_last_with_integer_should_use_sql_limit_coerced
     assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 3/) { Topic.take(3).entries }
@@ -576,6 +609,15 @@ end
 
 
 
+class PrimaryKeysTest < ActiveRecord::TestCase
+  # Gonna trust Rails core for this. We end up with 2 querys vs 3 asserted
+  # but as far as I can tell, this is only one for us anyway.
+  coerce_tests! :test_create_without_primary_key_no_extra_query
+end
+
+
+
+
 require 'models/task'
 class QueryCacheTest < ActiveRecord::TestCase
   coerce_tests! :test_cache_does_not_wrap_string_results_in_arrays
@@ -619,6 +661,26 @@ class RelationTest < ActiveRecord::TestCase
   # Leave it up to users to format selects/functions so HAVING works correctly.
   coerce_tests! :test_multiple_where_and_having_clauses
   coerce_tests! :test_having_with_binds_for_both_where_and_having
+
+  # Find any limit via our expression.
+  coerce_tests! %r{relations don't load all records in #inspect}
+  def test_relations_dont_load_all_records_in_inspect_coerced
+    assert_sql(/NEXT @0 ROWS.*@0 = \d+/) do
+      Post.all.inspect
+    end
+  end
+
+  # I wanted to add `.order("author_id")` scope to avoid error: Column "posts.id" is invalid in the ORDER BY
+  # However, this pull request on Rails core drops order on exists relation. https://github.com/rails/rails/pull/28699
+  # so we are skipping all together.
+  coerce_tests! :test_empty_complex_chained_relations
+
+  # Use LEN() vs length() function.
+  coerce_tests! :test_reverse_arel_assoc_order_with_function
+  def test_reverse_arel_assoc_order_with_function_coerced
+    topics = Topic.order(Arel.sql("LEN(title)") => :asc).reverse_order
+    assert_equal topics(:second).title, topics.first.title
+  end
 end
 
 
@@ -650,9 +712,6 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 38}, output
   end
 
-  # This accidently returns the wrong number because of our tables too.
-  coerce_tests! :test_types_line_up
-
   # This is a poorly written test and really does not catch the bottom'ness it is meant too. Ours throw it off.
   coerce_tests! :test_foreign_keys_are_dumped_at_the_bottom_to_circumvent_dependency_issues
 
@@ -816,3 +875,19 @@ module ActiveRecord
     coerce_tests! :test_find_does_not_use_statement_cache_if_table_name_is_changed
   end
 end
+
+
+
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaCacheTest < ActiveRecord::TestCase
+      private
+      # We need to give the full path for this to work.
+      def schema_dump_path
+        File.join ARTest::SQLServer.root_activerecord, 'test/assets/schema_dump_5_1.yml'
+      end
+    end
+  end
+end
+

data/test/cases/column_test_sqlserver.rb

@@ -36,7 +36,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'bigint(8)' do
       col = column('bigint')
       col.sql_type.must_equal           'bigint(8)'
-      col.type.must_equal               :bigint
+      col.type.must_equal               :integer
       col.null.must_equal               true
       col.default.must_equal            42
       obj.bigint.must_equal             42

data/test/cases/helper_sqlserver.rb

@@ -23,9 +23,14 @@ module ActiveRecord
 
     let(:logger) { ActiveRecord::Base.logger }
 
+    setup :ensure_clean_rails_env
 
     private
 
+    def ensure_clean_rails_env
+      Rails.instance_variable_set(:@_env, nil) if defined?(::Rails)
+    end
+
     def host_windows?
       RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     end

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -46,17 +46,6 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'reload with lock when #lock! called' do
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
-        end
-      end
-    end
-
     it 'can add a custom lock directive' do
       assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
         Person.lock('WITH(HOLDLOCK, ROWLOCK)').load

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -38,17 +38,17 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     # Character Strings
     assert_line :char_10,           type: 'char',         limit: 10,            precision: nil,   scale: nil,  default: "1234567890",           collation: nil
     assert_line :varchar_50,        type: 'varchar',      limit: 50,            precision: nil,   scale: nil,  default: "test varchar_50",      collation: nil
-    assert_line :varchar_max,       type: 'varchar_max',  limit: 2147483647,    precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
-    assert_line :text,              type: 'text_basic',   limit: 2147483647,    precision: nil,   scale: nil,  default: "test text",            collation: nil
+    assert_line :varchar_max,       type: 'varchar_max',  limit: nil,           precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
+    assert_line :text,              type: 'text_basic',   limit: nil,           precision: nil,   scale: nil,  default: "test text",            collation: nil
     # Unicode Character Strings
     assert_line :nchar_10,          type: 'nchar',        limit: 10,            precision: nil,   scale: nil,  default: "12345678åå",           collation: nil
     assert_line :nvarchar_50,       type: 'string',       limit: 50,            precision: nil,   scale: nil,  default: "test nvarchar_50 åå",  collation: nil
-    assert_line :nvarchar_max,      type: 'text',         limit: 2147483647,    precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
-    assert_line :ntext,             type: 'ntext',        limit: 2147483647,    precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
+    assert_line :nvarchar_max,      type: 'text',         limit: nil,           precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
+    assert_line :ntext,             type: 'ntext',        limit: nil,           precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
     # Binary Strings
     assert_line :binary_49,         type: 'binary_basic', limit: 49,            precision: nil,   scale: nil,  default: nil
     assert_line :varbinary_49,      type: 'varbinary',    limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_max,     type: 'binary',       limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :varbinary_max,     type: 'binary',       limit: nil,           precision: nil,   scale: nil,  default: nil
     # Other Data Types
     assert_line :uniqueidentifier,  type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: -> { "newid()" }
     assert_line :timestamp,         type: 'ss_timestamp', limit: nil,           precision: nil,   scale: nil,  default: nil
@@ -76,12 +76,12 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :decimal_col,     type: 'decimal',      limit: nil,          precision: 18,   scale: 0,   default: nil
     assert_line :float_col,       type: 'float',        limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :string_col,      type: 'string',       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :text_col,        type: 'text',         limit: 2147483647,   precision: nil,  scale: nil, default: nil
+    assert_line :text_col,        type: 'text',         limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :datetime_col,    type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :timestamp_col,   type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :time_col,        type: 'time',         limit: nil,          precision: 7,    scale: nil, default: nil
     assert_line :date_col,        type: 'date',         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :binary_col,      type: 'binary',       limit: 2147483647,   precision: nil,  scale: nil, default: nil
+    assert_line :binary_col,      type: 'binary',       limit: nil,          precision: nil,  scale: nil, default: nil
     # Our type methods.
     columns['real_col'].sql_type.must_equal         'real'
     columns['money_col'].sql_type.must_equal        'money'
@@ -107,14 +107,14 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :smallmoney_col,    type: 'smallmoney',     limit: nil,           precision: 10,    scale: 4,    default: nil
     assert_line :char_col,          type: 'char',           limit: 1,             precision: nil,   scale: nil,  default: nil
     assert_line :varchar_col,       type: 'varchar',        limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :text_basic_col,    type: 'text_basic',     limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :text_basic_col,    type: 'text_basic',     limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :nchar_col,         type: 'nchar',          limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :ntext_col,         type: 'ntext',          limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :ntext_col,         type: 'ntext',          limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :binary_basic_col,  type: 'binary_basic',   limit: 1,             precision: nil,   scale: nil,  default: nil
     assert_line :varbinary_col,     type: 'varbinary',      limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :uuid_col,          type: 'uuid',           limit: nil,           precision: nil,   scale: nil,  default: nil
     assert_line :sstimestamp_col,   type: 'ss_timestamp',   limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :json_col,          type: 'text',           limit: 2147483647,    precision: nil,   scale: nil,  default: nil
+    assert_line :json_col,          type: 'text',           limit: nil,           precision: nil,   scale: nil,  default: nil
   end
 
   # Special Cases

data/test/schema/sqlserver_specific_schema.rb

@@ -148,7 +148,7 @@ ActiveRecord::Schema.define do
 
   # Constraints
 
-  create_table(:sst_has_fks, force: true) { |t| t.column(:fk_id, :integer, null: false) }
+  create_table(:sst_has_fks, force: true) { |t| t.column(:fk_id, :bigint, null: false) }
   create_table(:sst_has_pks, force: true) { }
   execute <<-ADDFKSQL
     ALTER TABLE sst_has_fks

data/test/support/sql_counter_sqlserver.rb

@@ -13,7 +13,7 @@ module ARTest
     end
 
     ignored_sql = [
-      /INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)/im,
+      /INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS|KEY_COLUMN_USAGE)/im,
       /SELECT @@version/,
       /SELECT @@TRANCOUNT/,
       /(BEGIN|COMMIT|ROLLBACK|SAVE) TRANSACTION/,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version
-  version: 5.0.8
+  version: 5.1.0
 platform: ruby
 authors:
 - Ken Collins
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-30 00:00:00.000000000 Z
+date: 2017-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -22,14 +22,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.1.0
 - !ruby/object:Gem::Dependency
   name: tiny_tds
   requirement: !ruby/object:Gem::Requirement
@@ -54,6 +54,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- BACKERS.md
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -288,3 +289,4 @@ test_files:
 - test/support/rake_helpers.rb
 - test/support/sql_counter_sqlserver.rb
 - test/support/test_in_memory_oltp.rb
+has_rdoc: