activerecord-jdbc-alt-adapter 52.6.0-java → 60.0.0-java

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.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/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/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/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

data/lib/arjdbc/postgresql/adapter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ArJdbc.load_java_part :PostgreSQL
 
 require 'ipaddr'
@@ -42,46 +42,52 @@ module ArJdbc
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn end
 
-    ADAPTER_NAME = 'PostgreSQL'.freeze
+    ADAPTER_NAME = 'PostgreSQL'
 
     def adapter_name
       ADAPTER_NAME
     end
 
-    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
+    def get_database_version # :nodoc:
+      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
-              0
+              (version[0] * 100 + version[1]) * 100
             end
+          elsif version.size == 1
+            version[0] * 100 * 100
           else
             0
           end
+        else
+          0
         end
+      end
+    end
+
+    def check_version # :nodoc:
+      if database_version < 90300
+        raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
+      end
     end
 
+
     def redshift?
       # SELECT version() :
       #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
@@ -92,13 +98,6 @@ module ArJdbc
     end
     private :redshift?
 
-    def use_insert_returning?
-      if @use_insert_returning.nil?
-        @use_insert_returning = supports_insert_with_returning?
-      end
-      @use_insert_returning
-    end
-
     def set_client_encoding(encoding)
       ActiveRecord::Base.logger.warn "client_encoding is set by the driver and should not be altered, ('#{encoding}' ignored)"
       ActiveRecord::Base.logger.debug "Set the 'allowEncodingChanges' driver property (e.g. using config[:properties]) if you need to override the client encoding when doing a copy."
@@ -165,7 +164,7 @@ module ArJdbc
       int4range:    { name: 'int4range' },
       int8range:    { name: 'int8range' },
       integer:      { name: 'integer' },
-      interval:     { name: 'interval' }, # This doesn't get added to AR's postgres adapter until 5.1 but it fixes broken tests in 5.0 ...
+      interval:     { name: 'interval' },
       json:         { name: 'json' },
       jsonb:        { name: 'jsonb' },
       line:         { name: 'line' },
@@ -198,107 +197,114 @@ module ArJdbc
       !native_database_types[type].nil?
     end
 
-    # Enable standard-conforming strings if available.
     def set_standard_conforming_strings
-      self.standard_conforming_strings=(true)
+      execute("SET standard_conforming_strings = on", "SCHEMA")
     end
 
-    # Enable standard-conforming strings if available.
-    def standard_conforming_strings=(enable)
-      client_min_messages = self.client_min_messages
-      begin
-        self.client_min_messages = 'panic'
-        value = enable ? "on" : "off"
-        execute("SET standard_conforming_strings = #{value}", 'SCHEMA')
-        @standard_conforming_strings = ( value == "on" )
-      rescue
-        @standard_conforming_strings = :unsupported
-      ensure
-        self.client_min_messages = client_min_messages
-      end
+    def supports_bulk_alter?
+      true
     end
 
-    def standard_conforming_strings?
-      if @standard_conforming_strings.nil?
-        client_min_messages = self.client_min_messages
-        begin
-          self.client_min_messages = 'panic'
-          value = select_one('SHOW standard_conforming_strings', 'SCHEMA')['standard_conforming_strings']
-          @standard_conforming_strings = ( value == "on" )
-        rescue
-          @standard_conforming_strings = :unsupported
-        ensure
-          self.client_min_messages = client_min_messages
-        end
-      end
-      @standard_conforming_strings == true # return false if :unsupported
+    def supports_index_sort_order?
+      true
     end
 
-    def supports_ddl_transactions?; true end
+    def supports_partial_index?
+      true
+    end
 
-    def supports_advisory_locks?; true end
+    def supports_expression_index?
+      true
+    end
 
-    def supports_explain?; true end
+    def supports_transaction_isolation?
+      true
+    end
 
-    def supports_expression_index?; true end
+    def supports_foreign_keys?
+      true
+    end
 
-    def supports_foreign_keys?; true end
+    def supports_validate_constraints?
+      true
+    end
 
-    def supports_validate_constraints?; true end
+    def supports_views?
+      true
+    end
 
-    def supports_index_sort_order?; true end
+    def supports_datetime_with_precision?
+      true
+    end
 
-    def supports_partial_index?; true end
+    def supports_json?
+      database_version >= 90200
+    end
 
-    def supports_savepoints?; true end
+    def supports_comments?
+      true
+    end
 
-    def supports_transaction_isolation?; true end
+    def supports_savepoints?
+      true
+    end
 
-    def supports_views?; true end
+    def supports_insert_returning?
+      true
+    end
 
-    def supports_bulk_alter?; true end    
+    def supports_insert_on_conflict?
+      database_version >= 90500
+    end
+    alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
+    alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
+    alias supports_insert_conflict_target? supports_insert_on_conflict?
 
-    def supports_datetime_with_precision?; true end
+    def index_algorithms
+      { concurrently: 'CONCURRENTLY' }
+    end
 
-    def supports_comments?; true end
+    def supports_ddl_transactions?
+      true
+    end
 
-    # Does PostgreSQL support standard conforming strings?
-    def supports_standard_conforming_strings?
-      standard_conforming_strings?
-      @standard_conforming_strings != :unsupported
+    def supports_advisory_locks?
+      true
     end
 
-    def supports_foreign_tables? # we don't really support this yet, its a reminder :)
-      postgresql_version >= 90300
+    def supports_explain?
+      true
     end
 
-    def supports_hex_escaped_bytea?
-      postgresql_version >= 90000
+    def supports_extensions?
+      database_version >= 90200
     end
 
-    def supports_materialized_views?
-      postgresql_version >= 90300
+    def supports_ranges?
+      database_version >= 90200
     end
 
-    def supports_json?
-      postgresql_version >= 90200
+    def supports_materialized_views?
+      database_version >= 90300
     end
 
-    def supports_insert_with_returning?
-      postgresql_version >= 80200
+    def supports_foreign_tables? # we don't really support this yet, its a reminder :)
+      database_version >= 90300
     end
 
     def supports_pgcrypto_uuid?
-      postgresql_version >= 90400
+      database_version >= 90400
     end
 
-    # Range data-types weren't introduced until PostgreSQL 9.2.
-    def supports_ranges?
-      postgresql_version >= 90200
+    def supports_optimizer_hints?
+      unless defined?(@has_pg_hint_plan)
+        @has_pg_hint_plan = extension_available?("pg_hint_plan")
+      end
+      @has_pg_hint_plan
     end
 
-    def supports_extensions?
-      postgresql_version >= 90200
+    def supports_lazy_transactions?
+      true
     end
 
     # From AR 5.1 postgres_adapter.rb
@@ -306,65 +312,60 @@ module ArJdbc
       index.using == :btree || super
     end
 
+    def get_advisory_lock(lock_id) # :nodoc:
+      unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
+        raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
+      end
+      query_value("SELECT pg_try_advisory_lock(#{lock_id})")
+    end
+
+    def release_advisory_lock(lock_id) # :nodoc:
+      unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
+        raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
+      end
+      query_value("SELECT pg_advisory_unlock(#{lock_id})")
+    end
+
     def enable_extension(name)
-      execute("CREATE EXTENSION IF NOT EXISTS \"#{name}\"")
+      exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
+        reload_type_map
+      }
     end
 
     def disable_extension(name)
-      execute("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE")
+      exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
+        reload_type_map
+      }
+    end
+
+    def extension_available?(name)
+      query_value("SELECT true FROM pg_available_extensions WHERE name = #{quote(name)}", "SCHEMA")
     end
 
     def extension_enabled?(name)
-      if supports_extensions?
-        rows = select_rows("SELECT EXISTS(SELECT * FROM pg_available_extensions WHERE name = '#{name}' AND installed_version IS NOT NULL)", 'SCHEMA')
-        available = rows.first.first # true/false or 't'/'f'
-        available == true || available == 't'
-      end
+      query_value("SELECT installed_version IS NOT NULL FROM pg_available_extensions WHERE name = #{quote(name)}", "SCHEMA")
     end
 
     def extensions
-      if supports_extensions?
-        rows = select_rows "SELECT extname from pg_extension", "SCHEMA"
-        rows.map { |row| row.first }
-      else
-        []
-      end
+      exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
     end
 
-    def index_algorithms
-      { :concurrently => 'CONCURRENTLY' }
+    # Returns the configured supported identifier length supported by PostgreSQL
+    def max_identifier_length
+      @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
     end
 
-    # Set the authorized user for this session.
+    # Set the authorized user for this session
     def session_auth=(user)
       clear_cache!
-      execute "SET SESSION AUTHORIZATION #{user}"
+      execute("SET SESSION AUTHORIZATION #{user}")
     end
 
-    # Came from postgres_adapter
-    def get_advisory_lock(lock_id) # :nodoc:
-      unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
-        raise(ArgumentError, "Postgres requires advisory lock ids to be a signed 64 bit integer")
-      end
-      select_value("SELECT pg_try_advisory_lock(#{lock_id});")
-    end
-
-    # Came from postgres_adapter
-    def release_advisory_lock(lock_id) # :nodoc:
-      unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
-        raise(ArgumentError, "Postgres requires advisory lock ids to be a signed 64 bit integer")
-      end
-      select_value("SELECT pg_advisory_unlock(#{lock_id})")
-    end
-
-    # Returns the max identifier length supported by PostgreSQL
-    def max_identifier_length
-      @max_identifier_length ||= select_one('SHOW max_identifier_length', 'SCHEMA'.freeze)['max_identifier_length'].to_i
+    def use_insert_returning?
+      @use_insert_returning
     end
-    alias table_alias_length max_identifier_length
-    alias index_name_length max_identifier_length
 
-    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
       val = super
       if !use_insert_returning? && pk
         unless sequence_name
@@ -383,20 +384,12 @@ module ArJdbc
       ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query("EXPLAIN #{sql}", 'EXPLAIN', binds))
     end
 
-    # @note Only for "better" AR 4.0 compatibility.
-    # @private
-    def query(sql, name = nil)
-      log(sql, name) do
-        result = []
-        @connection.execute_query_raw(sql, []) do |*values|
-          # We need to use #deep_dup here because it appears that
-          # the java method is reusing an object in some cases
-          # which makes all of the entries in the "result"
-          # array end up with the same values as the last row
-          result << values.deep_dup
-        end
-        result
-      end
+    # from ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements
+    READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
+    private_constant :READ_QUERY
+
+    def write_query?(sql) # :nodoc:
+      !READ_QUERY.match?(sql)
     end
 
     # We need to make sure to deallocate all the prepared statements
@@ -427,6 +420,24 @@ module ArJdbc
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
 
+    def build_insert_sql(insert) # :nodoc:
+      sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+      if insert.skip_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+      elsif insert.update_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+      end
+
+      sql << " RETURNING #{insert.returning}" if insert.returning
+      sql
+    end
+
+    def build_truncate_statements(*table_names)
+      "TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"
+    end
+
     def all_schemas
       select('SELECT nspname FROM pg_namespace').map { |row| row["nspname"] }
     end
@@ -463,13 +474,7 @@ module ArJdbc
 
     def escape_bytea(string)
       return unless string
-      if supports_hex_escaped_bytea?
-        "\\x#{string.unpack("H*")[0]}"
-      else
-        result = ''
-        string.each_byte { |c| result << sprintf('\\\\%03o', c) }
-        result
-      end
+      "\\x#{string.unpack("H*")[0]}"
     end
 
     # @override
@@ -502,6 +507,19 @@ module ArJdbc
       nil
     end
 
+
+    # @private
+    def column_name_for_operation(operation, node)
+      case operation
+      when 'maximum' then 'max'
+      when 'minimum' then 'min'
+      when 'average' then 'avg'
+      else operation.downcase
+      end
+    end
+
+    private
+
     # Returns the list of a table's column names, data types, and default values.
     #
     # If the table name is not prefixed with a schema, the database will
@@ -511,82 +529,73 @@ module ArJdbc
     #  - format_type includes the column size constraint, e.g. varchar(50)
     #  - ::regclass is a function that gives the id for a table name
     def column_definitions(table_name)
-      select_rows(<<-end_sql, 'SCHEMA')
+      select_rows(<<~SQL, 'SCHEMA')
         SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-               (SELECT c.collname FROM pg_collation c, pg_type t
-                 WHERE c.oid = a.attcollation AND t.oid = a.atttypid
-                  AND a.attcollation <> t.typcollation),
-               col_description(a.attrelid, a.attnum) AS comment
+               c.collname, col_description(a.attrelid, a.attnum) AS comment
           FROM pg_attribute a
           LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+          LEFT JOIN pg_type t ON a.atttypid = t.oid
+          LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
          WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
            AND a.attnum > 0 AND NOT a.attisdropped
          ORDER BY a.attnum
-      end_sql
+      SQL
     end
-    private :column_definitions
 
-    def truncate(table_name, name = nil)
-      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    def extract_table_ref_from_insert_sql(sql)
+      sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
+      $1.strip if $1
     end
 
-    # @private
-    def column_name_for_operation(operation, node)
-      case operation
-      when 'maximum' then 'max'
-      when 'minimum' then 'min'
-      when 'average' then 'avg'
-      else operation.downcase
-      end
+    def arel_visitor
+      Arel::Visitors::PostgreSQL.new(self)
     end
 
-    private
-
     # Pulled from ActiveRecord's Postgres adapter and modified to use execute
     def can_perform_case_insensitive_comparison_for?(column)
       @case_insensitive_cache ||= {}
       @case_insensitive_cache[column.sql_type] ||= begin
-        sql = <<-end_sql
-              SELECT exists(
-                SELECT * FROM pg_proc
-                WHERE proname = 'lower'
-                  AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
-              ) OR exists(
-                SELECT * FROM pg_proc
-                INNER JOIN pg_cast
-                  ON ARRAY[casttarget]::oidvector = proargtypes
-                WHERE proname = 'lower'
-                  AND castsource = #{quote column.sql_type}::regtype
-              )
-        end_sql
+        sql = <<~SQL
+          SELECT exists(
+            SELECT * FROM pg_proc
+            WHERE proname = 'lower'
+              AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
+          ) OR exists(
+            SELECT * FROM pg_proc
+            INNER JOIN pg_cast
+              ON ARRAY[casttarget]::oidvector = proargtypes
+            WHERE proname = 'lower'
+              AND castsource = #{quote column.sql_type}::regtype
+          )
+        SQL
         select_value(sql, 'SCHEMA')
       end
     end
 
-    def translate_exception(exception, message)
+    def translate_exception(exception, message:, sql:, binds:)
       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/
-        ::ActiveRecord::RecordNotUnique.new(message)
+        ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
       when /violates not-null constraint/
-        ::ActiveRecord::NotNullViolation.new(message)
+        ::ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
       when /violates foreign key constraint/
-        ::ActiveRecord::InvalidForeignKey.new(message)
+        ::ActiveRecord::InvalidForeignKey.new(message, sql: sql, binds: binds)
       when /value too long/
-        ::ActiveRecord::ValueTooLong.new(message)
+        ::ActiveRecord::ValueTooLong.new(message, sql: sql, binds: binds)
       when /out of range/
-        ::ActiveRecord::RangeError.new(message)
+        ::ActiveRecord::RangeError.new(message, sql: sql, binds: binds)
       when /could not serialize/
-        ::ActiveRecord::SerializationFailure.new(message)
+        ::ActiveRecord::SerializationFailure.new(message, sql: sql, binds: binds)
       when /deadlock detected/
-        ::ActiveRecord::Deadlocked.new(message)
+        ::ActiveRecord::Deadlocked.new(message, sql: sql, binds: binds)
       when /lock timeout/
-        ::ActiveRecord::LockWaitTimeout.new(message)
+        ::ActiveRecord::LockWaitTimeout.new(message, sql: sql, binds: binds)
       when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
-        ::ActiveRecord::QueryCanceled.new(message)
+        ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
       else
         super
       end
@@ -610,11 +619,6 @@ module ArJdbc
       end
     end
 
-    def extract_table_ref_from_insert_sql(sql)
-      sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-      $1.strip if $1
-    end
-
     def local_tz
       @local_tz ||= execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
     end
@@ -635,6 +639,7 @@ module ActiveRecord::ConnectionAdapters
   remove_const(:PostgreSQLAdapter) if const_defined?(:PostgreSQLAdapter)
 
   class PostgreSQLAdapter < AbstractAdapter
+    class_attribute :create_unlogged_tables, default: false
 
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
@@ -672,11 +677,16 @@ module ActiveRecord::ConnectionAdapters
       initialize_type_map
 
       @use_insert_returning = @config.key?(:insert_returning) ?
-        self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
+        self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
 
-    def arel_visitor # :nodoc:
-      Arel::Visitors::PostgreSQL.new(self)
+    def self.database_exists?(config)
+      conn = ActiveRecord::Base.postgresql_connection(config)
+      conn && conn.really_valid?
+    rescue ActiveRecord::NoDatabaseError
+      false
+    ensure
+      conn.disconnect! if conn
     end
 
     require 'active_record/connection_adapters/postgresql/schema_definitions'
@@ -685,11 +695,8 @@ module ActiveRecord::ConnectionAdapters
     TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
     Table = ActiveRecord::ConnectionAdapters::PostgreSQL::Table
 
-    def create_table_definition(*args) # :nodoc:
-      TableDefinition.new(*args)
-    end
-
     public :sql_for_insert
+    alias :postgresql_version :database_version
 
     def jdbc_connection_class(spec)
       ::ArJdbc::PostgreSQL.jdbc_connection_class