activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/postgresql.rb

@@ -1,4 +1,3 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/postgres'
-require 'arjdbc/postgresql/connection_methods'
+require 'arjdbc'
 require 'arjdbc/postgresql/adapter'
+require 'arjdbc/postgresql/connection_methods'

data/lib/arjdbc/postgresql/_bc_time_cast_patch.rb

@@ -0,0 +1,24 @@
+ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.class_eval do
+  def cast_value(value)
+    return value unless value.is_a?(::String)
+
+    case value
+      when 'infinity' then ::Float::INFINITY
+      when '-infinity' then -::Float::INFINITY
+      # when / BC$/
+      #   astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+      #   super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+      # else
+      #   super
+      else
+        if value.end_with?(' BC')
+          astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+          DateTime.parse("#{value}"[0...-3].sub(/^\d+/, astronomical_year))
+        else
+          super
+        end
+    end
+  end
+
+  def apply_seconds_precision(value); value end
+end

data/lib/arjdbc/postgresql/adapter.rb

@@ -1,404 +1,403 @@
-module ActiveRecord::ConnectionAdapters
-  PostgreSQLAdapter = Class.new(AbstractAdapter) unless const_defined?(:PostgreSQLAdapter)
-end
-
-module ::ArJdbc
+# frozen_string_literal: false
+ArJdbc.load_java_part :PostgreSQL
+
+require 'ipaddr'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/postgresql/column'
+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_dumper'
+require 'active_record/connection_adapters/postgresql/schema_statements'
+require 'active_record/connection_adapters/postgresql/type_metadata'
+require 'active_record/connection_adapters/postgresql/utils'
+require 'arjdbc/abstract/core'
+require 'arjdbc/abstract/connection_management'
+require 'arjdbc/abstract/database_statements'
+require 'arjdbc/abstract/statement_cache'
+require 'arjdbc/abstract/transaction_support'
+require 'arjdbc/postgresql/base/array_decoder'
+require 'arjdbc/postgresql/base/array_encoder'
+require 'arjdbc/postgresql/name'
+
+module ArJdbc
+  # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
   module PostgreSQL
-    def self.extended(mod)
-      mod.class.class_eval do
-        alias_chained_method :insert, :query_dirty, :insert
-      end
-    end
 
-    def self.column_selector
-      [/postgre/i, lambda {|cfg,col| col.extend(::ArJdbc::PostgreSQL::Column)}]
-    end
+    require 'arjdbc/postgresql/column'
+    require 'arel/visitors/postgresql_jdbc'
+    # @private
+    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
 
+    # @private
+    ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+
+    # @private
+    Type = ::ActiveRecord::Type
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::PostgresJdbcConnection
+      ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
     end
 
-    module Column
-      def type_cast(value)
-        case type
-        when :boolean then cast_to_boolean(value)
-        else super
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn end
+
+    ADAPTER_NAME = 'PostgreSQL'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    # TODO: Update this to pull info from the DatabaseMetaData object?
+    def postgresql_version
+      @postgresql_version ||=
+        begin
+          version = @connection.database_product
+          if version =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+          else
+            0
+          end
         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
+      if ( redshift = config[:redshift] ).nil?
+        redshift = !! (@connection.database_product || '').index('Redshift')
       end
+      redshift
+    end
+    private :redshift?
 
-      def extract_limit(sql_type)
-        case sql_type
-        when /^bigint/i;    8
-        when /^smallint/i;  2
-        when /^bool/i;      nil # ACTIVERECORD_JDBC-135
-        else super
+    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."
+    end
+
+    # Configures the encoding, verbosity, schema search path, and time zone of the connection.
+    # This is called on `connection.connect` and should not be called manually.
+    def configure_connection
+      #if encoding = config[:encoding]
+        # The client_encoding setting is set by the driver and should not be altered.
+        # If the driver detects a change it will abort the connection.
+        # see http://jdbc.postgresql.org/documentation/91/connect.html
+        # self.set_client_encoding(encoding)
+      #end
+      self.client_min_messages = config[:min_messages] || 'warning'
+      self.schema_search_path = config[:schema_search_path] || config[:schema_order]
+
+      # Use standard-conforming strings if available so we don't have to do the E'...' dance.
+      set_standard_conforming_strings
+
+      # If using Active Record's time zone support configure the connection to return
+      # TIMESTAMP WITH ZONE types in UTC.
+      # (SET TIME ZONE does not use an equals sign like other SET variables)
+      if ActiveRecord::Base.default_timezone == :utc
+        execute("SET time zone 'UTC'", 'SCHEMA')
+      elsif tz = local_tz
+        execute("SET time zone '#{tz}'", 'SCHEMA')
+      end unless redshift?
+
+      # SET statements from :variables config hash
+      # http://www.postgresql.org/docs/8.3/static/sql-set.html
+      (config[:variables] || {}).map do |k, v|
+        if v == ':default' || v == :default
+          # Sets the value to the global or compile default
+          execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
+        elsif ! v.nil?
+          execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
         end
       end
+    end
 
-      def simplified_type(field_type)
-        return :integer if field_type =~ /^serial/i
-        return :string if field_type =~ /\[\]$/i || field_type =~ /^interval/i
-        return :string if field_type =~ /^(?:point|lseg|box|"?path"?|polygon|circle)/i
-        return :datetime if field_type =~ /^timestamp/i
-        return :float if field_type =~ /^(?:real|double precision)$/i
-        return :binary if field_type =~ /^bytea/i
-        return :boolean if field_type =~ /^bool/i
-        super
+    # @private
+    ActiveRecordError = ::ActiveRecord::ActiveRecordError
+
+    NATIVE_DATABASE_TYPES = {
+      bigserial:    'bigserial',
+      primary_key:  'serial primary key',
+      bigint:       { name: 'bigint' },
+      binary:       { name: 'bytea' },
+      bit:          { name: 'bit' },
+      bit_varying:  { name: 'bit varying' },
+      boolean:      { name: 'boolean' },
+      box:          { name: 'box' },
+      char:         { name: 'char' },
+      cidr:         { name: 'cidr' },
+      circle:       { name: 'circle' },
+      citext:       { name: 'citext' },
+      date:         { name: 'date' },
+      daterange:    { name: 'daterange' },
+      datetime:     { name: 'timestamp' },
+      decimal:      { name: 'decimal' }, # :limit => 1000
+      float:        { name: 'float' },
+      hstore:       { name: 'hstore' },
+      inet:         { name: 'inet' },
+      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 ...
+      json:         { name: 'json' },
+      jsonb:        { name: 'jsonb' },
+      line:         { name: 'line' },
+      lseg:         { name: 'lseg' },
+      ltree:        { name: 'ltree' },
+      macaddr:      { name: 'macaddr' },
+      money:        { name: 'money' },
+      numeric:      { name: 'numeric' },
+      numrange:     { name: 'numrange' },
+      path:         { name: 'path' },
+      point:        { name: 'point' },
+      polygon:      { name: 'polygon' },
+      serial:       { name: 'serial' }, # auto-inc integer, bigserial, smallserial
+      string:       { name: 'character varying' },
+      text:         { name: 'text' },
+      time:         { name: 'time' },
+      timestamp:    { name: 'timestamp' },
+      tsrange:      { name: 'tsrange' },
+      tstzrange:    { name: 'tstzrange' },
+      tsvector:     { name: 'tsvector' },
+      uuid:         { name: 'uuid' },
+      xml:          { name: 'xml' }
+    }
+
+    def native_database_types
+      NATIVE_DATABASE_TYPES
+    end
+
+    def valid_type?(type)
+      !native_database_types[type].nil?
+    end
+
+    # Enable standard-conforming strings if available.
+    def set_standard_conforming_strings
+      self.standard_conforming_strings=(true)
+    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
+    end
 
-      def cast_to_boolean(value)
-        return nil if value.nil?
-        if value == true || value == false
-          value
-        else
-          %w(true t 1).include?(value.to_s.downcase)
+    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
+    end
 
-      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
-      def default_value(value)
-        # Boolean types
-        return "t" if value =~ /true/i
-        return "f" if value =~ /false/i
+    def supports_ddl_transactions?; true end
 
-        # Char/String/Bytea type values
-        return $1 if value =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
+    def supports_explain?; true end
 
-        # Numeric values
-        return value if value =~ /^-?[0-9]+(\.[0-9]*)?/
+    def supports_expression_index?; true end
 
-        # Fixed dates / timestamp
-        return $1 if value =~ /^'(.+)'::(date|timestamp)/
+    def supports_foreign_keys?; true end
 
-        # Anything else is blank, some user type, or some function
-        # and we can't know the value of that, so return nil.
-        return nil
-      end
-    end
+    def supports_index_sort_order?; true end
 
-    def modify_types(tp)
-      tp[:primary_key] = "serial primary key"
-      tp[:string][:limit] = 255
-      tp[:integer][:limit] = nil
-      tp[:boolean] = { :name => "boolean" }
-      tp[:float] = { :name => "float" }
-      tp[:decimal] = { :name => "decimal" }
-      tp
-    end
+    def supports_migrations?; true end
 
-    def adapter_name #:nodoc:
-      'PostgreSQL'
-    end
+    def supports_partial_index?; true end
 
-    def arel2_visitors
-      {'jdbcpostgresql' => ::Arel::Visitors::PostgreSQL}
-    end
+    def supports_primary_key?; true end # Supports finding primary key on non-Active Record tables
 
-    def postgresql_version
-      @postgresql_version ||=
-        begin
-          value = select_value('SELECT version()')
-          if value =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
-            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
-          else
-            0
-          end
-        end
-    end
+    def supports_savepoints?; true end
 
-    # Does PostgreSQL support migrations?
-    def supports_migrations?
-      true
-    end
+    def supports_transaction_isolation?(level = nil); true end
+
+    def supports_views?; true end
 
     # Does PostgreSQL support standard conforming strings?
     def supports_standard_conforming_strings?
-      # Temporarily set the client message level above error to prevent unintentional
-      # error messages in the logs when working on a PostgreSQL database server that
-      # does not support standard conforming strings.
-      client_min_messages_old = client_min_messages
-      self.client_min_messages = 'panic'
+      standard_conforming_strings?
+      @standard_conforming_strings != :unsupported
+    end
 
-      # postgres-pr does not raise an exception when client_min_messages is set higher
-      # than error and "SHOW standard_conforming_strings" fails, but returns an empty
-      # PGresult instead.
-      has_support = select('SHOW standard_conforming_strings').to_a[0][0] rescue false
-      self.client_min_messages = client_min_messages_old
-      has_support
+    def supports_hex_escaped_bytea?
+      postgresql_version >= 90000
     end
 
     def supports_insert_with_returning?
       postgresql_version >= 80200
     end
 
-    def supports_ddl_transactions?
-      true
+    # Range data-types weren't introduced until PostgreSQL 9.2.
+    def supports_ranges?
+      postgresql_version >= 90200
     end
 
-    def supports_savepoints?
-      true
+    def supports_extensions?
+      postgresql_version >= 90200
     end
 
-    def supports_count_distinct? #:nodoc:
-      false
+    def enable_extension(name)
+      execute("CREATE EXTENSION IF NOT EXISTS \"#{name}\"")
     end
 
-    def create_savepoint
-      execute("SAVEPOINT #{current_savepoint_name}")
+    def disable_extension(name)
+      execute("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE")
     end
 
-    def rollback_to_savepoint
-      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+    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
     end
 
-    def release_savepoint
-      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+    def extensions
+      if supports_extensions?
+        rows = select_rows "SELECT extname from pg_extension", "SCHEMA"
+        rows.map { |row| row.first }
+      else
+        []
+      end
     end
 
-    # Returns the configured supported identifier length supported by PostgreSQL,
-    # or report the default of 63 on PostgreSQL 7.x.
-    def table_alias_length
-      @table_alias_length ||= (postgresql_version >= 80000 ? select_one('SHOW max_identifier_length')['max_identifier_length'].to_i : 63)
+    def index_algorithms
+      { :concurrently => 'CONCURRENTLY' }
     end
 
-    def default_sequence_name(table_name, pk = nil)
-      default_pk, default_seq = pk_and_sequence_for(table_name)
-      default_seq || "#{table_name}_#{pk || default_pk || 'id'}_seq"
+    # Set the authorized user for this session.
+    def session_auth=(user)
+      clear_cache!
+      execute "SET SESSION AUTHORIZATION #{user}"
     end
 
-    # Resets sequence to the max value of the table's pk if present.
-    def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
-      unless pk and sequence
-        default_pk, default_sequence = pk_and_sequence_for(table)
-        pk ||= default_pk
-        sequence ||= default_sequence
-      end
-      if pk
-        if sequence
-          quoted_sequence = quote_column_name(sequence)
-
-          select_value <<-end_sql, 'Reset sequence'
-              SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
-            end_sql
-        else
-          @logger.warn "#{table} has primary key #{pk} with no default sequence" if @logger
-        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
 
-    # Find a table's primary key and sequence.
-    def pk_and_sequence_for(table) #:nodoc:
-      # First try looking for a sequence with a dependency on the
-      # given table's primary key.
-      result = select(<<-end_sql, 'PK and serial sequence')[0]
-          SELECT attr.attname, seq.relname
-          FROM pg_class      seq,
-               pg_attribute  attr,
-               pg_depend     dep,
-               pg_namespace  name,
-               pg_constraint cons
-          WHERE seq.oid           = dep.objid
-            AND seq.relkind       = 'S'
-            AND attr.attrelid     = dep.refobjid
-            AND attr.attnum       = dep.refobjsubid
-            AND attr.attrelid     = cons.conrelid
-            AND attr.attnum       = cons.conkey[1]
-            AND cons.contype      = 'p'
-            AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
-        end_sql
-
-      if result.nil? or result.empty?
-        # If that fails, try parsing the primary key's default value.
-        # Support the 7.x and 8.0 nextval('foo'::text) as well as
-        # the 8.1+ nextval('foo'::regclass).
-        result = select(<<-end_sql, 'PK and custom sequence')[0]
-            SELECT attr.attname,
-              CASE
-                WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
-                  substr(split_part(def.adsrc, '''', 2),
-                         strpos(split_part(def.adsrc, '''', 2), '.')+1)
-                ELSE split_part(def.adsrc, '''', 2)
-              END as relname
-            FROM pg_class       t
-            JOIN pg_attribute   attr ON (t.oid = attrelid)
-            JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
-            JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
-            WHERE t.oid = '#{quote_table_name(table)}'::regclass
-              AND cons.contype = 'p'
-              AND def.adsrc ~* 'nextval'
-          end_sql
+    # 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
-
-      [result["attname"], result["relname"]]
-    rescue
-      nil
+      select_value("SELECT pg_advisory_unlock(#{lock_id})")
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-      # Extract the table from the insert sql. Yuck.
-      table = sql.split(" ", 4)[2].gsub('"', '')
-
-      # Try an insert with 'returning id' if available (PG >= 8.2)
-      if supports_insert_with_returning? && id_value.nil?
-        pk, sequence_name = *pk_and_sequence_for(table) unless pk
-        if pk
-          id_value = select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-          clear_query_cache #FIXME: Why now?
-          return id_value
-        end
-      end
-
-      # Otherwise, plain insert
-      execute(sql, name)
-
-      # Don't need to look up id_value if we already have it.
-      # (and can't in case of non-sequence PK)
-      unless id_value
-        # If neither pk nor sequence name is given, look them up.
-        unless pk || sequence_name
-          pk, sequence_name = *pk_and_sequence_for(table)
-        end
+    # Returns the configured supported 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
+    end
+    alias table_alias_length max_identifier_length
+    alias index_name_length max_identifier_length
 
-        # If a pk is given, fallback to default sequence name.
-        # Don't fetch last insert id for a table without a pk.
-        if pk && sequence_name ||= default_sequence_name(table, pk)
-          id_value = last_insert_id(table, sequence_name)
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+      val = super
+      if !use_insert_returning? && pk
+        unless sequence_name
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          sequence_name = default_sequence_name(table_ref, pk)
+          return val unless sequence_name
         end
+        last_insert_id_result(sequence_name)
+      else
+        val
       end
-      id_value
     end
 
-    def columns(table_name, name=nil)
-      schema_name = @config[:schema_search_path]
-      if table_name =~ /\./
-        parts = table_name.split(/\./)
-        table_name = parts.pop
-        schema_name = parts.join(".")
-      end
-      @connection.columns_internal(table_name, name, schema_name)
+    def explain(arel, binds = [])
+      sql = "EXPLAIN #{to_sql(arel, binds)}"
+      ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
     end
 
-    # From postgresql_adapter.rb
-    def indexes(table_name, name = nil)
-      result = select_rows(<<-SQL, name)
-        SELECT i.relname, d.indisunique, a.attname
-          FROM pg_class t, pg_class i, pg_index d, pg_attribute a
-         WHERE i.relkind = 'i'
-           AND d.indexrelid = i.oid
-           AND d.indisprimary = 'f'
-           AND t.oid = d.indrelid
-           AND t.relname = '#{table_name}'
-           AND a.attrelid = t.oid
-           AND ( d.indkey[0]=a.attnum OR d.indkey[1]=a.attnum
-              OR d.indkey[2]=a.attnum OR d.indkey[3]=a.attnum
-              OR d.indkey[4]=a.attnum OR d.indkey[5]=a.attnum
-              OR d.indkey[6]=a.attnum OR d.indkey[7]=a.attnum
-              OR d.indkey[8]=a.attnum OR d.indkey[9]=a.attnum )
-        ORDER BY i.relname
-      SQL
-
-      current_index = nil
-      indexes = []
-
-      result.each do |row|
-        if current_index != row[0]
-          indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, row[0], row[1] == "t", [])
-          current_index = row[0]
+    # @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
-
-        indexes.last.columns << row[2]
+        result
       end
-
-      indexes
-    end
-
-    def last_insert_id(table, sequence_name)
-      Integer(select_value("SELECT currval('#{sequence_name}')"))
-    end
-
-    def recreate_database(name)
-      drop_database(name)
-      create_database(name)
-    end
-
-    def create_database(name, options = {})
-      execute "CREATE DATABASE \"#{name}\" ENCODING='#{options[:encoding] || 'utf8'}'"
     end
 
-    def drop_database(name)
-      execute "DROP DATABASE IF EXISTS \"#{name}\""
+    # We need to make sure to deallocate all the prepared statements
+    # since apparently calling close on the statement object
+    # doesn't always free the server resources and calling
+    # 'DISCARD ALL' fails if we are inside a transaction
+    def clear_cache!
+      super
+      @connection.execute 'DEALLOCATE ALL' if supports_statement_cache? && @connection.active?
     end
 
-    def create_schema(schema_name, pg_username)
-      execute("CREATE SCHEMA \"#{schema_name}\" AUTHORIZATION \"#{pg_username}\"")
+    def reset!
+      clear_cache!
+      reset_transaction
+      @connection.rollback # Have to deal with rollbacks differently than the AR adapter
+      @connection.execute 'DISCARD ALL'
+      @connection.configure_connection
     end
 
-    def drop_schema(schema_name)
-      execute("DROP SCHEMA \"#{schema_name}\"")
+    def last_insert_id_result(sequence_name)
+      exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
 
     def all_schemas
-      select('select nspname from pg_namespace').map {|r| r["nspname"] }
+      select('SELECT nspname FROM pg_namespace').map { |row| row["nspname"] }
     end
 
-    def primary_key(table)
-      pk_and_sequence = pk_and_sequence_for(table)
-      pk_and_sequence && pk_and_sequence.first
+    # Returns the current client message level.
+    def client_min_messages
+      return nil if redshift? # not supported on Redshift
+      # Need to use #execute so we don't try to access the type map before it is initialized
+      execute('SHOW client_min_messages', 'SCHEMA').values.first.first
     end
 
-    def structure_dump
-      database = @config[:database]
-      if database.nil?
-        if @config[:url] =~ /\/([^\/]*)$/
-          database = $1
-        else
-          raise "Could not figure out what database this url is for #{@config["url"]}"
-        end
-      end
-
-      ENV['PGHOST']     = @config[:host] if @config[:host]
-      ENV['PGPORT']     = @config[:port].to_s if @config[:port]
-      ENV['PGPASSWORD'] = @config[:password].to_s if @config[:password]
-      search_path = @config[:schema_search_path]
-      search_path = "--schema=#{search_path}" if search_path
-
-      @connection.connection.close
-      begin
-        definition = `pg_dump -i -U "#{@config[:username]}" -s -x -O #{search_path} #{database}`
-        raise "Error dumping database" if $?.exitstatus == 1
-
-        # need to patch away any references to SQL_ASCII as it breaks the JDBC driver
-        definition.gsub(/SQL_ASCII/, 'UNICODE')
-      ensure
-        reconnect!
-      end
-    end
-
-    # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
-    #
-    # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
-    # requires that the ORDER BY include the distinct column.
-    #
-    #   distinct("posts.id", "posts.created_at desc")
-    def distinct(columns, order_by)
-      return "DISTINCT #{columns}" if order_by.blank?
-
-      # construct a clean list of column names from the ORDER BY clause, removing
-      # any asc/desc modifiers
-      order_columns = order_by.split(',').collect { |s| s.split.first }
-      order_columns.delete_if(&:blank?)
-      order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
-
-      # return a DISTINCT ON() clause that's distinct on the columns we want but includes
-      # all the required columns for the ORDER BY to work properly
-      sql = "DISTINCT ON (#{columns}) #{columns}, "
-      sql << order_columns * ', '
+    # 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')
     end
 
     # ORDER BY clause for the passed order option.
     #
-    # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
-    # by wrapping the sql as a sub-select and ordering in that query.
+    # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON,
+    # so we work around this by wrapping the SQL as a sub-select and ordering
+    # in that query.
     def add_order_by_for_association_limiting!(sql, options)
       return sql if options[:order].blank?
 
@@ -409,36 +408,20 @@ module ::ArJdbc
       sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
     end
 
-    def quote(value, column = nil) #:nodoc:
-      return super unless column
-
-      if value.kind_of?(String) && column.type == :binary
-        "'#{escape_bytea(value)}'"
-      elsif value.kind_of?(String) && column.sql_type == 'xml'
-        "xml '#{quote_string(value)}'"
-      elsif value.kind_of?(Numeric) && column.sql_type == 'money'
-        # Not truly string input, so doesn't require (or allow) escape string syntax.
-        "'#{value}'"
-      elsif value.kind_of?(String) && column.sql_type =~ /^bit/
-        case value
-        when /^[01]*$/
-          "B'#{value}'" # Bit-string notation
-        when /^[0-9A-F]*$/i
-          "X'#{value}'" # Hexadecimal notation
-        end
-      else
-        super
-      end
-    end
+    # @note #quote_string implemented as native
 
-    def escape_bytea(s)
-      if s
+    def escape_bytea(string)
+      return unless string
+      if supports_hex_escaped_bytea?
+        "\\x#{string.unpack("H*")[0]}"
+      else
         result = ''
-        s.each_byte { |c| result << sprintf('\\\\%03o', c) }
+        string.each_byte { |c| result << sprintf('\\\\%03o', c) }
         result
       end
     end
 
+    # @override
     def quote_table_name(name)
       schema, name_part = extract_pg_identifier_from_name(name.to_s)
 
@@ -450,98 +433,285 @@ module ::ArJdbc
       end
     end
 
-    def quote_column_name(name)
-      %("#{name}")
+    # @note #quote_column_name implemented as native
+    alias_method :quote_schema_name, :quote_column_name
+
+    # Need to clear the cache even though the AR adapter doesn't for some reason
+    def remove_column(table_name, column_name, type = nil, options = {})
+      super
+      clear_cache!
     end
 
-    def quoted_date(value) #:nodoc:
-      if value.acts_like?(:time) && value.respond_to?(:usec)
-        "#{super}.#{sprintf("%06d", value.usec)}"
-      else
-        super
+    # @private
+    def column_for(table_name, column_name)
+      column_name = column_name.to_s
+      for column in columns(table_name)
+        return column if column.name == column_name
       end
+      nil
     end
 
-    def disable_referential_integrity(&block) #:nodoc:
-      execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
-      yield
-    ensure
-      execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+    # 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
+    # take the first match from the schema search path.
+    #
+    # Query implementation notes:
+    #  - 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 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
+          FROM pg_attribute a
+          LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+         WHERE a.attrelid = '#{quote_table_name(table_name)}'::regclass
+           AND a.attnum > 0 AND NOT a.attisdropped
+         ORDER BY a.attnum
+      end_sql
+    end
+    private :column_definitions
+
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    end
+
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, name = nil)
+      # 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,
+            (SELECT COUNT(*) FROM pg_opclass o
+               JOIN (SELECT unnest(string_to_array(d.indclass::text, ' '))::int oid) c
+                 ON o.oid = c.oid WHERE o.opcdefault = 'f')
+            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]
+        opclass = row[6]
+
+        using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/).flatten
+
+        if indkey.include?(0) || opclass > 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 for columns (only desc order is explicitly specified, asc is the default)
+          orders = Hash[
+              expressions.scan(/(\w+) DESC/).flatten.map { |order_column| [order_column, :desc] }
+          ]
+        end
+
+        IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, using.to_sym, comment.presence)
+      end.compact
     end
 
-    def rename_table(name, new_name)
-      execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+    # @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
 
-    def add_column(table_name, column_name, type, options = {})
-      execute("ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
-      change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
-      if options[:null] == false
-        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)} = '#{options[:default]}'") if options[:default]
-        execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} SET NOT NULL")
+    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
+        select_value(sql, 'SCHEMA')
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      begin
-        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-      rescue ActiveRecord::StatementInvalid
-        # This is PG7, so we use a more arcane way of doing it.
-        begin_db_transaction
-        add_column(table_name, "#{column_name}_ar_tmp", type, options)
-        execute "UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit], options[:precision], options[:scale])})"
-        remove_column(table_name, column_name)
-        rename_column(table_name, "#{column_name}_ar_tmp", column_name)
-        commit_db_transaction
+    def translate_exception(exception, message)
+      case exception.message
+      when /duplicate key value violates unique constraint/
+        ::ActiveRecord::RecordNotUnique.new(message)
+      when /violates foreign key constraint/
+        ::ActiveRecord::InvalidForeignKey.new(message)
+      when /value too long/
+        ::ActiveRecord::ValueTooLong.new(message)
+      else
+        super
       end
-      change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
     end
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT '#{default}'"
+    # @private `Utils.extract_schema_and_table` from AR
+    def extract_schema_and_table(name)
+      result = name.scan(/[^".\s]+|"[^"]*"/)[0, 2]
+      result.each { |m| m.gsub!(/(^"|"$)/, '') }
+      result.unshift(nil) if result.size == 1 # schema == nil
+      result # [schema, table]
     end
 
-    def change_column_null(table_name, column_name, null, default = nil)
-      unless null || default.nil?
-        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+    def extract_pg_identifier_from_name(name)
+      match_data = name[0, 1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
+
+      if match_data
+        rest = name[match_data[0].length..-1]
+        rest = rest[1..-1] if rest[0, 1] == "."
+        [match_data[1], (rest.length > 0 ? rest : nil)]
       end
-      execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
     end
 
-    def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_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
 
-    def remove_index(table_name, options) #:nodoc:
-      execute "DROP INDEX #{index_name(table_name, options)}"
+    def local_tz
+      @local_tz ||= execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
     end
 
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-      return super unless type.to_s == 'integer'
+  end
+end
+
+require 'arjdbc/util/quoted_cache'
+
+module ActiveRecord::ConnectionAdapters
+
+  # NOTE: seems needed on 4.x due loading of '.../postgresql/oid' which
+  # assumes: class PostgreSQLAdapter < AbstractAdapter
+  remove_const(:PostgreSQLAdapter) if const_defined?(:PostgreSQLAdapter)
+
+  class PostgreSQLAdapter < AbstractAdapter
+
+    # 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
+
+    include Jdbc::ConnectionPoolCallbacks
 
-      if limit.nil? || limit == 4
-        'integer'
-      elsif limit < 4
-        'smallint'
+    include ArJdbc::Abstract::Core
+    include ArJdbc::Abstract::ConnectionManagement
+    include ArJdbc::Abstract::DatabaseStatements
+    include ArJdbc::Abstract::StatementCache
+    include ArJdbc::Abstract::TransactionSupport
+    include ArJdbc::PostgreSQL
+
+    require 'arjdbc/postgresql/oid_types'
+    include ::ArJdbc::PostgreSQL::OIDTypes
+
+    load 'arjdbc/postgresql/_bc_time_cast_patch.rb'
+
+    include ::ArJdbc::PostgreSQL::ColumnHelpers
+
+    include ::ArJdbc::Util::QuotedCache
+
+    # AR expects OID to be available on the adapter
+    OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+
+    def initialize(connection, logger = nil, config = {})
+      # @local_tz is initialized as nil to avoid warnings when connect tries to use it
+      @local_tz = nil
+
+      super # configure_connection happens in super
+
+      initialize_type_map(@type_map = Type::HashLookupTypeMap.new)
+
+      @use_insert_returning = @config.key?(:insert_returning) ?
+        self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
+    end
+
+    def arel_visitor # :nodoc:
+      Arel::Visitors::PostgreSQL.new(self)
+    end
+
+    require 'active_record/connection_adapters/postgresql/schema_definitions'
+
+    ColumnDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition
+    ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods
+    TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+    Table = ActiveRecord::ConnectionAdapters::PostgreSQL::Table
+
+    def create_table_definition(*args) # :nodoc:
+      TableDefinition.new(*args)
+    end
+
+    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)
+
+      if open_transactions > 0
+        # In a transaction, have to fail it - See AR code for details
+        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
       else
-        'bigint'
+        # Not in a transaction, clear the prepared statement and try again
+        delete_cached_statement(sql)
+        retry
       end
     end
 
-    def tables
-      @connection.tables(database_name, nil, nil, ["TABLE"])
+    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
 
     private
-    def extract_pg_identifier_from_name(name)
-      match_data = name[0,1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
 
-      if match_data
-        rest = name[match_data[0].length..-1]
-        rest = rest[1..-1] if rest[0,1] == "."
-        [match_data[1], (rest.length > 0 ? rest : nil)]
-      end
+    # Prepared statements aren't schema aware so we need to make sure we
+    # store different PreparedStatement objects for different schemas
+    def cached_statement_key(sql)
+      "#{schema_search_path}-#{sql}"
     end
+
   end
 end
-