activerecord-jdbc-alt-adapter 52.2.3-java → 60.1.0-java

data/lib/arjdbc/mssql/column.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     # MSSQL specific extensions to column definitions in a table.
     class MSSQLColumn < Column
+      attr_reader :table_name
       def initialize(name, raw_default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+        @table_name = table_name
         default = extract_default(raw_default)
 
-        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+        super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
       end
 
       def extract_default(value)

data/lib/arjdbc/mssql/connection_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ArJdbc::ConnectionMethods.module_eval do
 
   # Default connection method for MS-SQL adapter (`adapter: mssql`),
@@ -11,6 +13,8 @@ ArJdbc::ConnectionMethods.module_eval do
       return sqlserver_connection(config)
     end
 
+    config = config.deep_dup
+
     config[:adapter_spec] ||= ::ArJdbc::MSSQL
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
 
@@ -31,7 +35,8 @@ ArJdbc::ConnectionMethods.module_eval do
     config[:connection_alive_sql] ||= 'SELECT 1'
 
     config[:url] ||= begin
-      url = "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      url = ''.dup
+      url << "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
       # Instance is often a preferrable alternative to port when dynamic ports are used.
       # If instance is specified then port is essentially ignored.
       url << ";instance=#{config[:instance]}" if config[:instance]
@@ -52,6 +57,8 @@ ArJdbc::ConnectionMethods.module_eval do
 
   # @note Assumes SQLServer SQL-JDBC driver on the class-path.
   def sqlserver_connection(config)
+    config = config.deep_dup
+
     config[:adapter_spec] ||= ::ArJdbc::MSSQL
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
 
@@ -60,13 +67,17 @@ ArJdbc::ConnectionMethods.module_eval do
     config[:host] ||= 'localhost'
     config[:driver] ||= 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
     config[:connection_alive_sql] ||= 'SELECT 1'
+    config[:lock_timeout] ||= 5000
 
     config[:url] ||= begin
-      url = "jdbc:sqlserver://#{config[:host]}"
+      url = ''.dup
+      url << "jdbc:sqlserver://#{config[:host]}"
       url << ( config[:port] ? ":#{config[:port]};" : ';' )
       url << "databaseName=#{config[:database]};" if config[:database]
       url << "instanceName=#{config[:instance]};" if config[:instance]
       url << "sendTimeAsDatetime=#{config[:send_time_as_datetime] || false};"
+      url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
+      url << "lockTimeout=#{config[:lock_timeout].to_i};"
       app = config[:appname] || config[:application]
       url << "applicationName=#{app};" if app
       isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll

data/lib/arjdbc/mssql/database_limits.rb

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

data/lib/arjdbc/mssql/database_statements.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MSSQL
@@ -23,6 +25,15 @@ module ActiveRecord
         end
         alias_method :execute_procedure, :exec_proc # AR-SQLServer-Adapter naming
 
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :with
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
+
         def execute(sql, name = nil)
           # with identity insert on block
           if insert_sql?(sql)
@@ -52,11 +63,6 @@ module ActiveRecord
           end
         end
 
-        # Implements the truncate method.
-        def truncate(table_name, name = nil)
-          execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
-        end
-
         # Not a rails method, own method to test different isolation
         # levels supported by the mssql adapter.
         def supports_transaction_isolation_level?(level)
@@ -95,8 +101,40 @@ module ActiveRecord
           end
         end
 
+        # Implements the truncate method.
+        def truncate(table_name, name = nil)
+          execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+        end
+
+        def truncate_tables(*table_names) # :nodoc:
+          return if table_names.empty?
+
+          disable_referential_integrity do
+            table_names.each do |table_name|
+              mssql_truncate(table_name)
+            end
+          end
+        end
+
         private
 
+        # It seems the truncate_tables is mostly used for testing
+        # this a workaround to the fact that SQL Server truncate tables
+        # referenced by a foreign key, it may not be required to reset
+        # the identity column too, more at:
+        #    https://docs.microsoft.com/en-us/sql/t-sql/statements/truncate-table-transact-sql?view=sql-server-ver15
+        # TODO: improve is with pure T-SQL, use statements
+        # such as TRY CATCH and reset identity with DBCC CHECKIDENT
+        def mssql_truncate(table_name)
+          execute "TRUNCATE TABLE #{quote_table_name(table_name)}", 'Truncate Tables'
+        rescue => e
+          if e.message =~ /Cannot truncate table .* because it is being referenced by a FOREIGN KEY constraint/
+          execute "DELETE FROM #{quote_table_name(table_name)}", 'Truncate Tables with Delete'
+          else
+            raise
+          end
+        end
+
         # Overrides method in abstract class, combining the sqls with semicolon
         # affects disable_referential_integrity in mssql specially when multiple
         # tables are involved.
@@ -127,7 +165,7 @@ module ActiveRecord
         end
 
         def identity_column_name(table_name)
-          for column in columns(table_name)
+          for column in schema_cache.columns(table_name)
             return column.name if column.identity?
           end
           nil

data/lib/arjdbc/mssql/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # Error raised when adapter determines the database could not acquire
   # a necessary lock before timing out

data/lib/arjdbc/mssql/explain_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/string'
 
 module ActiveRecord
@@ -108,7 +110,7 @@ module ActiveRecord
           end
 
           def build_separator
-            '+' << @widths.map {|w| '-' * (w + (cell_padding * 2))}.join('+') << '+'
+            '+'.dup << @widths.map {|w| '-' * (w + (cell_padding * 2))}.join('+') << '+'
           end
 
           def build_cells(items)

data/lib/arjdbc/mssql/extensions/attribute_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file contains extensions, overrides, and monkey patches to core parts
 # of active record to allow SQL Server work properly.
 #
@@ -15,7 +17,9 @@ module ActiveRecord
         # this behaviour, even the current comments for that method says that
         # it rejects primary key but it doesn't (maybe a rails bug?)
         def attributes_for_update(attribute_names)
-          attribute_names.reject do |name|
+          attribute_names &= self.class.column_names
+
+          attribute_names.delete_if do |name|
             # It seems is only required to check if column in identity or not.
             # This allows to update rails custom primary keys
             next true if readonly_attribute?(name)

data/lib/arjdbc/mssql/extensions/calculations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/relation'
 require 'active_record/version'
 

data/lib/arjdbc/mssql/quoting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MSSQL
@@ -64,6 +66,42 @@ module ActiveRecord
         # @see #quote in old adapter
         BLOB_VALUE_MARKER = "''"
 
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # \[table_name\].\[column_name\] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+AS\s+(?:\w+|\[\w+\]))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # \[table_name\].\[column_name\] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
         private
 
         def time_with_db_timezone(value)

data/lib/arjdbc/mssql/schema_creation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MSSQL
@@ -11,8 +13,28 @@ module ActiveRecord
             projections, source = query.match(%r{SELECT\s+(.*)?\s+FROM\s+(.*)?}).captures
             select_into = "SELECT #{projections} INTO #{table_name} FROM #{source}"
           else
-            o.instance_variable_set :@as, nil
-            super
+            # o.instance_variable_set :@as, nil
+            # super
+            create_sql = +''
+
+            create_sql << "IF NOT EXISTS (SELECT 1 FROM sysobjects WHERE name='#{o.name}' and xtype='U') " if o.if_not_exists
+            create_sql << "CREATE#{table_modifier_in_create(o)} TABLE "
+            create_sql << "#{quote_table_name(o.name)} "
+
+            statements = o.columns.map { |c| accept c }
+            statements << accept(o.primary_keys) if o.primary_keys
+
+            if supports_indexes_in_create?
+              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+            end
+
+            if supports_foreign_keys?
+              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            end
+
+            create_sql << "(#{statements.join(', ')})" if statements.present?
+            add_table_options!(create_sql, table_options(o))
+            create_sql
           end
         end
 

data/lib/arjdbc/mssql/schema_definitions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MSSQL
@@ -81,6 +83,14 @@ module ActiveRecord
 
           super
         end
+
+        def timestamps(**options)
+          if !options.key?(:precision) && @conn.supports_datetime_with_precision?
+            options[:precision] = 7
+          end
+
+          super
+        end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table

data/lib/arjdbc/mssql/schema_dumper.rb

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

data/lib/arjdbc/mssql/schema_statements.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MSSQL
-      module SchemaStatements
+      module SchemaStatements # :nodoc:
 
         NATIVE_DATABASE_TYPES = {
           # Logical Rails types to SQL Server types
@@ -41,23 +43,36 @@ module ActiveRecord
           NATIVE_DATABASE_TYPES
         end
 
-        # Returns an array of Column objects for the table specified by +table_name+.
-        # See the concrete implementation for details on the expected parameter values.
-        # NOTE: This is ready, all implemented in the java part of adapter,
-        # it uses MSSQLColumn, SqlTypeMetadata, etc.
-        def columns(table_name)
-          @connection.columns(table_name)
-        rescue => e
-          # raise translate_exception_class(e, nil)
-          # FIXME: this breaks one arjdbc test but fixes activerecord tests
-          # (table name alias). Also it behaves similarly to the CRuby adapter
-          # which returns an empty array too. (postgres throws a exception)
-          []
-        end
-
         # Returns an array of indexes for the given table.
-        def indexes(table_name, name = nil)
-          @connection.indexes(table_name, name)
+        def indexes(table_name)
+          data = select("EXEC sp_helpindex #{quote(table_name)}", "SCHEMA") rescue []
+
+          data.reduce([]) do |indexes, index|
+            index = index.with_indifferent_access
+
+            if index[:index_description] =~ /primary key/
+              indexes
+            else
+              name    = index[:index_name]
+              unique  = index[:index_description].to_s.match?(/unique/)
+              where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}")
+              orders  = {}
+              columns = []
+
+              index[:index_keys].split(',').each do |column|
+                column.strip!
+
+                if column.ends_with?('(-)')
+                  column.gsub! '(-)', ''
+                  orders[column] = :desc
+                end
+
+                columns << column
+              end
+
+              indexes << IndexDefinition.new(table_name, name, unique, columns, where: where, orders: orders)
+            end
+          end
         end
 
         def primary_keys(table_name)
@@ -124,7 +139,7 @@ module ActiveRecord
             end
           end
 
-          if options[:if_exists] && @mssql_major_version < 13
+          if options[:if_exists] && mssql_major_version < 13
             # this is for sql server 2012 and 2014
             execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}"
           else
@@ -193,7 +208,7 @@ module ActiveRecord
               column_type_sql << "(#{precision})"
             else
               raise(
-                ActiveRecordError,
+                ArgumentError,
                 "No #{native[:name]} type has precision of #{precision}. The " \
                 'allowed range of precision is from 0 to 7, even though the ' \
                 'sql type precision is 7 this adapter will persist up to 6 ' \
@@ -220,6 +235,14 @@ module ActiveRecord
           (order_columns << super).join(', ')
         end
 
+        def add_timestamps(table_name, options = {})
+          if !options.key?(:precision) && supports_datetime_with_precision?
+            options[:precision] = 7
+          end
+
+          super
+        end
+
         def create_schema_dumper(options)
           MSSQL::SchemaDumper.create(self, options)
         end
@@ -299,13 +322,30 @@ module ActiveRecord
           execute(sql_alter.join(' '))
         end
 
+        def update_table_definition(table_name, base) #:nodoc:
+          MSSQL::Table.new(table_name, base)
+        end
+
         private
 
+        def schema_creation
+          MSSQL::SchemaCreation.new(self)
+        end
+
+        def create_table_definition(*args)
+          MSSQL::TableDefinition.new(self, *args)
+        end
+
+        def new_column_from_field(table_name, field)
+          field
+        end
+
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope(name, type: type)
           table_name = 'TABLE_NAME'
 
-          sql = "SELECT #{table_name}"
+          sql = ''.dup
+          sql << "SELECT #{table_name}"
           sql << ' FROM INFORMATION_SCHEMA.TABLES'
           sql << ' WHERE TABLE_CATALOG = DB_NAME()'
           sql << " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
@@ -327,7 +367,9 @@ module ActiveRecord
         end
 
         def change_column_type(table_name, column_name, type, options = {})
-          sql = "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 = ''.dup
+
+          sql << "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 << (options[:null] ? " NULL" : " NOT NULL") if options.has_key?(:null)
           result = execute(sql)
           result