activerecord-jdbc-alt-adapter 52.5.1-java → 60.2.0-java

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.

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)
-          log('JDBC: GETCOLUMNS', 'SCHEMA') { @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

data/lib/arjdbc/mssql/transaction.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/abstract/transaction'
 
 # MSSQL doe not restore the initial transaction isolation when the transaction

data/lib/arjdbc/mssql/types/binary_types.rb

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

data/lib/arjdbc/mssql/types/date_and_time_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # MSSQL date and time types definitions
 module ActiveRecord
   module ConnectionAdapters

data/lib/arjdbc/mssql/types/deprecated_types.rb

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

data/lib/arjdbc/mssql/types/numeric_types.rb

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

data/lib/arjdbc/mssql/types/string_types.rb

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

data/lib/arjdbc/mssql/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'arjdbc/mssql/types/numeric_types'
 require 'arjdbc/mssql/types/string_types'
 require 'arjdbc/mssql/types/binary_types'

data/lib/arjdbc/mssql/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # NOTE: file contains code adapted from **sqlserver** adapter, license follows
 =begin
 Copyright (c) 2008-2015

data/lib/arjdbc/mssql.rb

@@ -1,7 +1,9 @@
 require 'arjdbc'
 require 'arjdbc/mssql/adapter'
 require 'arjdbc/mssql/connection_methods'
+
 module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
 end
-ArJdbc.warn_unsupported_adapter 'mssql', [5, 2] # warns on AR >= 4.2
+
+ArJdbc.warn_unsupported_adapter 'mssql', [6, 0] # warns on AR >= 4.2

data/lib/arjdbc/mysql/adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ArJdbc.load_java_part :MySQL
 
 require 'bigdecimal'
@@ -19,7 +21,7 @@ module ActiveRecord
     remove_const(:Mysql2Adapter) if const_defined?(:Mysql2Adapter)
 
     class Mysql2Adapter < AbstractMysqlAdapter
-      ADAPTER_NAME = 'Mysql2'.freeze
+      ADAPTER_NAME = 'Mysql2'
 
       include Jdbc::ConnectionPoolCallbacks
 
@@ -32,21 +34,30 @@ module ActiveRecord
       include ArJdbc::MySQL
 
       def initialize(connection, logger, connection_parameters, config)
-        # workaround to skip version check on JNDI to be lazy, dummy version is high enough for Rails 5.0 - 6.0
-        is_jndi = ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
-        @version = '8.1.5' if is_jndi
-
         super
 
-        # set to nil to have it lazy-load the real value when required
-        @version = nil if is_jndi
-
         @prepared_statements = false unless config.key?(:prepared_statements)
         # configure_connection taken care of at ArJdbc::Abstract::Core
       end
 
+      def self.database_exists?(config)
+        conn = ActiveRecord::Base.mysql2_connection(config)
+        conn && conn.really_valid?
+      rescue ActiveRecord::NoDatabaseError
+        false
+      ensure
+        conn.disconnect! if conn
+      end
+
+      def check_version
+        # for JNDI, don't check version as the whole connection should be lazy
+        return if ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
+
+        super
+      end
+
       def supports_json?
-        !mariadb? && version >= '5.7.8'
+        !mariadb? && database_version >= '5.7.8'
       end
 
       def supports_comments?
@@ -61,6 +72,10 @@ module ActiveRecord
         true
       end
 
+      def supports_lazy_transactions?
+        true
+      end
+
       def supports_transaction_isolation?
         true
       end
@@ -71,6 +86,16 @@ module ActiveRecord
 
       # HELPER METHODS ===========================================
 
+      # from MySQL::DatabaseStatements
+      READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+        :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc
+      ) # :nodoc:
+      private_constant :READ_QUERY
+
+      def write_query?(sql) # :nodoc:
+        !READ_QUERY.match?(sql)
+      end
+
       # Reloading the type map in abstract/statement_cache.rb blows up postgres
       def clear_cache!
         reload_type_map
@@ -136,7 +161,13 @@ module ActiveRecord
       private
 
       # e.g. "5.7.20-0ubuntu0.16.04.1"
-      def full_version; @full_version ||= @connection.full_version end
+      def full_version
+        schema_cache.database_version.full_version_string
+      end
+
+      def get_full_version
+        @full_version ||= @connection.full_version
+      end
 
       def jdbc_connection_class(spec)
         ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
@@ -152,15 +183,13 @@ module ActiveRecord
       end
 
       # FIXME: optimize insert_fixtures_set by using JDBC Statement.addBatch()/executeBatch()
-      def combine_multi_statements(total_sql)
-        total_sql
-      end
-
-      def with_multi_statements
-        yield
-      end
 
-      def discard_remaining_results
+      def combine_multi_statements(total_sql)
+        if total_sql.length == 1
+          total_sql.first
+        else
+          total_sql
+        end
       end
     end
   end