activerecord-jdbc-adapter 51.8-java → 52.0-java

data/lib/arjdbc/mysql/adapter.rb

@@ -31,16 +31,8 @@ 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
-
+      def initialize(connection, logger, config)
+        super(connection, logger, nil, config)
         @prepared_statements = false unless config.key?(:prepared_statements)
         # configure_connection taken care of at ArJdbc::Abstract::Core
       end
@@ -65,6 +57,10 @@ module ActiveRecord
         true
       end
 
+      def supports_set_server_option?
+        false
+      end
+
       # HELPER METHODS ===========================================
 
       # Reloading the type map in abstract/statement_cache.rb blows up postgres
@@ -90,10 +86,6 @@ module ActiveRecord
         exception.error_code if exception.is_a?(JDBCError)
       end
 
-      def create_table(table_name, **options) #:nodoc:
-        super(table_name, options: "ENGINE=InnoDB", **options)
-      end
-
       #--
       # QUOTING ==================================================
       #+
@@ -146,6 +138,22 @@ module ActiveRecord
         ::ActiveRecord::ConnectionAdapters::MySQL::Column
       end
 
+      # defined in MySQL::DatabaseStatements which is not included
+      def default_insert_value(column)
+        Arel.sql("DEFAULT") unless column.auto_increment?
+      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
+      end
     end
   end
 end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def mysql_connection(config)
-    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.mysql2_connection ActiveRecord::Base.configurations['arunit'].merge(database: ...)
     config = symbolize_keys_if_necessary(config)
@@ -11,20 +10,14 @@ ArJdbc::ConnectionMethods.module_eval do
 
     return jndi_connection(config) if jndi_config?(config)
 
-    driver = config[:driver]
-    mysql_driver = driver.nil? || driver.to_s.start_with?('com.mysql.')
-    mariadb_driver = ! mysql_driver && driver.to_s.start_with?('org.mariadb.')
+    driver = config[:driver] ||=
+      defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
 
     begin
       require 'jdbc/mysql'
       ::Jdbc::MySQL.load_driver(:require) if defined?(::Jdbc::MySQL.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
-    end if mysql_driver
-
-    if driver.nil?
-      config[:driver] ||=
-        defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
-    end
+    end if mysql_driver = driver[0, 10] == 'com.mysql.'
 
     config[:username] = 'root' unless config.key?(:username)
     # jdbc:mysql://[host][,failoverhost...][:port]/[database]
@@ -32,16 +25,15 @@ ArJdbc::ConnectionMethods.module_eval do
     # - if the port is not specified, it defaults to 3306
     # - alternate fail-over syntax: [host:port],[host:port]/[database]
     unless config[:url]
-      host = config[:host]
-      host ||= 'localhost' if mariadb_driver
-      host = host.join(',') if host.respond_to?(:join)
+      host = config[:host]; host = host.join(',') if host.respond_to?(:join)
       config[:url] = "jdbc:mysql://#{host}#{ config[:port] ? ":#{config[:port]}" : nil }/#{config[:database]}"
     end
 
+    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
+
     properties = ( config[:properties] ||= {} )
     if mysql_driver
-      properties['zeroDateTimeBehavior'] ||=
-        config[:driver].to_s.start_with?('com.mysql.cj.') ? 'CONVERT_TO_NULL' : 'convertToNull'
+      properties['zeroDateTimeBehavior'] ||= 'convertToNull'
       properties['jdbcCompliantTruncation'] ||= false
       # NOTE: this is "better" than passing what users are used to set on MRI
       # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
@@ -71,8 +63,8 @@ ArJdbc::ConnectionMethods.module_eval do
     end
     if config[:sslkey] || sslcert = config[:sslcert] # || config[:use_ssl]
       properties['useSSL'] ||= true # supported by MariaDB as well
+      properties['requireSSL'] ||= true if mysql_driver
       if mysql_driver
-        properties['requireSSL'] ||= true
         properties['clientCertificateKeyStoreUrl'] ||= java.io.File.new(sslcert).to_url.to_s if sslcert
         if sslca = config[:sslca]
           properties['trustCertificateKeyStoreUrl'] ||= java.io.File.new(sslca).to_url.to_s
@@ -113,8 +105,7 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
 
-    config[:driver] ||=
-      defined?(::Jdbc::MariaDB.driver_name) ? ::Jdbc::MariaDB.driver_name : 'org.mariadb.jdbc.Driver'
+    config[:driver] ||= 'org.mariadb.jdbc.Driver'
 
     mysql_connection(config)
   end

data/lib/arjdbc/postgresql/adapter.rb

@@ -8,6 +8,7 @@ require 'active_record/connection_adapters/postgresql/explain_pretty_printer'
 require 'active_record/connection_adapters/postgresql/quoting'
 require 'active_record/connection_adapters/postgresql/referential_integrity'
 require 'active_record/connection_adapters/postgresql/schema_creation'
+require 'active_record/connection_adapters/postgresql/schema_definitions'
 require 'active_record/connection_adapters/postgresql/schema_dumper'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/type_metadata'
@@ -30,9 +31,6 @@ module ArJdbc
     # @private
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
 
-    # @private
-    ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
-
     # @private
     Type = ::ActiveRecord::Type
 
@@ -50,35 +48,12 @@ module ArJdbc
       ADAPTER_NAME
     end
 
-    # TODO: Update this to pull info from the DatabaseMetaData object?
     def postgresql_version
       @postgresql_version ||=
         begin
           version = @connection.database_product
-          if match = version.match(/([\d\.]*\d).*?/)
-            version = match[1].split('.').map(&:to_i)
-            # PostgreSQL version representation does not have more than 4 digits
-            # From version 10 onwards, PG has changed its versioning policy to
-            # limit it to only 2 digits. i.e. in 10.x, 10 being the major
-            # version and x representing the patch release
-            # Refer to:
-            #   https://www.postgresql.org/support/versioning/
-            #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
-            # for more info
-
-            if version.size >= 3
-              (version[0] * 100 + version[1]) * 100 + version[2]
-            elsif version.size == 2
-              if version[0] >= 10
-                version[0] * 100 * 100 + version[1]
-              else
-                (version[0] * 100 + version[1]) * 100
-              end
-            elsif version.size == 1
-              version[0] * 100 * 100
-            else
-              0
-            end
+          if version =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
           else
             0
           end
@@ -239,8 +214,6 @@ module ArJdbc
 
     def supports_ddl_transactions?; true end
 
-    def supports_advisory_locks?; true end
-
     def supports_explain?; true end
 
     def supports_expression_index?; true end
@@ -257,26 +230,18 @@ module ArJdbc
 
     def supports_views?; true end
 
-    def supports_datetime_with_precision?; true end
-
-    def supports_comments?; true end
-
     # Does PostgreSQL support standard conforming strings?
     def supports_standard_conforming_strings?
       standard_conforming_strings?
       @standard_conforming_strings != :unsupported
     end
 
-    def supports_hex_escaped_bytea?
-      postgresql_version >= 90000
-    end
-
-    def supports_materialized_views?
+    def supports_foreign_tables? # we don't really support this yet, its a reminder :)
       postgresql_version >= 90300
     end
 
-    def supports_json?
-      postgresql_version >= 90200
+    def supports_hex_escaped_bytea?
+      postgresql_version >= 90000
     end
 
     def supports_insert_with_returning?
@@ -374,8 +339,8 @@ module ArJdbc
     end
 
     def explain(arel, binds = [])
-      sql = "EXPLAIN #{to_sql(arel, binds)}"
-      ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+      sql, binds = to_sql_and_binds(arel, binds)
+      ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query("EXPLAIN #{sql}", 'EXPLAIN', binds))
     end
 
     # @note Only for "better" AR 4.0 compatibility.
@@ -412,12 +377,6 @@ module ArJdbc
       @connection.configure_connection
     end
 
-    def default_sequence_name(table_name, pk = "id") #:nodoc:
-      serial_sequence(table_name, pk)
-    rescue ActiveRecord::StatementInvalid
-      %Q("#{table_name}_#{pk}_seq")
-    end
-
     def last_insert_id_result(sequence_name)
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
@@ -435,10 +394,8 @@ module ArJdbc
 
     # Set the client message level.
     def client_min_messages=(level)
-      # NOTE: for now simply ignore the writer (no warn on Redshift) so that
-      # the AR copy-pasted PpstgreSQL parts stay the same as much as possible
-      return nil if redshift? # not supported on Redshift
-      execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
+      # Not supported on Redshift
+      redshift? ? nil : super
     end
 
     # ORDER BY clause for the passed order option.
@@ -528,6 +485,77 @@ module ArJdbc
       execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
     end
 
+    # Returns an array of indexes for the given table.
+    def indexes(table_name)
+
+      # FIXME: AR version => table = Utils.extract_schema_qualified_name(table_name.to_s)
+      schema, table = extract_schema_and_table(table_name.to_s)
+
+      result = query(<<-SQL, 'SCHEMA')
+            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
+                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment
+            FROM pg_class t
+            INNER JOIN pg_index d ON t.oid = d.indrelid
+            INNER JOIN pg_class i ON d.indexrelid = i.oid
+            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
+            WHERE i.relkind = 'i'
+              AND d.indisprimary = 'f'
+              AND t.relname = '#{table}'
+              AND n.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
+            ORDER BY i.relname
+      SQL
+
+      result.map do |row|
+        index_name = row[0]
+        # FIXME: These values [1,2] are returned in a different format than AR expects, maybe we could update it on the Java side to be more accurate
+        unique = row[1].is_a?(String) ? row[1] == 't' : row[1] # JDBC gets us a boolean
+        indkey = row[2].is_a?(Java::OrgPostgresqlUtil::PGobject) ? row[2].value : row[2]
+        indkey = indkey.split(" ").map(&:to_i)
+        inddef = row[3]
+        oid = row[4]
+        comment = row[5]
+
+        using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m).flatten
+
+        orders = {}
+        opclasses = {}
+
+        if indkey.include?(0)
+          columns = expressions
+        else
+          columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
+                SELECT a.attnum, a.attname
+                FROM pg_attribute a
+                WHERE a.attrelid = #{oid}
+                AND a.attnum IN (#{indkey.join(",")})
+          SQL
+
+          # add info on sort order (only desc order is explicitly specified, asc is the default)
+          # and non-default opclasses
+          expressions.scan(/(?<column>\w+)\s?(?<opclass>\w+_ops)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
+            opclasses[column] = opclass.to_sym if opclass
+            if nulls
+              orders[column] = [desc, nulls].compact.join(' ')
+            elsif desc
+              orders[column] = :desc
+            end
+          end
+        end
+
+        IndexDefinition.new(
+            table_name,
+            index_name,
+            unique,
+            columns,
+            orders: orders,
+            opclasses: opclasses,
+            where: where,
+            using: using.to_sym,
+            comment: comment.presence
+        )
+      end
+    end
+
     # @private
     def column_name_for_operation(operation, node)
       case operation
@@ -562,8 +590,6 @@ module ArJdbc
     end
 
     def translate_exception(exception, message)
-      return super unless exception.is_a?(ActiveRecord::JDBCError)
-
       # TODO: Can we base these on an error code of some kind?
       case exception.message
       when /duplicate key value violates unique constraint/
@@ -580,6 +606,10 @@ module ArJdbc
         ::ActiveRecord::SerializationFailure.new(message)
       when /deadlock detected/
         ::ActiveRecord::Deadlocked.new(message)
+      when /lock timeout/
+        ::ActiveRecord::LockWaitTimeout.new(message)
+      when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
+        ::ActiveRecord::QueryCanceled.new(message)
       else
         super
       end
@@ -627,7 +657,6 @@ module ActiveRecord::ConnectionAdapters
 
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
-    include ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDumper
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity
     include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
     include ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting
@@ -651,14 +680,15 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
+    def initialize(connection, logger = nil, config = {})
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
       @max_identifier_length = nil
 
-      super(connection, logger, config) # configure_connection happens in super
+      super # configure_connection happens in super
 
-      initialize_type_map(@type_map = Type::HashLookupTypeMap.new)
+      @type_map = Type::HashLookupTypeMap.new
+      initialize_type_map
 
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
@@ -668,26 +698,23 @@ module ActiveRecord::ConnectionAdapters
       Arel::Visitors::PostgreSQL.new(self)
     end
 
-    require 'active_record/connection_adapters/postgresql/schema_definitions'
-
-    ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods
-    TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
-    Table = ActiveRecord::ConnectionAdapters::PostgreSQL::Table
+    def exec_query(sql, name = nil, binds = [], prepare: false)
+      super
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless e.cause.message.include?('cached plan must not change result type'.freeze)
 
-    def create_table_definition(*args) # :nodoc:
-      TableDefinition.new(*args)
+      if open_transactions > 0
+        # In a transaction, have to fail it - See AR code for details
+        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+      else
+        # Not in a transaction, clear the prepared statement and try again
+        delete_cached_statement(sql)
+        retry
+      end
     end
 
     public :sql_for_insert
 
-    def schema_creation # :nodoc:
-      PostgreSQL::SchemaCreation.new self
-    end
-
-    def update_table_definition(table_name, base)
-      Table.new(table_name, base)
-    end
-
     def jdbc_connection_class(spec)
       ::ArJdbc::PostgreSQL.jdbc_connection_class
     end
@@ -696,7 +723,7 @@ module ActiveRecord::ConnectionAdapters
 
     # Prepared statements aren't schema aware so we need to make sure we
     # store different PreparedStatement objects for different schemas
-    def sql_key(sql)
+    def cached_statement_key(sql)
       "#{schema_search_path}-#{sql}"
     end
 

data/lib/arjdbc/postgresql/column.rb

@@ -15,7 +15,7 @@ module ArJdbc
       end
 
       # Extracts the value from a PostgreSQL column default definition.
-      def extract_value_from_default(default)
+      def extract_value_from_default(default) # :nodoc:
         case default
           # Quoted types
           when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
@@ -41,13 +41,10 @@ module ArJdbc
         end
       end
 
-      def extract_default_function(default_value, default)
-        default if has_default_function?(default_value, default)
+      def extract_default_function(default_value, default) # :nodoc:
+        default if ! default_value && ( %r{\w+\(.*\)|\(.*\)::\w+} === default )
       end
 
-      def has_default_function?(default_value, default)
-        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP} === default
-      end
     end
 
   end