activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,12 +1,15 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/statement_pool'
+
+require 'active_record/connection_adapters/postgresql/utils'
+require 'active_record/connection_adapters/postgresql/column'
 require 'active_record/connection_adapters/postgresql/oid'
-require 'active_record/connection_adapters/postgresql/cast'
-require 'active_record/connection_adapters/postgresql/array_parser'
 require 'active_record/connection_adapters/postgresql/quoting'
+require 'active_record/connection_adapters/postgresql/referential_integrity'
+require 'active_record/connection_adapters/postgresql/schema_definitions'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/database_statements'
-require 'active_record/connection_adapters/postgresql/referential_integrity'
+
 require 'arel/visitors/bind_visitor'
 
 # Make sure we're using pg high enough for PGResult#values
@@ -43,222 +46,6 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    # PostgreSQL-specific extensions to column definitions in a table.
-    class PostgreSQLColumn < Column #:nodoc:
-      attr_accessor :array
-
-      def initialize(name, default, oid_type, sql_type = nil, null = true)
-        @oid_type = oid_type
-        default_value     = self.class.extract_value_from_default(default)
-
-        if sql_type =~ /\[\]$/
-          @array = true
-          super(name, default_value, sql_type[0..sql_type.length - 3], null)
-        else
-          @array = false
-          super(name, default_value, sql_type, null)
-        end
-
-        @default_function = default if has_default_function?(default_value, default)
-      end
-
-      def number?
-        !array && super
-      end
-
-      def text?
-        !array && super
-      end
-
-      # :stopdoc:
-      class << self
-        include ConnectionAdapters::PostgreSQLColumn::Cast
-        include ConnectionAdapters::PostgreSQLColumn::ArrayParser
-        attr_accessor :money_precision
-      end
-      # :startdoc:
-
-      # Extracts the value from a PostgreSQL column default definition.
-      def self.extract_value_from_default(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
-          when /\A'(.*)'::(num|date|tstz|ts|int4|int8)range\z/m
-            $1
-          # Numeric types
-          when /\A\(?(-?\d+(\.\d*)?\)?(::bigint)?)\z/
-            $1
-          # Character types
-          when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m
-            $1.gsub(/''/, "'")
-          # Binary data types
-          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
-          # Boolean type
-          when 'true'
-            true
-          when 'false'
-            false
-          # Geometric types
-          when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
-            $1
-          # Network address types
-          when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
-            $1
-          # Bit string types
-          when /\AB'(.*)'::"?bit(?: varying)?"?\z/
-            $1
-          # XML type
-          when /\A'(.*)'::xml\z/m
-            $1
-          # Arrays
-          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
-        end
-      end
-
-      def type_cast_for_write(value)
-        if @oid_type.respond_to?(:type_cast_for_write)
-          @oid_type.type_cast_for_write(value)
-        else
-          super
-        end
-      end
-
-      def type_cast(value)
-        return if value.nil?
-        return super if encoded?
-
-        @oid_type.type_cast value
-      end
-
-      def accessor
-        @oid_type.accessor
-      end
-
-      private
-
-        def has_default_function?(default_value, default)
-          !default_value && (%r{\w+\(.*\)} === default)
-        end
-
-        def extract_limit(sql_type)
-          case sql_type
-          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.
-          sql_type =~ /^money/ ? 2 : super
-        end
-
-        # Extracts the precision from PostgreSQL-specific data types.
-        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
-          # Numeric and monetary types
-          when /^(?:real|double precision)$/
-            :float
-          # Monetary types
-          when 'money'
-            :decimal
-          when 'hstore'
-            :hstore
-          when 'ltree'
-            :ltree
-          # Network address types
-          when 'inet'
-            :inet
-          when 'cidr'
-            :cidr
-          when 'macaddr'
-            :macaddr
-          # Character types
-          when /^(?:character varying|bpchar)(?:\(\d+\))?$/
-            :string
-          # Binary data types
-          when 'bytea'
-            :binary
-          # Date/time types
-          when /^timestamp with(?:out)? time zone$/
-            :datetime
-          when /^interval(?:|\(\d+\))$/
-            :string
-          # Geometric types
-          when /^(?:point|line|lseg|box|"?path"?|polygon|circle)$/
-            :string
-          # Bit strings
-          when /^bit(?: varying)?(?:\(\d+\))?$/
-            :string
-          # XML type
-          when 'xml'
-            :xml
-          # tsvector type
-          when 'tsvector'
-            :tsvector
-          # Arrays
-          when /^\D+\[\]$/
-            :string
-          # Object identifier types
-          when 'oid'
-            :integer
-          # UUID type
-          when 'uuid'
-            :uuid
-          # JSON type
-          when 'json'
-            :json
-          # Small and big integer types
-          when /^(?:small|big)int$/
-            :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
-    end
-
     # The PostgreSQL adapter works with the native C (https://bitbucket.org/ged/ruby-pg) driver.
     #
     # Options:
@@ -287,142 +74,16 @@ module ActiveRecord
     # In addition, default connection parameters of libpq can be set per environment variables.
     # See http://www.postgresql.org/docs/9.1/static/libpq-envars.html .
     class PostgreSQLAdapter < AbstractAdapter
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-        attr_accessor :array
-      end
-
-      module ColumnMethods
-        def xml(*args)
-          options = args.extract_options!
-          column(args[0], 'xml', options)
-        end
-
-        def tsvector(*args)
-          options = args.extract_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
-
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ColumnMethods
-
-        # Defines the primary key field.
-        # Use of the native PostgreSQL UUID type is supported, and can be used
-        # by defining your tables as such:
-        #
-        #   create_table :stuffs, id: :uuid do |t|
-        #     t.string :content
-        #     t.timestamps
-        #   end
-        #
-        # By default, this will use the +uuid_generate_v4()+ function from the
-        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
-        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
-        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
-        # set the +:default+ option to +nil+:
-        #
-        #   create_table :stuffs, id: false do |t|
-        #     t.primary_key :id, :uuid, default: nil
-        #     t.uuid :foo_id
-        #     t.timestamps
-        #   end
-        #
-        # You may also pass a different UUID generation function from +uuid-ossp+
-        # or another library.
-        #
-        # Note that setting the UUID primary key default value to +nil+ will
-        # require you to assure that you always provide a UUID value before saving
-        # a record (as primary keys cannot be +nil+). This might be done via the
-        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
-        def primary_key(name, type = :primary_key, options = {})
-          return super unless type == :uuid
-          options[:default] = options.fetch(:default, 'uuid_generate_v4()')
-          options[:primary_key] = true
-          column name, type, options
-        end
-
-        def column(name, type = nil, options = {})
-          super
-          column = self[name]
-          column.array = options[:array]
-
-          self
-        end
-
-        private
-
-          def create_column_definition(name, type)
-            ColumnDefinition.new name, type
-          end
-      end
-
-      class Table < ActiveRecord::ConnectionAdapters::Table
-        include ColumnMethods
-      end
-
       ADAPTER_NAME = 'PostgreSQL'
 
       NATIVE_DATABASE_TYPES = {
         primary_key: "serial primary key",
-        string:      { name: "character varying", limit: 255 },
+        string:      { name: "character varying" },
         text:        { name: "text" },
         integer:     { name: "integer" },
         float:       { name: "float" },
         decimal:     { name: "decimal" },
         datetime:    { name: "timestamp" },
-        timestamp:   { name: "timestamp" },
         time:        { name: "time" },
         date:        { name: "date" },
         daterange:   { name: "daterange" },
@@ -441,13 +102,20 @@ module ActiveRecord
         macaddr:     { name: "macaddr" },
         uuid:        { name: "uuid" },
         json:        { name: "json" },
-        ltree:       { name: "ltree" }
+        ltree:       { name: "ltree" },
+        citext:      { name: "citext" },
+        point:       { name: "point" },
+        bit:         { name: "bit" },
+        bit_varying: { name: "bit varying" },
+        money:       { name: "money" },
       }
 
-      include Quoting
-      include ReferentialIntegrity
-      include SchemaStatements
-      include DatabaseStatements
+      OID = PostgreSQL::OID #:nodoc:
+
+      include PostgreSQL::Quoting
+      include PostgreSQL::ReferentialIntegrity
+      include PostgreSQL::SchemaStatements
+      include PostgreSQL::DatabaseStatements
       include Savepoints
 
       # Returns 'PostgreSQL' as adapter name for identification purposes.
@@ -455,9 +123,13 @@ module ActiveRecord
         ADAPTER_NAME
       end
 
+      def schema_creation # :nodoc:
+        PostgreSQL::SchemaCreation.new self
+      end
+
       # Adds `:array` option to the default set provided by the
       # AbstractAdapter
-      def prepare_column_options(column, types)
+      def prepare_column_options(column, types) # :nodoc:
         spec = super
         spec[:array] = 'true' if column.respond_to?(:array) && column.array
         spec[:default] = "\"#{column.default_function}\"" if column.default_function
@@ -487,6 +159,10 @@ module ActiveRecord
         true
       end
 
+      def supports_foreign_keys?
+        true
+      end
+
       def index_algorithms
         { concurrently: 'CONCURRENTLY' }
       end
@@ -544,19 +220,15 @@ module ActiveRecord
           end
       end
 
-      class BindSubstitution < Arel::Visitors::PostgreSQL # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
       # Initializes and connects a PostgreSQL adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger)
 
+        @visitor = Arel::Visitors::PostgreSQL.new self
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
           @prepared_statements = true
-          @visitor = Arel::Visitors::PostgreSQL.new self
         else
-          @visitor = unprepared_visitor
+          @prepared_statements = false
         end
 
         @connection_parameters, @config = connection_parameters, config
@@ -573,7 +245,7 @@ module ActiveRecord
           raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
         end
 
-        @type_map = OID::TypeMap.new
+        @type_map = Type::HashLookupTypeMap.new
         initialize_type_map(type_map)
         @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]) : true
@@ -592,10 +264,6 @@ module ActiveRecord
         false
       end
 
-      def active_threadsafe?
-        @connection.connect_poll != PG::PGRES_POLLING_FAILED
-      end
-
       # Close then reopen the connection.
       def reconnect!
         super
@@ -605,7 +273,12 @@ module ActiveRecord
 
       def reset!
         clear_cache!
-        super
+        reset_transaction
+        unless @connection.transaction_status == ::PG::PQTRANS_IDLE
+          @connection.query 'ROLLBACK'
+        end
+        @connection.query 'DISCARD ALL'
+        configure_connection
       end
 
       # Disconnects from the database if already connected. Otherwise, this
@@ -637,10 +310,6 @@ module ActiveRecord
         self.client_min_messages = old
       end
 
-      def supports_insert_with_returning?
-        true
-      end
-
       def supports_ddl_transactions?
         true
       end
@@ -659,6 +328,10 @@ module ActiveRecord
         postgresql_version >= 90200
       end
 
+      def supports_materialized_views?
+        postgresql_version >= 90300
+      end
+
       def enable_extension(name)
         exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
           reload_type_map
@@ -675,14 +348,13 @@ module ActiveRecord
         if supports_extensions?
           res = exec_query "SELECT EXISTS(SELECT * FROM pg_available_extensions WHERE name = '#{name}' AND installed_version IS NOT NULL) as enabled",
             'SCHEMA'
-          res.column_types['enabled'].type_cast res.rows.first.first
+          res.cast_values.first
         end
       end
 
       def extensions
         if supports_extensions?
-          res = exec_query "SELECT extname from pg_extension", "SCHEMA"
-          res.rows.map { |r| res.column_types['extname'].type_cast r.first }
+          exec_query("SELECT extname from pg_extension", "SCHEMA").cast_values
         else
           super
         end
@@ -699,25 +371,6 @@ module ActiveRecord
         exec_query "SET SESSION AUTHORIZATION #{user}"
       end
 
-      module Utils
-        extend self
-
-        # Returns an array of <tt>[schema_name, table_name]</tt> extracted from +name+.
-        # +schema_name+ is nil if not specified in +name+.
-        # +schema_name+ and +table_name+ exclude surrounding quotes (regardless of whether provided in +name+)
-        # +name+ supports the range of schema/table references understood by PostgreSQL, for example:
-        #
-        # * <tt>table_name</tt>
-        # * <tt>"table.name"</tt>
-        # * <tt>schema_name.table_name</tt>
-        # * <tt>schema_name."table.name"</tt>
-        # * <tt>"schema.name"."table name"</tt>
-        def extract_schema_and_table(name)
-          table, schema = name.scan(/[^".\s]+|"[^"]*"/)[0..1].collect{|m| m.gsub(/(^"|"$)/,'') }.reverse
-          [schema, table]
-        end
-      end
-
       def use_insert_returning?
         @use_insert_returning
       end
@@ -727,7 +380,12 @@ module ActiveRecord
       end
 
       def update_table_definition(table_name, base) #:nodoc:
-        Table.new(table_name, base)
+        PostgreSQL::Table.new(table_name, base)
+      end
+
+      def lookup_cast_type(sql_type) # :nodoc:
+        oid = execute("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").first['oid'].to_i
+        super(oid)
       end
 
       protected
@@ -756,68 +414,161 @@ module ActiveRecord
 
       private
 
-        def type_map
-          @type_map
-        end
+        def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
+          if !type_map.key?(oid)
+            load_additional_types(type_map, [oid])
+          end
 
-        def get_oid_type(oid, fmod, column_name)
-          type_map.fetch(oid, fmod) {
+          type_map.fetch(oid, fmod, sql_type) {
             warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
-            type_map[oid] = OID::Identity.new
+            Type::Value.new.tap do |cast_type|
+              type_map.register_type(oid, cast_type)
+            end
           }
         end
 
-        def reload_type_map
-          type_map.clear
-          initialize_type_map(type_map)
-        end
-
-        def add_oid(row, records_by_oid, type_map)
-          return type_map if type_map.key? row['type_elem'].to_i
+        def initialize_type_map(m) # :nodoc:
+          register_class_with_limit m, 'int2', OID::Integer
+          m.alias_type 'int4', 'int2'
+          m.alias_type 'int8', 'int2'
+          m.alias_type 'oid', 'int2'
+          m.register_type 'float4', OID::Float.new
+          m.alias_type 'float8', 'float4'
+          m.register_type 'text', Type::Text.new
+          register_class_with_limit m, 'varchar', Type::String
+          m.alias_type 'char', 'varchar'
+          m.alias_type 'name', 'varchar'
+          m.alias_type 'bpchar', 'varchar'
+          m.register_type 'bool', Type::Boolean.new
+          register_class_with_limit m, 'bit', OID::Bit
+          register_class_with_limit m, 'varbit', OID::BitVarying
+          m.alias_type 'timestamptz', 'timestamp'
+          m.register_type 'date', OID::Date.new
+          m.register_type 'time', OID::Time.new
+
+          m.register_type 'money', OID::Money.new
+          m.register_type 'bytea', OID::Bytea.new
+          m.register_type 'point', OID::Point.new
+          m.register_type 'hstore', OID::Hstore.new
+          m.register_type 'json', OID::Json.new
+          m.register_type 'jsonb', OID::Jsonb.new
+          m.register_type 'cidr', OID::Cidr.new
+          m.register_type 'inet', OID::Inet.new
+          m.register_type 'uuid', OID::Uuid.new
+          m.register_type 'xml', OID::Xml.new
+          m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
+          m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+          m.register_type 'citext', OID::SpecializedString.new(:citext)
+          m.register_type 'ltree', OID::SpecializedString.new(:ltree)
+
+          # FIXME: why are we keeping these types as strings?
+          m.alias_type 'interval', 'varchar'
+          m.alias_type 'path', 'varchar'
+          m.alias_type 'line', 'varchar'
+          m.alias_type 'polygon', 'varchar'
+          m.alias_type 'circle', 'varchar'
+          m.alias_type 'lseg', 'varchar'
+          m.alias_type 'box', 'varchar'
+
+          m.register_type 'timestamp' do |_, _, sql_type|
+            precision = extract_precision(sql_type)
+            OID::DateTime.new(precision: precision)
+          end
 
-          if OID.registered_type? row['typname']
-            # this composite type is explicitly registered
-            vector = OID::NAMES[row['typname']]
-          else
-            # use the default for composite types
-            unless type_map.key? row['typelem'].to_i
-              add_oid records_by_oid[row['typelem']], records_by_oid, type_map
+          m.register_type 'numeric' do |_, fmod, sql_type|
+            precision = extract_precision(sql_type)
+            scale = extract_scale(sql_type)
+
+            # The type for the numeric depends on the width of the field,
+            # so we'll do something special here.
+            #
+            # When dealing with decimal columns:
+            #
+            # places after decimal  = fmod - 4 & 0xffff
+            # places before decimal = (fmod - 4) >> 16 & 0xffff
+            if fmod && (fmod - 4 & 0xffff).zero?
+              # FIXME: Remove this class, and the second argument to
+              # lookups on PG
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              OID::Decimal.new(precision: precision, scale: scale)
             end
-
-            vector = OID::Vector.new row['typdelim'], type_map[row['typelem'].to_i]
           end
 
-          type_map[row['oid'].to_i] = vector
-          type_map
+          load_additional_types(m)
         end
 
-        def initialize_type_map(type_map)
-          result = execute('SELECT oid, typname, typelem, typdelim, typinput FROM pg_type', 'SCHEMA')
-          leaves, nodes = result.partition { |row| row['typelem'] == '0' }
+        def extract_limit(sql_type) # :nodoc:
+          case sql_type
+          when /^bigint/i;    8
+          when /^smallint/i;  2
+          else super
+          end
+        end
 
-          # populate the leaf nodes
-          leaves.find_all { |row| OID.registered_type? row['typname'] }.each do |row|
-            type_map[row['oid'].to_i] = OID::NAMES[row['typname']]
+        # Extracts the value from a PostgreSQL column default definition.
+        def extract_value_from_default(oid, default) # :nodoc:
+          case default
+            # Quoted types
+            when /\A[\(B]?'(.*)'::/m
+              $1.gsub(/''/, "'")
+            # Boolean types
+            when 'true', 'false'
+              default
+            # Numeric types
+            when /\A\(?(-?\d+(\.\d*)?\)?(::bigint)?)\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
           end
+        end
 
-          records_by_oid = result.group_by { |row| row['oid'] }
+        def extract_default_function(default_value, default) # :nodoc:
+          default if has_default_function?(default_value, default)
+        end
 
-          arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+        def has_default_function?(default_value, default) # :nodoc:
+          !default_value && (%r{\w+\(.*\)} === default)
+        end
 
-          # populate composite types
-          nodes.each do |row|
-            add_oid row, records_by_oid, type_map
+        def load_additional_types(type_map, oids = nil) # :nodoc:
+          if supports_ranges?
+            query = <<-SQL
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+              FROM pg_type as t
+              LEFT JOIN pg_range as r ON oid = rngtypid
+            SQL
+          else
+            query = <<-SQL
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
+              FROM pg_type as t
+            SQL
           end
 
-          # populate array types
-          arrays.find_all { |row| type_map.key? row['typelem'].to_i }.each do |row|
-            array = OID::Array.new  type_map[row['typelem'].to_i]
-            type_map[row['oid'].to_i] = array
+          if oids
+            query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
           end
+
+          initializer = OID::TypeMapInitializer.new(type_map)
+          records = execute(query, 'SCHEMA')
+          initializer.run(records)
         end
 
         FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
 
+        def execute_and_clear(sql, name, binds)
+          result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
+                                                        exec_cache(sql, name, binds)
+          ret = yield result
+          result.clear
+          ret
+        end
+
         def exec_no_cache(sql, name, binds)
           log(sql, name, binds) { @connection.async_exec(sql, []) }
         end
@@ -877,11 +628,6 @@ module ActiveRecord
           @statements[sql_key]
         end
 
-        # The internal PostgreSQL identifier of the money data type.
-        MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
-        # The internal PostgreSQL identifier of the BYTEA data type.
-        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
-
         # Connects to a PostgreSQL server and sets up the adapter depending on the
         # connected server's characteristics.
         def connect
@@ -890,14 +636,14 @@ module ActiveRecord
           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
           # should know about this but can't detect it there, so deal with it here.
-          PostgreSQLColumn.money_precision = (postgresql_version >= 80300) ? 19 : 10
+          OID::Money.precision = (postgresql_version >= 80300) ? 19 : 10
 
           configure_connection
         rescue ::PG::Error => error
           if error.message.include?("does not exist")
-            raise ActiveRecord::NoDatabaseError.new(error.message)
+            raise ActiveRecord::NoDatabaseError.new(error.message, error)
           else
-            raise error
+            raise
           end
         end
 
@@ -972,7 +718,7 @@ module ActiveRecord
         # 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:
+        def column_definitions(table_name) # :nodoc:
           exec_query(<<-end_sql, 'SCHEMA').rows
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                      pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod
@@ -984,23 +730,13 @@ module ActiveRecord
           end_sql
         end
 
-        def extract_pg_identifier_from_name(name)
-          match_data = name.start_with?('"') ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
-
-          if match_data
-            rest = name[match_data[0].length, name.length]
-            rest = rest[1, rest.length] if rest.start_with? "."
-            [match_data[1], (rest.length > 0 ? rest : nil)]
-          end
-        end
-
-        def extract_table_ref_from_insert_sql(sql)
+        def extract_table_ref_from_insert_sql(sql) # :nodoc:
           sql[/into\s+([^\(]*).*values\s*\(/im]
           $1.strip if $1
         end
 
-        def create_table_definition(name, temporary, options, as = nil)
-          TableDefinition.new native_database_types, name, temporary, options, as
+        def create_table_definition(name, temporary, options, as = nil) # :nodoc:
+          PostgreSQL::TableDefinition.new native_database_types, name, temporary, options, as
         end
     end
   end