activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/lib/arjdbc/mysql/explain_support.rb

@@ -8,12 +8,9 @@ module ::ArJdbc
       def explain(arel, binds = [])
         sql = "EXPLAIN #{to_sql(arel, binds)}"
         start = Time.now.to_f
-        raw_result = execute(sql, "EXPLAIN", binds)
+        result = exec_query(sql, "EXPLAIN", binds)
         elapsed = Time.now.to_f - start
-        # TODO we should refactor to exce_query once it returns Result ASAP :
-        keys = raw_result[0] ? raw_result[0].keys : {}
-        rows = raw_result.map { |hash| hash.values }
-        ExplainPrettyPrinter.new.pp ActiveRecord::Result.new(keys, rows), elapsed
+        ExplainPrettyPrinter.new.pp result, elapsed
       end
 
       class ExplainPrettyPrinter # :nodoc:

data/lib/arjdbc/oracle.rb

@@ -1,3 +1,3 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/oracle/adapter'
 require 'arjdbc/oracle/connection_methods'

data/lib/arjdbc/oracle/adapter.rb

@@ -5,7 +5,7 @@ module ArJdbc
     
     @@_lob_callback_added = nil
     
-    def self.extended(mod)
+    def self.extended(base)
       unless @@_lob_callback_added
         ActiveRecord::Base.class_eval do
           def after_save_with_oracle_lob
@@ -14,7 +14,7 @@ module ArJdbc
               next if value.nil? || (value == '')
 
               connection.write_large_object(
-                column.type == :binary, column.name, 
+                column.type == :binary, column.name,
                 self.class.table_name, self.class.primary_key, 
                 quote_value(id), value
               )
@@ -48,18 +48,9 @@ module ArJdbc
 
     module Column
       
-      def primary=(val)
+      def primary=(value)
         super
-        if val && @sql_type =~ /^NUMBER$/i
-          @type = :integer
-        end
-      end
-
-      def extract_limit(sql_type)
-        case sql_type
-        when /^(clob|date)/i; nil
-        else super
-        end
+        @type = :integer if value && @sql_type =~ /^NUMBER$/i
       end
       
       def type_cast(value)
@@ -67,6 +58,7 @@ module ArJdbc
         case type
         when :datetime  then ArJdbc::Oracle::Column.string_to_time(value)
         when :timestamp then ArJdbc::Oracle::Column.string_to_time(value)
+        when :boolean   then ArJdbc::Oracle::Column.value_to_boolean(value)
         else
           super
         end
@@ -76,11 +68,25 @@ module ArJdbc
         case type
         when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
         when :timestamp then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
+        when :boolean   then "ArJdbc::Oracle::Column.value_to_boolean(#{var_name})"
         else
           super
         end
       end
 
+      # convert a value to a boolean 
+      def self.value_to_boolean(value)
+        # NOTE: Oracle JDBC meta-data gets us DECIMAL for NUMBER(1) values
+        # thus we're likely to get a column back as BigDecimal (e.g. 1.0)
+        if value.is_a?(String)
+          value.blank? ? nil : value == '1'
+        elsif value.is_a?(Numeric)
+          value.to_i == 1 # <BigDecimal:7b5bfe,'0.1E1',1(4)>
+        else
+          !! value
+        end
+      end
+      
       def self.string_to_time(string)
         return string unless string.is_a?(String)
         return nil if string.empty?
@@ -101,19 +107,28 @@ module ArJdbc
 
       private
       
+      def extract_limit(sql_type)
+        case sql_type
+        when /^(clob|date)/i then nil
+        when /^xml/i then @sql_type = 'XMLTYPE'; nil
+        else super
+        end
+      end
+      
       def simplified_type(field_type)
         case field_type
-        when /^number\(1\)$/i                  then :boolean
-        when /char/i                           then :string
-        when /float|double/i                   then :float
-        when /int/i                            then :integer
-        when /num|dec|real/i                   then extract_scale(field_type) == 0 ? :integer : :decimal
+        when /^number\(1\)$/i   then :boolean
+        when /char/i            then :string
+        when /float|double/i    then :float
+        when /int/i             then :integer
+        when /num|dec|real/i    then extract_scale(field_type) == 0 ? :integer : :decimal
         # Oracle TIMESTAMP stores the date and time to up to 9 digits of sub-second precision
-        when /TIMESTAMP/i                      then :timestamp
+        when /TIMESTAMP/i       then :timestamp
         # Oracle DATE stores the date and time to the second
-        when /DATE|TIME/i                      then :datetime
-        when /CLOB/i                           then :text
-        when /BLOB/i                           then :binary
+        when /DATE|TIME/i       then :datetime
+        when /CLOB/i            then :text
+        when /BLOB/i            then :binary
+        when /XML/i             then :xml
         else
           super
         end
@@ -135,6 +150,22 @@ module ArJdbc
       end
       
     end
+    
+    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition # :nodoc:
+      def raw(*args)
+        options = args.extract_options!
+        column(args[0], 'raw', options)
+      end
+      
+      def xml(*args)
+        options = args.extract_options!
+        column(args[0], 'xml', options)
+      end
+    end
+    
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
+    end
 
     def self.arel2_visitors(config)
       { 'oracle' => Arel::Visitors::Oracle }
@@ -160,6 +191,7 @@ module ArJdbc
       :binary => { :name => "BLOB" },
       :boolean => { :name => "NUMBER", :limit => 1 },
       :raw => { :name => "RAW", :limit => 2000 },
+      :xml => { :name => 'XMLTYPE' }
     }
 
     def native_database_types
@@ -439,14 +471,17 @@ module ArJdbc
     end
     private :extract_order_columns
     
-    def tables
+    def tables # :nodoc:
       @connection.tables(nil, oracle_schema)
     end
     
     # NOTE: better to use current_schema instead of the configured one ?!
-    
     def columns(table_name, name = nil) # :nodoc:
-      @connection.columns_internal(table_name.to_s, name, oracle_schema)
+      @connection.columns_internal(table_name.to_s, nil, oracle_schema)
+    end
+    
+    def tablespace(table_name)
+      select_value "SELECT tablespace_name FROM user_tables WHERE table_name='#{table_name.to_s.upcase}'"
     end
     
     # QUOTING ==================================================
@@ -468,15 +503,17 @@ module ArJdbc
     end
     
     def quote(value, column = nil) # :nodoc:
-      # Arel 2 passes SqlLiterals through
-      return value if sql_literal?(value)
+      return value if sql_literal?(value) # Arel 2 passes SqlLiterals through
 
-      if column && [:text, :binary].include?(column.type)
+      column_type = column && column.type
+      if column_type == :text || column_type == :binary
         if /(.*?)\([0-9]+\)/ =~ column.sql_type
           %Q{empty_#{ $1.downcase }()}
         else
           %Q{empty_#{ column.sql_type.downcase rescue 'blob' }()}
         end
+      elsif column_type == :xml
+        "XMLTYPE('#{quote_string(value)}')" # XMLTYPE ?
       else
         if column.respond_to?(:primary) && column.primary && column.klass != String
           return value.to_i.to_s
@@ -510,23 +547,29 @@ module ArJdbc
     def explain(arel, binds = [])
       sql = "EXPLAIN PLAN FOR #{to_sql(arel)}"
       return if sql =~ /FROM all_/
-      exec_query(sql, 'EXPLAIN', binds)
+      execute(sql, 'EXPLAIN', binds)
       select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
     end
 
     def select(sql, name = nil, binds = [])
-      records = execute(sql, name, binds)
-      for column in records
-        column.delete('raw_rnum_')
-      end
-      records
+      result = super # AR::Result (4.0) or Array (<= 3.2)
+      result.columns.delete('raw_rnum_') if result.respond_to?(:columns)
+      result.each { |row| row.delete('raw_rnum_') } # Hash rows even for AR::Result
+      result
+    end
+    
+    # @override as <code>#execute_insert</code> not working for Oracle e.g.
+    # getLong not implemented for class oracle.jdbc.driver.T4CRowidAccessor: 
+    # INSERT INTO binaries (data, id, name, short_data) VALUES (?, ?, ?, ?)
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
+      execute(sql, name, binds)
     end
     
     private
     
     def _execute(sql, name = nil)
       if self.class.select?(sql)
-        @connection.execute_query(sql)
+        @connection.execute_query_raw(sql)
       else
         @connection.execute_update(sql)
       end
@@ -560,8 +603,5 @@ module ActiveRecord::ConnectionAdapters
 
   class OracleColumn < JdbcColumn
     include ArJdbc::Oracle::Column
-
-    def call_discovered_column_callbacks(*)
-    end
   end
 end

data/lib/arjdbc/oracle/connection_methods.rb

@@ -1,12 +1,11 @@
-class ActiveRecord::Base
-  class << self
-    def oracle_connection(config)
-      config[:port] ||= 1521
-      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
-      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
-      config[:adapter_spec] = ::ArJdbc::Oracle
-      jdbc_connection(config)
-    end
-    alias_method :jdbcoracle_connection, :oracle_connection
+ArJdbc::ConnectionMethods.module_eval do
+  def oracle_connection(config)
+    config[:port] ||= 1521
+    config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
+    config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
+    config[:adapter_spec] = ::ArJdbc::Oracle
+    config[:connection_alive_sql] ||= 'SELECT 1 FROM DUAL'
+    jdbc_connection(config)
   end
+  alias_method :jdbcoracle_connection, :oracle_connection
 end

data/lib/arjdbc/postgresql.rb

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

data/lib/arjdbc/postgresql/adapter.rb

@@ -1,113 +1,251 @@
+require 'ipaddr'
+require 'arjdbc/postgresql/column_cast'
 require 'arjdbc/postgresql/explain_support'
 
-module ::ArJdbc
+module ArJdbc
   module PostgreSQL
-    def self.extended(mod)
-      (class << mod; self; end).class_eval do
-        alias_chained_method :columns, :query_cache, :pg_columns
-      end
-
-      mod.configure_connection
+    
+    AR4_COMPAT = ::ActiveRecord::VERSION::MAJOR > 3 unless const_defined?(:AR4_COMPAT) # :nodoc:
+    
+    def self.extended(base)
+      base.configure_connection
     end
 
     def self.column_selector
-      [/postgre/i, lambda {|cfg,col| col.extend(::ArJdbc::PostgreSQL::Column)}]
+      [ /postgre/i, lambda { |cfg, column| column.extend(::ArJdbc::PostgreSQL::Column) } ]
     end
 
     def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::PostgresJdbcConnection
+      ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
     end
-
+    
+    # Configures the encoding, verbosity, schema search path, and time zone of the connection.
+    # This is called by #connect and should not be called manually.
     def configure_connection
-      self.standard_conforming_strings = true
+      if encoding = config[:encoding]
+        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 defined?(@local_tz) && @local_tz
+        execute("SET time zone '#{@local_tz}'", 'SCHEMA')
+      end # if defined? ActiveRecord::Base.default_timezone
+
+      # 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_s} TO DEFAULT", 'SCHEMA')
+        elsif ! v.nil?
+          execute("SET SESSION #{k.to_s} TO #{quote(v)}", 'SCHEMA')
+        end
+      end
+    end
+
+    # constants taken from postgresql_adapter in rails project
+    ADAPTER_NAME = 'PostgreSQL'
+
+    def adapter_name #:nodoc:
+      ADAPTER_NAME
+    end
+
+    def self.arel2_visitors(config)
+      {
+        'postgresql' => ::Arel::Visitors::PostgreSQL,
+        'jdbcpostgresql' => ::Arel::Visitors::PostgreSQL,
+        'pg' => ::Arel::Visitors::PostgreSQL
+      }
     end
 
-    # column behavior based on postgresql_adapter in rails project
-    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L41
+    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 use_insert_returning?
+      if ( @use_insert_returning ||= nil ).nil?
+        @use_insert_returning = supports_insert_with_returning?
+      end
+      @use_insert_returning
+    end
+    
+    # column behavior based on postgresql_adapter in rails
     module Column
+      
       def self.included(base)
         class << base
+          include ArJdbc::PostgreSQL::Column::Cast
+          # include ArJdbc::PostgreSQL::Column::ArrayParser
           attr_accessor :money_precision
-          def string_to_time(string)
-            return string unless String === string
-
-            case string
-            when 'infinity' then 1.0 / 0.0
-            when '-infinity' then -1.0 / 0.0
-            else
-              super
-            end
-          end
         end
       end
-
-      private
-      # Extracts the value from a Postgresql column default definition
+      
+      attr_accessor :array
+      def array?; array; end # in case we remove the array reader
+      
+      # Extracts the value from a PostgreSQL column default definition.
+      # 
+      # @override JdbcColumn#default_value
+      # NOTE: based on `self.extract_value_from_default(default)` code
       def default_value(default)
+        # This is a performance optimization for Ruby 1.9.2 in development.
+        # If the value is nil, we return nil straight away without checking
+        # the regular expressions. If we check each regular expression,
+        # Regexp#=== will call NilClass#to_str, which will trigger
+        # method_missing (defined by whiny nil in ActiveSupport) which
+        # makes this method very very slow.
+        return default unless default
+
         case default
-          # This is a performance optimization for Ruby 1.9.2 in development.
-          # If the value is nil, we return nil straight away without checking
-          # the regular expressions. If we check each regular expression,
-          # Regexp#=== will call NilClass#to_str, which will trigger
-          # method_missing (defined by whiny nil in ActiveSupport) which
-          # makes this method very very slow.
-        when NilClass
-          nil
+          when /\A'(.*)'::(num|date|tstz|ts|int4|int8)range\z/m
+            $1
           # Numeric types
-        when /\A\(?(-?\d+(\.\d*)?\)?)\z/
-          $1
+          when /\A\(?(-?\d+(\.\d*)?\)?)\z/
+            $1
           # Character types
-        when /\A'(.*)'::(?:character varying|bpchar|text)\z/m
-          $1
-          # Character types (8.1 formatting)
-        when /\AE'(.*)'::(?:character varying|bpchar|text)\z/m
-          $1.gsub(/\\(\d\d\d)/) { $1.oct.chr }
+          when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m
+            $1
           # Binary data types
-        when /\A'(.*)'::bytea\z/m
-          $1
+          when /\A'(.*)'::bytea\z/m
+            $1
           # Date/time types
-        when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/
-          $1
-        when /\A'(.*)'::interval\z/
-          $1
+          when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/
+            $1
+          when /\A'(.*)'::interval\z/
+            $1
           # Boolean type
-        when 'true'
-          true
-        when 'false'
-          false
+          when 'true'
+            true
+          when 'false'
+            false
           # Geometric types
-        when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
-          $1
+          when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
+            $1
           # Network address types
-        when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
-          $1
+          when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
+            $1
           # Bit string types
-        when /\AB'(.*)'::"?bit(?: varying)?"?\z/
-          $1
+          when /\AB'(.*)'::"?bit(?: varying)?"?\z/
+            $1
           # XML type
-        when /\A'(.*)'::xml\z/m
-          $1
+          when /\A'(.*)'::xml\z/m
+            $1
           # Arrays
-        when /\A'(.*)'::"?\D+"?\[\]\z/
-          $1
+          when /\A'(.*)'::"?\D+"?\[\]\z/
+            $1
+          # Hstore
+          when /\A'(.*)'::hstore\z/
+            $1
+          # JSON
+          when /\A'(.*)'::json\z/
+            $1
           # Object identifier types
-        when /\A-?\d+\z/
-          $1
-        else
-          # Anything else is blank, some user type, or some function
-          # and we can't know the value of that, so return nil.
-          nil
+          when /\A-?\d+\z/
+            $1
+          else
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            nil
         end
       end
 
+      # Casts value (which is a String) to an appropriate instance.
+      def type_cast(value)
+        return if value.nil?
+        return super if encoded? # respond_to?(:encoded?) only since AR-3.2
+        
+        # NOTE: we do not use OID::Type
+        # @oid_type.type_cast value
+        
+        return value if array? # handled on the connection (JDBC) side
+        
+        case type
+        when :hstore then self.class.string_to_hstore value
+        when :json then self.class.string_to_json value
+        when :cidr, :inet then self.class.string_to_cidr value
+        when :macaddr then value
+        when :tsvector then value
+        else
+          case sql_type
+          when 'money'
+            # Because money output is formatted according to the locale, there 
+            # are two cases to consider (note the decimal separators) :
+            # (1) $12,345,678.12
+            # (2) $12.345.678,12
+            case value
+            when /^-?\D+[\d,]+\.\d{2}$/ # (1)
+              value.gsub!(/[^-\d.]/, '')
+            when /^-?\D+[\d.]+,\d{2}$/ # (2)
+              value.gsub!(/[^-\d,]/, '')
+              value.sub!(/,/, '.')
+            end
+            self.class.value_to_decimal value
+          when /^point/
+            if value.is_a?(String)
+              self.class.string_to_point value
+            else
+              value
+            end
+          when /(.*?)range$/
+            return if value.nil? || value == 'empty'
+            return value if value.is_a?(::Range)
+            
+            extracted = extract_bounds(value)
+            
+            case $1 # subtype
+            when 'date' # :date
+              from = self.class.value_to_date(extracted[:from])
+              from -= 1.day if extracted[:exclude_start]
+              to = self.class.value_to_date(extracted[:to])
+            when 'num' # :decimal
+              from = BigDecimal.new(extracted[:from].to_s)
+              # FIXME: add exclude start for ::Range, same for timestamp ranges
+              to = BigDecimal.new(extracted[:to].to_s)
+            when 'ts', 'tstz' # :time
+              from = self.class.string_to_time(extracted[:from])
+              to = self.class.string_to_time(extracted[:to])
+            when 'int4', 'int8' # :integer
+              from = to_integer(extracted[:from]) rescue value ? 1 : 0
+              from -= 1 if extracted[:exclude_start]
+              to = to_integer(extracted[:to]) rescue value ? 1 : 0
+            else
+              return value
+            end
+
+            ::Range.new(from, to, extracted[:exclude_end])
+          else super
+          end
+        end
+      end if AR4_COMPAT
+      
+      private
+      
       def extract_limit(sql_type)
         case sql_type
-        when /^bigint/i then 8
-        when /^smallint/i then 2
+        when /^bigint/i; 8
+        when /^smallint/i; 2
+        when /^timestamp/i; nil
         else super
         end
       end
-
+      
       # Extracts the scale from PostgreSQL-specific data types.
       def extract_scale(sql_type)
         # Money type has a fixed scale of 2.
@@ -118,11 +256,13 @@ module ::ArJdbc
       def extract_precision(sql_type)
         if sql_type == 'money'
           self.class.money_precision
+        elsif sql_type =~ /timestamp/i
+          $1.to_i if sql_type =~ /\((\d+)\)/
         else
           super
         end
       end
-
+      
       # Maps PostgreSQL-specific data types to logical Rails types.
       def simplified_type(field_type)
         case field_type
@@ -160,56 +300,219 @@ module ::ArJdbc
           super
         end
       end
-    end
+      
+      def simplified_type(field_type) # :nodoc:
+        case field_type
+        # Numeric and monetary types
+        when /^(?:real|double precision)$/ then :float
+        # Monetary types
+        when 'money' then :decimal
+        when 'hstore' then :hstore
+        when 'ltree' then :ltree
+        # Network address types
+        when 'inet' then :inet
+        when 'cidr' then :cidr
+        when 'macaddr' then :macaddr
+        # Character types
+        when /^(?:character varying|bpchar)(?:\(\d+\))?$/ then :string
+        # Binary data types
+        when 'bytea' then :binary
+        # Date/time types
+        when /^timestamp with(?:out)? time zone$/ then :datetime
+        when /^interval(?:|\(\d+\))$/ then :string
+        # Geometric types
+        when /^(?:point|line|lseg|box|"?path"?|polygon|circle)$/ then :string
+        # Bit strings
+        when /^bit(?: varying)?(?:\(\d+\))?$/ then :string
+        # XML type
+        when 'xml' then :xml
+        # tsvector type
+        when 'tsvector' then :tsvector
+        # Arrays
+        when /^\D+\[\]$/ then :string
+        # Object identifier types
+        when 'oid' then :integer
+        # UUID type
+        when 'uuid' then :uuid
+        # JSON type
+        when 'json' then :json
+        # Small and big integer types
+        when /^(?:small|big)int$/ then :integer
+        when /(num|date|tstz|ts|int4|int8)range$/
+          field_type.to_sym
+        # Pass through all types that are not specific to PostgreSQL.
+        else
+          super
+        end
+      end if AR4_COMPAT
+      
+      # OID Type::Range helpers :
+      
+      def extract_bounds(value)
+        f, t = value[1..-2].split(',')
+        {
+          :from => (value[1] == ',' || f == '-infinity') ? infinity(:negative => true) : f,
+          :to   => (value[-2] == ',' || t == 'infinity') ? infinity : t,
+          :exclude_start => (value[0] == '('), :exclude_end => (value[-1] == ')')
+        }
+      end if AR4_COMPAT
+      
+      def infinity(options = {})
+        ::Float::INFINITY * (options[:negative] ? -1 : 1)
+      end if AR4_COMPAT
+      
+      def to_integer(value)
+        (value.respond_to?(:infinite?) && value.infinite?) ? value : value.to_i
+      end if AR4_COMPAT
+      
+    end # Column
+
+    ActiveRecordError = ::ActiveRecord::ActiveRecordError # :nodoc:
+    
+    # Maps logical Rails types to PostgreSQL-specific data types.
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      case type.to_sym
+      when :'binary'
+        # PostgreSQL doesn't support limits on binary (bytea) columns.
+        # The hard limit is 1Gb, because of a 32-bit size field, and TOAST.
+        case limit
+        when nil, 0..0x3fffffff; super(type, nil, nil, nil)
+        else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
+        end
+      when :'text'
+        # PostgreSQL doesn't support limits on text columns.
+        # The hard limit is 1Gb, according to section 8.3 in the manual.
+        case limit
+        when nil, 0..0x3fffffff; super(type, nil, nil, nil)
+        else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
+        end
+      when :'integer'
+        return 'integer' unless limit
 
-    # constants taken from postgresql_adapter in rails project
-    ADAPTER_NAME = 'PostgreSQL'
+        case limit
+          when 1, 2; 'smallint'
+          when 3, 4; 'integer'
+          when 5..8; 'bigint'
+          else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+        end
+      when :'datetime'
+        return super unless precision
 
-    def adapter_name #:nodoc:
-      ADAPTER_NAME
+        case precision
+          when 0..6; "timestamp(#{precision})"
+          else raise(ActiveRecordError, "No timestamp type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+        end
+      else
+        super
+      end
     end
 
-    def self.arel2_visitors(config)
-      {
-        'postgresql' => ::Arel::Visitors::PostgreSQL,
-        'jdbcpostgresql' => ::Arel::Visitors::PostgreSQL,
-        'pg' => ::Arel::Visitors::PostgreSQL
-      }
-    end
+    def type_cast(value, column, array_member = false)
+      return super unless column
 
-    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
+      case value
+      when String
+        return super(value, column) unless 'bytea' == column.sql_type
+        value # { :value => value, :format => 1 }
+      when Array
+        return super(value, column) unless column.array
+        column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+        column_class.array_to_string(value, column, self)
+      when NilClass
+        if column.array && array_member
+          'NULL'
+        elsif column.array
+          value
+        else
+          super(value, column)
         end
-    end
-
+      when Hash
+        case column.sql_type
+        when 'hstore'
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          column_class.hstore_to_string(value)
+        when 'json'
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          column_class.json_to_string(value)
+        else super(value, column)
+        end
+      when IPAddr
+        return super unless column.sql_type == 'inet' || column.sql_type == 'cidr'
+        column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+        column_class.cidr_to_string(value)
+      else
+        super(value, column)
+      end
+    end if AR4_COMPAT
+    
     NATIVE_DATABASE_TYPES = {
       :primary_key => "serial primary key",
-      :string      => { :name => "character varying", :limit => 255 },
-      :text        => { :name => "text" },
-      :integer     => { :name => "integer" },
-      :float       => { :name => "float" },
-      :decimal     => { :name => "decimal" },
-      :datetime    => { :name => "timestamp" },
-      :timestamp   => { :name => "timestamp" },
-      :time        => { :name => "time" },
-      :date        => { :name => "date" },
-      :binary      => { :name => "bytea" },
-      :boolean     => { :name => "boolean" },
-      :xml         => { :name => "xml" },
-      :tsvector    => { :name => "tsvector" }
+      :string => { :name => "character varying", :limit => 255 },
+      :text => { :name => "text" },
+      :integer => { :name => "integer" },
+      :float => { :name => "float" },
+      :decimal => { :name => "decimal" },
+      :datetime => { :name => "timestamp" },
+      :timestamp => { :name => "timestamp" },
+      :time => { :name => "time" },
+      :date => { :name => "date" },
+      :binary => { :name => "bytea" },
+      :boolean => { :name => "boolean" },
+      :xml => { :name => "xml" },
     }
     
+    NATIVE_DATABASE_TYPES.update({
+      :tsvector => { :name => "tsvector" },
+      :hstore => { :name => "hstore" },
+      :inet => { :name => "inet" },
+      :cidr => { :name => "cidr" },
+      :macaddr => { :name => "macaddr" },
+      :uuid => { :name => "uuid" },
+      :json => { :name => "json" },
+      :ltree => { :name => "ltree" },
+      # ranges :
+      :daterange => { :name => "daterange" },
+      :numrange => { :name => "numrange" },
+      :tsrange => { :name => "tsrange" },
+      :tstzrange => { :name => "tstzrange" },
+      :int4range => { :name => "int4range" },
+      :int8range => { :name => "int8range" },
+    }) if AR4_COMPAT
+    
     def native_database_types
       NATIVE_DATABASE_TYPES
     end
     
+    # Adds `:array` option to the default set provided by the AbstractAdapter
+    def prepare_column_options(column, types)
+      spec = super
+      spec[:array] = 'true' if column.respond_to?(:array) && column.array
+      spec
+    end if AR4_COMPAT
+
+    # Adds `:array` as a valid migration key
+    def migration_keys
+      super + [:array]
+    end if AR4_COMPAT
+    
+    def add_column_options!(sql, options)
+      if options[:array] || options[:column].try(:array)
+        sql << '[]'
+      end
+
+      column = options.fetch(:column) { return super }
+      if column.type == :uuid && options[:default] =~ /\(\)/
+        sql << " DEFAULT #{options[:default]}"
+      else
+        super
+      end
+    end if AR4_COMPAT
+    
+    # Enable standard-conforming strings if available.
+    def set_standard_conforming_strings # native adapter API compatibility
+      self.standard_conforming_strings=(true)
+    end
+    
     # Enable standard-conforming strings if available.
     def standard_conforming_strings=(enable)
       client_min_messages = self.client_min_messages
@@ -269,14 +572,27 @@ module ::ArJdbc
       true
     end
 
+    def supports_transaction_isolation? # :nodoc:
+      true
+    end
+    
     def supports_index_sort_order? # :nodoc:
       true
     end
     
+    # Range datatypes weren't introduced until PostgreSQL 9.2
+    def supports_ranges? # :nodoc:
+      postgresql_version >= 90200
+    end if AR4_COMPAT
+    
     def supports_savepoints? # :nodoc:
       true
     end
     
+    def supports_transaction_isolation?(level = nil)
+      true
+    end
+    
     def create_savepoint
       execute("SAVEPOINT #{current_savepoint_name}")
     end
@@ -288,11 +604,48 @@ module ::ArJdbc
     def release_savepoint
       execute("RELEASE SAVEPOINT #{current_savepoint_name}")
     end
+    
+    def supports_extensions? # :nodoc:
+      postgresql_version >= 90200
+    end # NOTE: only since AR-4.0 but should not hurt on other versions
+    
+    def enable_extension(name)
+      execute("CREATE EXTENSION IF NOT EXISTS \"#{name}\"")
+    end
+
+    def disable_extension(name)
+      execute("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE")
+    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')
+        rows.first.first
+      end
+    end
+
+    def extensions
+      if supports_extensions?
+        rows = select_rows "SELECT extname from pg_extension", "SCHEMA"
+        rows.map { |row| row.first }
+      else
+        []
+      end
+    end
+    
+    # Set the authorized user for this session
+    def session_auth=(user)
+      execute "SET SESSION AUTHORIZATION #{user}"
+    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)
+      @table_alias_length ||= (
+        postgresql_version >= 80000 ? 
+          select_one('SHOW max_identifier_length')['max_identifier_length'].to_i : 
+            63
+      )
     end
 
     def default_sequence_name(table_name, pk = nil)
@@ -302,21 +655,16 @@ module ::ArJdbc
 
     # 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
+      if ! pk || ! sequence
         default_pk, default_sequence = pk_and_sequence_for(table)
-        pk ||= default_pk
-        sequence ||= default_sequence
+        pk ||= default_pk; sequence ||= default_sequence
       end
-      if pk
-        if sequence
-          quoted_sequence = quote_column_name(sequence)
+      if pk && 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
+        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
       end
     end
 
@@ -324,7 +672,7 @@ module ::ArJdbc
     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]
+      result = select(<<-end_sql, 'PK and Serial Sequence')[0]
           SELECT attr.attname, seq.relname
           FROM pg_class      seq,
                pg_attribute  attr,
@@ -341,11 +689,11 @@ module ::ArJdbc
             AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
         end_sql
 
-      if result.nil? or result.empty?
+      if result.nil? || 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]
+        result = select(<<-end_sql, 'PK and Custom Sequence')[0]
             SELECT attr.attname,
               CASE
                 WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
@@ -363,43 +711,36 @@ module ::ArJdbc
           end_sql
       end
 
-      [result["attname"], result["relname"]]
+      [ result['attname'], result['relname'] ]
     rescue
       nil
     end
-
-    # Insert logic for pre-AR-3.1 adapters
+    
     def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-      # 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
-          sql = to_sql(sql, binds)
-          return select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-        end
+      unless pk
+        # Extract the table from the insert sql. Yuck.
+        table_ref = extract_table_ref_from_insert_sql(sql)
+        pk = primary_key(table_ref) if table_ref
       end
 
-      # Otherwise, plain insert
-      execute(sql, name, binds)
-
-      # 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
-
-        # 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)
+      if pk && use_insert_returning? # && id_value.nil?
+        select_value("#{to_sql(sql, binds)} RETURNING #{quote_column_name(pk)}")
+      else
+        execute(sql, name, binds) # super
+        unless id_value
+          table_ref ||= extract_table_ref_from_insert_sql(sql)
+          # If neither PK nor sequence name is given, look them up.
+          if table_ref && ! ( pk ||= primary_key(table_ref) ) && ! sequence_name
+            pk, sequence_name = pk_and_sequence_for(table_ref)
+          end
+          # 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_ref, pk)
+            id_value = last_insert_id(table_ref, sequence_name)
+          end
         end
+        id_value
       end
-      id_value
     end
     
     # taken from rails postgresql_adapter.rb
@@ -411,138 +752,163 @@ module ::ArJdbc
 
       sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
 
-      [sql, binds]
+      [ sql, binds ]
     end
     
     def primary_key(table)
-      pk_and_sequence = pk_and_sequence_for(table)
-      pk_and_sequence && pk_and_sequence.first
+      result = select(<<-end_sql, 'SCHEMA').first
+        SELECT attr.attname
+        FROM pg_attribute attr
+        INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]
+        WHERE cons.contype = 'p'
+          AND cons.conrelid = '#{quote_table_name(table)}'::regclass
+      end_sql
+      
+      result && result["attname"]
+      # pk_and_sequence = pk_and_sequence_for(table)
+      # pk_and_sequence && pk_and_sequence.first
     end
-
-    def pg_columns(table_name, name=nil)
-      column_definitions(table_name).map do |row|
-        ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new(
-          row["column_name"], row["column_default"], row["column_type"],
-          row["column_not_null"] == "f")
-      end
+    
+    # Returns an array of schema names.
+    def schema_names
+      select_values(
+        "SELECT nspname FROM pg_namespace" <<
+        " WHERE nspname !~ '^pg_.*' AND nspname NOT IN ('information_schema')" <<
+        " ORDER by nspname;", 
+      'SCHEMA')
     end
-
+        
+    # Returns true if schema exists.
+    def schema_exists?(name)
+      select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", 'SCHEMA').to_i > 0
+    end
+    
+    # Returns the current schema name.
+    def current_schema
+      select_value('SELECT current_schema', 'SCHEMA')
+    end
+    
     # current database name
     def current_database
-      exec_query("select current_database() as database").
-        first["database"]
+      select_value('SELECT current_database()', 'SCHEMA')
     end
 
-    # current database encoding
+    # Returns the current database encoding format.
     def encoding
-      exec_query(<<-end_sql).first["encoding"]
-        SELECT pg_encoding_to_char(pg_database.encoding) as encoding
-        FROM pg_database
-        WHERE pg_database.datname LIKE '#{current_database}'
-      end_sql
+      select_value(
+        "SELECT pg_encoding_to_char(pg_database.encoding)" << 
+        " FROM pg_database" << 
+        " WHERE pg_database.datname LIKE '#{current_database}'", 
+      'SCHEMA')
     end
 
-    # Sets the maximum number columns postgres has, default 32
-    def multi_column_index_limit=(limit)
-      @multi_column_index_limit = limit
+    # Returns the current database collation.
+    def collation
+      select_value(
+        "SELECT pg_database.datcollate" << 
+        " FROM pg_database" << 
+        " WHERE pg_database.datname LIKE '#{current_database}'",
+      'SCHEMA')
     end
-
-    # Gets the maximum number columns postgres has, default 32
-    def multi_column_index_limit
-      defined?(@multi_column_index_limit) && @multi_column_index_limit || 32
+    
+    # Returns the current database ctype.
+    def ctype
+      select_value(
+        "SELECT pg_database.datctype FROM pg_database WHERE pg_database.datname LIKE '#{current_database}'",
+      'SCHEMA')
     end
 
-    # Based on postgresql_adapter.rb
-    def indexes(table_name, name = nil)
-      schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
-      result = select_rows(<<-SQL, name)
-        SELECT i.relname, d.indisunique, a.attname, a.attnum, d.indkey
-          FROM pg_class t, pg_class i, pg_index d, pg_attribute a,
-          generate_series(0,#{multi_column_index_limit - 1}) AS s(i)
-         WHERE i.relkind = 'i'
-           AND d.indexrelid = i.oid
-           AND d.indisprimary = 'f'
-           AND t.oid = d.indrelid
-           AND t.relname = '#{table_name}'
-           AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
-           AND a.attrelid = t.oid
-           AND d.indkey[s.i]=a.attnum
-        ORDER BY i.relname
-      SQL
-
-      current_index = nil
-      indexes = []
-
-      insertion_order = []
-      index_order = nil
-
-      result.each do |row|
-        if current_index != row[0]
-
-          (index_order = row[4].split(' ')).each_with_index{ |v, i| index_order[i] = v.to_i }
-          indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, row[0], row[1] == "t", [])
-          current_index = row[0]
-        end
-        insertion_order = row[3]
-        ind = index_order.index(insertion_order)
-        indexes.last.columns[ind] = row[2]
+    # Returns the active schema search path.
+    def schema_search_path
+      @schema_search_path ||= select_value('SHOW search_path', 'SCHEMA')
+    end
+    
+    # Sets the schema search path to a string of comma-separated schema names.
+    # Names beginning with $ have to be quoted (e.g. $user => '$user').
+    # See: http://www.postgresql.org/docs/current/static/ddl-schemas.html
+    #
+    # This should be not be called manually but set in database.yml.
+    def schema_search_path=(schema_csv)
+      if schema_csv
+        execute "SET search_path TO #{schema_csv}"
+        @schema_search_path = schema_csv
       end
-
-      indexes
     end
 
     # take id from result of insert query
     def last_inserted_id(result)
-      if result.is_a? Fixnum
+      if result.is_a? Integer
         result
       else
         result.first.first[1]
       end
     end
 
-    def last_insert_id(table, sequence_name)
-      Integer(select_value("SELECT currval('#{sequence_name}')"))
+    def last_insert_id(table, sequence_name = nil)
+      sequence_name = table if sequence_name.nil? # AR-4.0 1 argument
+      Integer(select_value("SELECT currval('#{sequence_name}')", 'SQL'))
     end
-
+    
     def recreate_database(name, options = {})
       drop_database(name)
       create_database(name, options)
     end
-
+    
+    # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
+    # <tt>:encoding</tt>, <tt>:collation</tt>, <tt>:ctype</tt>,
+    # <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL uses
+    # <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
+    #
+    # Example:
+    # create_database config[:database], config
+    # create_database 'foo_development', encoding: 'unicode'
     def create_database(name, options = {})
-      options = options.with_indifferent_access
-      create_query = "CREATE DATABASE \"#{name}\" ENCODING='#{options[:encoding] || 'utf8'}'"
-      create_query += options.symbolize_keys.sum('') do |key, value|
+      options = { :encoding => 'utf8' }.merge!(options.symbolize_keys)
+
+      option_string = options.sum do |key, value|
         case key
-          when :owner
-            " OWNER = \"#{value}\""
-          when :template
-            " TEMPLATE = \"#{value}\""
-          when :tablespace
-            " TABLESPACE = \"#{value}\""
-          when :connection_limit
-            " CONNECTION LIMIT = #{value}"
-          else
-            ""
+        when :owner
+          " OWNER = \"#{value}\""
+        when :template
+          " TEMPLATE = \"#{value}\""
+        when :encoding
+          " ENCODING = '#{value}'"
+        when :collation
+          " LC_COLLATE = '#{value}'"
+        when :ctype
+          " LC_CTYPE = '#{value}'"
+        when :tablespace
+          " TABLESPACE = \"#{value}\""
+        when :connection_limit
+          " CONNECTION LIMIT = #{value}"
+        else
+          ""
         end
       end
-      execute create_query
+
+      execute "CREATE DATABASE #{quote_table_name(name)}#{option_string}"
     end
 
     def drop_database(name)
-      execute "DROP DATABASE IF EXISTS \"#{name}\""
+      execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
     end
 
-    def create_schema(schema_name, pg_username)
-      execute("CREATE SCHEMA \"#{schema_name}\" AUTHORIZATION \"#{pg_username}\"")
+    # Creates a schema for the given schema name.
+    def create_schema(schema_name, pg_username = nil)
+      if pg_username.nil? # AR 4.0 compatibility - accepts only single argument
+        execute "CREATE SCHEMA #{schema_name}"
+      else
+        execute("CREATE SCHEMA \"#{schema_name}\" AUTHORIZATION \"#{pg_username}\"")
+      end
     end
 
-    def drop_schema(schema_name)
-      execute("DROP SCHEMA \"#{schema_name}\"")
+    # Drops the schema for the given schema name.
+    def drop_schema schema_name
+      execute "DROP SCHEMA #{schema_name} CASCADE"
     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 structure_dump
@@ -572,31 +938,9 @@ module ::ArJdbc
       end
     end
 
-    # Sets the schema search path to a string of comma-separated schema names.
-    # Names beginning with $ have to be quoted (e.g. $user => '$user').
-    # See: http://www.postgresql.org/docs/current/static/ddl-schemas.html
-    #
-    # This should be not be called manually but set in database.yml.
-    def schema_search_path=(schema_csv)
-      if schema_csv
-        execute "SET search_path TO #{schema_csv}"
-        @schema_search_path = schema_csv
-      end
-    end
-
-    # Returns the active schema search path.
-    def schema_search_path
-      @schema_search_path ||= exec_query('SHOW search_path', 'SCHEMA')[0]['search_path']
-    end
-
-    # Returns the current schema name.
-    def current_schema
-      exec_query('SELECT current_schema', 'SCHEMA')[0]["current_schema"]
-    end
-
     # Returns the current client message level.
     def client_min_messages
-      exec_query('SHOW client_min_messages', 'SCHEMA')[0]['client_min_messages']
+      select_value('SHOW client_min_messages', 'SCHEMA')
     end
 
     # Set the client message level.
@@ -604,6 +948,16 @@ module ::ArJdbc
       execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
     end
 
+    # Gets the maximum number columns postgres has, default 32
+    def multi_column_index_limit
+      defined?(@multi_column_index_limit) && @multi_column_index_limit || 32
+    end
+    
+    # Sets the maximum number columns postgres has, default 32
+    def multi_column_index_limit=(limit)
+      @multi_column_index_limit = limit
+    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
@@ -637,22 +991,33 @@ module ::ArJdbc
       sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
     end
 
-    # from postgres_adapter.rb in rails project
-    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L412
-    # Quotes PostgreSQL-specific data types for SQL input.
     def quote(value, column = nil) #:nodoc:
       return super unless column
 
+      # TODO recent 4.0 (master) seems to be passing a ColumnDefinition here :
+      #   NoMethodError: undefined method `sql_type' for #<ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ColumnDefinition:0x634f6b>
+      # .../activerecord-jdbc-adapter/lib/arjdbc/postgresql/adapter.rb:1014:in `quote'
+      # .../gems/rails-817e8fad5a84/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb:698:in `add_column_options!'
+      # .../activerecord-jdbc-adapter/lib/arjdbc/postgresql/adapter.rb:507:in `add_column_options!'
+      # .../gems/rails-817e8fad5a84/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb:168:in `add_column_options!'
+      # .../gems/rails-817e8fad5a84/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb:135:in `visit_ColumnDefinition'
+      sql_type = column.sql_type rescue nil
+      
       case value
       when Float
-        return super unless value.infinite? && column.type == :datetime
-        "'#{value.to_s.downcase}'"
+        if value.infinite? && column.type == :datetime
+          "'#{value.to_s.downcase}'"
+        elsif value.infinite? || value.nan?
+          "'#{value.to_s}'"
+        else
+          super
+        end
       when Numeric
-        return super unless column.sql_type == 'money'
+        return super unless sql_type == 'money'
         # Not truly string input, so doesn't require (or allow) escape string syntax.
-        "'#{value}'"
+        ( column.type == :string || column.type == :text ) ? "'#{value}'" : super
       when String
-        case column.sql_type
+        case sql_type
         when 'bytea' then "E'#{escape_bytea(value)}'::bytea" # "'#{escape_bytea(value)}'"
         when 'xml'   then "xml '#{quote_string(value)}'"
         when /^bit/
@@ -669,6 +1034,35 @@ module ::ArJdbc
         else
           super
         end
+      when Array
+        if column.array && AR4_COMPAT
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          "'#{column_class.array_to_string(value, column, self)}'"
+        else
+          super
+        end
+      when Hash
+        if sql_type == 'hstore' && AR4_COMPAT
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          super(column_class.hstore_to_string(value), column)
+        elsif sql_type == 'json' && AR4_COMPAT
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          super(column_class.json_to_string(value), column)
+        else super
+        end
+      when Range
+        if /range$/ =~ sql_type && AR4_COMPAT
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          "'#{column_class.range_to_string(value)}'::#{sql_type}"
+        else
+          super
+        end
+      when IPAddr
+        if (sql_type == 'inet' || sql_type == 'cidr') && AR4_COMPAT
+          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+          super(column_class.cidr_to_string(value), column)
+        else super
+        end
       else
         super
       end
@@ -711,30 +1105,50 @@ module ::ArJdbc
       %("#{name.to_s.gsub("\"", "\"\"")}")
     end
     
+    # Quote date/time values for use in SQL input. 
+    # Includes microseconds if the value is a Time responding to usec.
     def quoted_date(value) #:nodoc:
+      result = super
       if value.acts_like?(:time) && value.respond_to?(:usec)
-        "#{super}.#{sprintf("%06d", value.usec)}"
-      else
-        super
+        "#{result}.#{sprintf("%06d", value.usec)}"
       end
+      result = "#{result.sub(/^-/, '')} BC" if value.year < 0
+      result
+    end
+    
+    def supports_disable_referential_integrity? # :nodoc:
+      true
     end
 
     def disable_referential_integrity # :nodoc:
-      execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
+      if supports_disable_referential_integrity?
+        begin
+          execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
+        rescue
+          execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER USER" }.join(";"))
+        end
+      end
       yield
     ensure
-      execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+      if supports_disable_referential_integrity?
+        begin
+          execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
+        rescue
+          execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER USER" }.join(";"))
+        end
+      end
     end
 
-    def rename_table(name, new_name)
-      execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+    def rename_table(table_name, new_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
       pk, seq = pk_and_sequence_for(new_name)
-      if seq == "#{name}_#{pk}_seq"
+      if seq == "#{table_name}_#{pk}_seq"
         new_seq = "#{new_name}_#{pk}_seq"
         execute "ALTER TABLE #{quote_table_name(seq)} RENAME TO #{quote_table_name(new_seq)}"
       end
+      rename_table_indexes(table_name, new_name) if respond_to?(:rename_table_indexes) # AR-4.0 SchemaStatements
     end
-
+    
     # Adds a new column to the named table.
     # See TableDefinition#column for details of the options you can use.
     def add_column(table_name, column_name, type, options = {})
@@ -786,8 +1200,9 @@ module ::ArJdbc
       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:
+    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)}"
+      rename_column_indexes(table_name, column_name, new_column_name) if respond_to?(:rename_column_indexes) # AR-4.0 SchemaStatements
     end
 
     def remove_index!(table_name, index_name) #:nodoc:
@@ -798,64 +1213,128 @@ module ::ArJdbc
       63
     end
 
-    # Maps logical Rails types to PostgreSQL-specific data types.
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-      case type.to_sym
-      when :integer
-        return 'integer' unless limit
-        case limit.to_i
-          when 1, 2; 'smallint'
-          when 3, 4; 'integer'
-          when 5..8; 'bigint'
-          else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
-        end
-      when :binary
-        super(type, nil, nil, nil)
-      else
-        super
+    # Returns the list of all column definitions for a table.
+    def columns(table_name, name = nil)
+      klass = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+      column_definitions(table_name).map do |row|
+        # name, type, default, notnull, oid, fmod
+        name = row[0]; type = row[1]; default = row[2]
+        notnull = row[3]; oid = row[4]; fmod = row[5]
+        # oid = OID::TYPE_MAP.fetch(oid.to_i, fmod.to_i) { OID::Identity.new }
+        notnull = notnull == 't' if notnull.is_a?(String) # JDBC gets true/false
+        # for ID columns we get a bit of non-sense default :
+        # e.g. "nextval('mixed_cases_id_seq'::regclass"
+        default = nil if default =~ /^nextval\(.*?\:\:regclass\)$/
+        klass.new(name, default, oid, type, ! notnull)
       end
     end
     
+    # 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) #:nodoc:
+      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
+          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 tables(name = nil)
-      exec_query(<<-SQL, 'SCHEMA').map { |row| row["tablename"] }
-          SELECT tablename
-          FROM pg_tables
-          WHERE schemaname = ANY (current_schemas(false))
+      select_values(<<-SQL, 'SCHEMA')
+        SELECT tablename
+        FROM pg_tables
+        WHERE schemaname = ANY (current_schemas(false))
       SQL
     end
 
     def table_exists?(name)
       schema, table = extract_schema_and_table(name.to_s)
-      return false unless table # Abstract classes is having nil table name
-
-      binds = [[nil, table.gsub(/(^"|"$)/,'')]]
-      binds << [nil, schema] if schema
-
-      exec_query(<<-SQL, 'SCHEMA', binds).first["table_count"] > 0
-          SELECT COUNT(*) as table_count
-          FROM pg_tables
-          WHERE tablename = ?
-          AND schemaname = #{schema ? "?" : "ANY (current_schemas(false))"}
+      return false unless table # abstract classes - nil table name
+
+      binds = [[ nil, table.gsub(/(^"|"$)/,'') ]]
+      binds << [ nil, schema ] if schema
+      
+      exec_query_raw(<<-SQL, 'SCHEMA', binds).first["table_count"] > 0
+        SELECT COUNT(*) as table_count
+        FROM pg_tables
+        WHERE tablename = ?
+        AND schemaname = #{schema ? "?" : "ANY (current_schemas(false))"}
       SQL
     end
-
-    # Extracts the table and schema name from +name+
-    def extract_schema_and_table(name)
-      schema, table = name.split('.', 2)
-
-      unless table # A table was provided without a schema
-        table  = schema
-        schema = nil
+    
+    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition # :nodoc:
+    if ActiveRecord::VERSION::MAJOR < 3 || 
+        ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 )
+      # NOTE: make sure we accept 6 arguments (>= 3.2) as well as 5 (<= 3.1) :
+      # allow 6 on 3.1 : Struct.new(:table, :name, :unique, :columns, :lengths)
+      IndexDefinition.class_eval do
+        def initialize(table, name, unique = nil, columns = nil, lengths = nil, orders = nil)
+          super(table, name, unique, columns, lengths) # @see {#indexes}
+        end
       end
+    end
+    
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, name = nil)
+      # NOTE: maybe it's better to leave things of to the JDBC API ?!
+      result = select_rows(<<-SQL, 'SCHEMA')
+        SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
+        FROM pg_class t
+        INNER JOIN pg_index d ON t.oid = d.indrelid
+        INNER JOIN pg_class i ON d.indexrelid = i.oid
+        WHERE i.relkind = 'i'
+        AND d.indisprimary = 'f'
+        AND t.relname = '#{table_name}'
+        AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+        ORDER BY i.relname
+      SQL
+      
+      result.map! do |row|
+        index_name = row[0]
+        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(" ")
+        inddef = row[3]
+        oid = row[4]
+
+        columns = select_rows(<<-SQL, "SCHEMA")
+          SELECT a.attnum, a.attname
+          FROM pg_attribute a
+          WHERE a.attrelid = #{oid}
+          AND a.attnum IN (#{indkey.join(",")})
+        SQL
+        
+        columns = Hash[ columns.each { |column| column[0] = column[0].to_s } ]
+        column_names = columns.values_at(*indkey).compact
 
-      if name =~ /^"/ # Handle quoted table names
-        table  = name
-        schema = nil
+        # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+        desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
+        orders = desc_order_columns.any? ? Hash[ desc_order_columns.map { |column| [column, :desc] } ] : {}
+        
+        column_names.empty? ? nil : IndexDefinition.new(table_name, index_name, unique, column_names, [], orders)
       end
-      [schema, table]
+      result.compact!
+      result
     end
 
+    # #override due RETURNING clause - can't do an {#execute_insert}
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
+      execute(sql, name, binds)
+    end
+    
     private
+    
     def translate_exception(exception, message)
       case exception.message
       when /duplicate key value violates unique constraint/
@@ -866,42 +1345,29 @@ module ::ArJdbc
         super
       end
     end
+    
+    # Extracts the table and schema name from +name+
+    def extract_schema_and_table(name)
+      schema, table = name.split('.', 2)
 
-    # Returns the list of a table's column names, data types, and default values.
-    #
-    # The underlying query is roughly:
-    #  SELECT column.name, column.type, default.value
-    #    FROM column LEFT JOIN default
-    #      ON column.table_id = default.table_id
-    #     AND column.num = default.column_num
-    #   WHERE column.table_id = get_table_id('table_name')
-    #     AND column.num > 0
-    #     AND NOT column.is_dropped
-    #   ORDER BY column.num
-    #
-    # 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) #:nodoc:
-      exec_query(<<-end_sql, 'SCHEMA')
-            SELECT a.attname as column_name, format_type(a.atttypid, a.atttypmod) as column_type, d.adsrc as column_default, a.attnotnull as column_not_null
-              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
+      unless table # A table was provided without a schema
+        table  = schema
+        schema = nil
+      end
+
+      if name =~ /^"/ # Handle quoted table names
+        table  = name
+        schema = nil
+      end
+      [schema, table]
     end
 
     def extract_pg_identifier_from_name(name)
-      match_data = name[0,1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
+      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] == "."
+        rest = rest[1..-1] if rest[0, 1] == "."
         [match_data[1], (rest.length > 0 ? rest : nil)]
       end
     end
@@ -910,75 +1376,193 @@ module ::ArJdbc
     def extract_table_ref_from_insert_sql(sql) # :nodoc:
       sql[/into\s+([^\(]*).*values\s*\(/i]
       $1.strip if $1
+      # sql.split(" ", 4)[2].gsub('"', '')
     end
     
   end
 end
 
 module ActiveRecord::ConnectionAdapters
-  remove_const(:PostgreSQLAdapter) if const_defined?(:PostgreSQLAdapter)
+  
+  PostgreSQLJdbcConnection.class_eval do
+    
+    # alias :java_native_database_types :set_native_database_types
+    
+    # @override to prevent connection from loading hash from JDBC meta-data, 
+    # which can be expensive. We can do this since {#native_database_types} is 
+    # defined in the adapter to use a hash not relying on driver's meta-data
+    def set_native_database_types; @native_types = {}; end
+    
+  end
+  
+  remove_const(:PostgreSQLColumn) if const_defined?(:PostgreSQLColumn)
 
   class PostgreSQLColumn < JdbcColumn
     include ArJdbc::PostgreSQL::Column
-
-    def initialize(name, *args)
-      if Hash === name
-        super
+    
+    def initialize(name, default, oid_type, sql_type = nil, null = true)
+      @oid_type = oid_type
+      if sql_type =~ /\[\]$/
+        @array = true
+        super(name, default, sql_type[0..sql_type.length - 3], null)
       else
-        super(nil, name, *args)
+        @array = false
+        super(name, default, sql_type, null)
       end
     end
-
-    def call_discovered_column_callbacks(*)
-    end
-  end
-
-  class PostgresJdbcConnection < JdbcConnection
-    alias :java_native_database_types :set_native_database_types
-
-    # override to prevent connection from loading hash from jdbc
-    # metadata, which can be expensive. We can do this since
-    # native_database_types is defined in the adapter to use a static hash
-    # not relying on the driver's metadata
-    def set_native_database_types
-      @native_types = {}
-    end
+        
   end
 
+  remove_const(:PostgreSQLAdapter) if const_defined?(:PostgreSQLAdapter)
+  
   class PostgreSQLAdapter < JdbcAdapter
     include ArJdbc::PostgreSQL
     include ArJdbc::PostgreSQL::ExplainSupport
 
     def initialize(*args)
       super
+      
+      # @local_tz is initialized as nil to avoid warnings when connect tries to use it
+      @local_tz = nil
+      @table_alias_length = nil
+      
       configure_connection
+
+      @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
+      @use_insert_returning = config.key?(:insert_returning) ? 
+        self.class.type_cast_config_to_boolean(config[:insert_returning]) : nil
     end
 
-    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+    class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+      attr_accessor :array
+    end
+
+    module ColumnMethods
       def xml(*args)
         options = args.extract_options!
-        column(args[0], "xml", options)
+        column(args[0], 'xml', options)
       end
 
       def tsvector(*args)
         options = args.extract_options!
-        column(args[0], "tsvector", options)
+        column(args[0], 'tsvector', options)
+      end
+
+      def int4range(name, options = {})
+        column(name, 'int4range', options)
+      end
+
+      def int8range(name, options = {})
+        column(name, 'int8range', options)
+      end
+
+      def tsrange(name, options = {})
+        column(name, 'tsrange', options)
+      end
+
+      def tstzrange(name, options = {})
+        column(name, 'tstzrange', options)
+      end
+
+      def numrange(name, options = {})
+        column(name, 'numrange', options)
+      end
+
+      def daterange(name, options = {})
+        column(name, 'daterange', options)
+      end
+
+      def hstore(name, options = {})
+        column(name, 'hstore', options)
+      end
+
+      def ltree(name, options = {})
+        column(name, 'ltree', options)
+      end
+
+      def inet(name, options = {})
+        column(name, 'inet', options)
+      end
+
+      def cidr(name, options = {})
+        column(name, 'cidr', options)
+      end
+
+      def macaddr(name, options = {})
+        column(name, 'macaddr', options)
+      end
+
+      def uuid(name, options = {})
+        column(name, 'uuid', options)
+      end
+
+      def json(name, options = {})
+        column(name, 'json', options)
       end
     end
 
-    def table_definition
-      TableDefinition.new(self)
+    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      include ColumnMethods
+      
+      def primary_key(name, type = :primary_key, options = {})
+        return super unless type == :uuid
+        options[:default] ||= 'uuid_generate_v4()'
+        options[:primary_key] = true
+        column name, type, options
+      end if ActiveRecord::VERSION::MAJOR > 3 # 3.2 super expects (name)
+      
+      def column(name, type = nil, options = {})
+        super
+        column = self[name]
+        # NOTE: <= 3.1 no #new_column_definition hard-coded ColumnDef.new :
+        # column = self[name] || ColumnDefinition.new(@base, name, type)
+        # thus we simply do not support array column definitions on <= 3.1
+        if column.is_a?(ColumnDefinition)
+          column.array = options[:array]
+        end
+        self
+      end
+
+      private
+
+      if ActiveRecord::VERSION::MAJOR > 3
+        
+        def create_column_definition(name, type)
+          ColumnDefinition.new name, type
+        end
+        
+      else # no #create_column_definition on 3.2
+        
+        def new_column_definition(base, name, type)
+          definition = ColumnDefinition.new base, name, type
+          @columns << definition
+          @columns_hash[name] = definition
+          definition
+        end
+        
+      end
+      
     end
 
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
+    end
+    
+    class Table < ActiveRecord::ConnectionAdapters::Table
+      include ColumnMethods
+    end
+
+    def update_table_definition(table_name, base)
+      Table.new(table_name, base)
+    end if ActiveRecord::VERSION::MAJOR > 3
+    
     def jdbc_connection_class(spec)
       ::ArJdbc::PostgreSQL.jdbc_connection_class
     end
 
     def jdbc_column_class
-      ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+      ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
     end
-
-    alias_chained_method :columns, :query_cache, :pg_columns
     
     # some QUOTING caching :
     
@@ -1006,4 +1590,4 @@ module ActiveRecord::ConnectionAdapters
 end
 
 # Don't need to load native postgres adapter
-$LOADED_FEATURES << 'active_record/connection_adapters/postgresql_adapter.rb'
+$LOADED_FEATURES << 'active_record/connection_adapters/postgresql_adapter.rb'