activerecord-redshift-adapter-ng 0.9.0 → 0.9.1

data/lib/active_record/connection_adapters/redshift/schema_statements.rb

@@ -14,6 +14,10 @@ module ActiveRecord
         end
 
         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]}"
@@ -39,7 +43,7 @@ module ActiveRecord
           create_database(name, options)
         end
 
-        # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
+        # Create a new PostgreSQL database. Options include <tt>:owner</tt>,
         # <tt>:encoding</tt> (defaults to utf8), <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>).
@@ -54,6 +58,16 @@ module ActiveRecord
             memo += case key
             when :owner
               " OWNER = \"#{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
@@ -72,7 +86,7 @@ module ActiveRecord
 
         # Returns the list of all tables in the schema search path or a specified schema.
         def tables(name = nil)
-          query(<<-SQL, 'SCHEMA').map { |row| row[0] }
+          query(<<-SQL, 'SCHEMA').map { |row| "#{row[0]}.#{row[1]}" }
             SELECT tablename
             FROM pg_tables
             WHERE schemaname = ANY (current_schemas(false))
@@ -110,7 +124,16 @@ module ActiveRecord
         end
 
         def index_name_exists?(table_name, index_name, default)
-          false
+          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
+            SELECT COUNT(*)
+            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 i.relname = '#{index_name}'
+              AND t.relname = '#{table_name}'
+              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+          SQL
         end
 
         # Returns an array of indexes for the given table.
@@ -151,10 +174,18 @@ module ActiveRecord
           end_sql
         end
 
+        # Returns the current database collation.
         def collation
+          query(<<-end_sql, 'SCHEMA')[0][0]
+            SELECT pg_database.datcollate FROM pg_database WHERE pg_database.datname LIKE '#{current_database}'
+          end_sql
         end
 
+        # Returns the current database ctype.
         def ctype
+          query(<<-end_sql, 'SCHEMA')[0][0]
+            SELECT pg_database.datctype FROM pg_database WHERE pg_database.datname LIKE '#{current_database}'
+          end_sql
         end
 
         # Returns an array of schema names.
@@ -195,6 +226,17 @@ module ActiveRecord
           @schema_search_path ||= query('SHOW search_path', 'SCHEMA')[0][0]
         end
 
+        # Returns the current client message level.
+        def client_min_messages
+          query('SHOW client_min_messages', 'SCHEMA')[0][0]
+        end
+
+        # Set the client message level.
+        def client_min_messages=(level)
+          # can't set client_min_messages in redshift
+          # execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
+        end
+
         # Returns the sequence name for a table's primary key or some other specified key.
         def default_sequence_name(table_name, pk = nil) #:nodoc:
           result = serial_sequence(table_name, pk || 'id')
@@ -211,26 +253,113 @@ module ActiveRecord
           result.rows.first.first
         end
 
+        # Sets the sequence of a table's primary key to the specified value.
         def set_pk_sequence!(table, value) #:nodoc:
+          pk, sequence = pk_and_sequence_for(table)
+
+          if pk
+            if sequence
+              quoted_sequence = quote_table_name(sequence)
+
+              select_value <<-end_sql, 'SCHEMA'
+              SELECT setval('#{quoted_sequence}', #{value})
+              end_sql
+            else
+              @logger.warn "#{table} has primary key #{pk} with no default sequence" if @logger
+            end
+          end
         end
 
+        # Resets the sequence of a table's primary key to the maximum value.
         def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
+          unless pk and sequence
+            default_pk, default_sequence = pk_and_sequence_for(table)
+
+            pk ||= default_pk
+            sequence ||= default_sequence
+          end
+
+          if @logger && pk && !sequence
+            @logger.warn "#{table} has primary key #{pk} with no default sequence"
+          end
+
+          if pk && sequence
+            quoted_sequence = quote_table_name(sequence)
+
+            select_value <<-end_sql, 'SCHEMA'
+              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
 
+        # Returns a table's primary key and belonging sequence.
         def pk_and_sequence_for(table) #:nodoc:
-          [nil, nil]
+          # First try looking for a sequence with a dependency on the
+          # given table's primary key.
+          result = query(<<-end_sql, 'SCHEMA')[0]
+            SELECT attr.attname, nsp.nspname, seq.relname
+            FROM pg_class      seq,
+                 pg_attribute  attr,
+                 pg_depend     dep,
+                 pg_constraint cons,
+                 pg_namespace  nsp
+            WHERE seq.oid           = dep.objid
+              AND seq.relkind       = 'S'
+              AND attr.attrelid     = dep.refobjid
+              AND attr.attnum       = dep.refobjsubid
+              AND attr.attrelid     = cons.conrelid
+              AND attr.attnum       = cons.conkey[1]
+              AND seq.relnamespace  = nsp.oid
+              AND cons.contype      = 'p'
+              AND dep.classid       = 'pg_class'::regclass
+              AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
+          end_sql
+
+          if result.nil? or result.empty?
+            result = query(<<-end_sql, 'SCHEMA')[0]
+              SELECT attr.attname, nsp.nspname,
+                CASE
+                  WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
+                  WHEN split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2) ~ '.' THEN
+                    substr(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2),
+                           strpos(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2), '.')+1)
+                  ELSE split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2)
+                END
+              FROM pg_class       t
+              JOIN pg_attribute   attr ON (t.oid = attrelid)
+              JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
+              JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
+              JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
+              WHERE t.oid = '#{quote_table_name(table)}'::regclass
+                AND cons.contype = 'p'
+                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
+            end_sql
+          end
+
+          pk = result.shift
+          if result.last
+            [pk, Redshift::Name.new(*result)]
+          else
+            [pk, nil]
+          end
+        rescue
+          nil
         end
 
         # Returns just a table's primary key
         def primary_key(table)
+          # Passing the env variable REDSHIFT_SCHEMA will allow the correct generation of id
+          # fields that are not of integer/uuid/serial type
+          return if ENV['REDSHIFT_SCHEMA']
           pks = exec_query(<<-end_sql, 'SCHEMA').rows
             SELECT DISTINCT attr.attname
             FROM pg_attribute attr
             INNER JOIN pg_depend dep ON attr.attrelid = dep.refobjid AND attr.attnum = dep.refobjsubid
-            INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = any(cons.conkey)
+            INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]
             WHERE cons.contype = 'p'
               AND dep.refobjid = '#{quote_table_name(table)}'::regclass
           end_sql
+
           return nil unless pks.count == 1
           pks[0][0]
         end
@@ -244,9 +373,21 @@ module ActiveRecord
         def rename_table(table_name, new_name)
           clear_cache!
           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 && seq.identifier == "#{table_name}_#{pk}_seq"
+            new_seq = "#{new_name}_#{pk}_seq"
+            idx = "#{table_name}_pkey"
+            new_idx = "#{new_name}_pkey"
+            execute "ALTER TABLE #{quote_table_name(seq)} RENAME TO #{quote_table_name(new_seq)}"
+            execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
+          end
+
+          rename_table_indexes(table_name, new_name)
         end
 
-        def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        # 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 = {})
           clear_cache!
           super
         end
@@ -294,24 +435,30 @@ module ActiveRecord
         end
 
         # Renames a column in a table.
-        def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        def rename_column(table_name, column_name, new_column_name)
           clear_cache!
           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)
         end
 
         def add_index(table_name, column_name, options = {}) #:nodoc:
+          # ignore
         end
 
         def remove_index!(table_name, index_name) #:nodoc:
+          # ignore
         end
 
         def rename_index(table_name, old_name, new_name)
+          validate_index_length!(table_name, new_name)
+
+          execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
+          # ignore
         end
 
         def foreign_keys(table_name)
           fk_info = select_all <<-SQL.strip_heredoc
-            SELECT t2.relname AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+            SELECT t2.oid::regclass AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
             JOIN pg_class t2 ON c.confrelid = t2.oid
@@ -353,6 +500,22 @@ module ActiveRecord
         # Maps logical Rails types to PostgreSQL-specific data types.
         def type_to_sql(type, limit = nil, precision = nil, scale = nil)
           case type.to_s
+          when 'boolean'
+            super(type)
+          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)
+            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)
+            else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
+            end
           when 'integer'
             return 'integer' unless limit
 

data/lib/active_record/connection_adapters/redshift/utils.rb

@@ -18,11 +18,7 @@ module ActiveRecord
         end
 
         def quoted
-          if schema
-            PGconn.quote_ident(schema) << SEPARATOR << PGconn.quote_ident(identifier)
-          else
-            PGconn.quote_ident(identifier)
-          end
+          parts.map { |p| PGconn.quote_ident(p) }.join SEPARATOR
         end
 
         def ==(o)
@@ -36,11 +32,8 @@ module ActiveRecord
 
         protected
           def unquote(part)
-            if part && part.start_with?('"')
-              part[1..-2]
-            else
-              part
-            end
+            return unless part
+            part.gsub(/(^"|"$)/,'')
           end
 
           def parts
@@ -64,11 +57,7 @@ module ActiveRecord
         # * <tt>"schema_name".table_name</tt>
         # * <tt>"schema.name"."table name"</tt>
         def extract_schema_qualified_name(string)
-          schema, table = string.scan(/[^".\s]+|"[^"]*"/)
-          if table.nil?
-            table = schema
-            schema = nil
-          end
+          table, schema = string.scan(/[^".\s]+|"[^"]*"/)[0..1].reverse
           Redshift::Name.new(schema, table)
         end
       end

data/lib/active_record/connection_adapters/redshift_adapter.rb

@@ -13,14 +13,14 @@ require 'active_record/connection_adapters/redshift/database_statements'
 require 'arel/visitors/bind_visitor'
 
 # Make sure we're using pg high enough for PGResult#values
-gem 'pg', '> 0.15'
+gem 'pg', '~> 0.15'
 require 'pg'
 
 require 'ipaddr'
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
-    RS_VALID_CONN_PARAMS = [:host, :hostaddr, :port, :dbname, :user, :password, :connect_timeout,
+    VALID_CONN_PARAMS = [:host, :hostaddr, :port, :dbname, :user, :password, :connect_timeout,
                          :client_encoding, :options, :application_name, :fallback_application_name,
                          :keepalives, :keepalives_idle, :keepalives_interval, :keepalives_count,
                          :tty, :sslmode, :requiressl, :sslcompression, :sslcert, :sslkey,
@@ -37,7 +37,7 @@ module ActiveRecord
       conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
       # Forward only valid config params to PGconn.connect.
-      conn_params.keep_if { |k, _| RS_VALID_CONN_PARAMS.include?(k) }
+      conn_params.keep_if { |k, _| VALID_CONN_PARAMS.include?(k) }
 
       # The postgres drivers don't allow the creation of an unconnected PGconn object,
       # so just pass a nil connection object for the time being.
@@ -64,7 +64,8 @@ module ActiveRecord
     #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
     # * <tt>:variables</tt> - An optional hash of additional parameters that
     #   will be used in <tt>SET SESSION key = val</tt> calls on the connection.
-    # * <tt>:insert_returning</tt> - Does nothing for Redshift.
+    # * <tt>:insert_returning</tt> - An optional boolean to control the use or <tt>RETURNING</tt> for <tt>INSERT</tt> statements
+    #   defaults to true.
     #
     # Any further options are used as connection parameters to libpq. See
     # http://www.postgresql.org/docs/9.1/static/libpq-connect.html for the
@@ -76,17 +77,40 @@ module ActiveRecord
       ADAPTER_NAME = 'Redshift'.freeze
 
       NATIVE_DATABASE_TYPES = {
-        primary_key: "integer identity primary key",
-        string:      { name: "varchar" },
-        text:        { name: "varchar" },
+        primary_key: "integer identity",
+        bigserial:   { name: "bigint" },
+        string:      { name: "character varying" },
+        text:        { name: "text" },
         integer:     { name: "integer" },
         float:       { name: "float" },
         decimal:     { name: "decimal" },
         datetime:    { name: "timestamp" },
         time:        { name: "time" },
         date:        { name: "date" },
-        bigint:      { name: "bigint" },
+        daterange:   { name: "daterange" },
+        numrange:    { name: "numrange" },
+        tsrange:     { name: "tsrange" },
+        tstzrange:   { name: "tstzrange" },
+        int4range:   { name: "int4range" },
+        int8range:   { name: "int8range" },
+        binary:      { name: "bytea" },
         boolean:     { name: "boolean" },
+        bigint:      { name: "bigint" },
+        xml:         { name: "xml" },
+        tsvector:    { name: "tsvector" },
+        hstore:      { name: "hstore" },
+        inet:        { name: "inet" },
+        cidr:        { name: "cidr" },
+        macaddr:     { name: "macaddr" },
+        uuid:        { name: "uuid" },
+        json:        { name: "json" },
+        jsonb:       { name: "jsonb" },
+        ltree:       { name: "ltree" },
+        citext:      { name: "citext" },
+        point:       { name: "point" },
+        bit:         { name: "bit" },
+        bit_varying: { name: "bit varying" },
+        money:       { name: "money" },
       }
 
       OID = Redshift::OID #:nodoc:
@@ -95,6 +119,7 @@ module ActiveRecord
       include Redshift::ReferentialIntegrity
       include Redshift::SchemaStatements
       include Redshift::DatabaseStatements
+      include Savepoints
 
       def schema_creation # :nodoc:
         Redshift::SchemaCreation.new self
@@ -104,10 +129,16 @@ module ActiveRecord
       # AbstractAdapter
       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
         spec
       end
 
+      # Adds +:array+ as a valid migration key
+      def migration_keys
+        super + [:array]
+      end
+
       # Returns +true+, since this connection adapter supports prepared statement
       # caching.
       def supports_statement_cache?
@@ -115,15 +146,15 @@ module ActiveRecord
       end
 
       def supports_index_sort_order?
-        false
+        true
       end
 
       def supports_partial_index?
-        false
+        true
       end
 
       def supports_transaction_isolation?
-        false
+        true
       end
 
       def supports_foreign_keys?
@@ -196,8 +227,13 @@ module ActiveRecord
         super(connection, logger)
 
         @visitor = Arel::Visitors::PostgreSQL.new self
-        @prepared_statements = false
+        if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
+          @prepared_statements = true
+        else
+          @prepared_statements = false
+        end
 
+        connection_parameters.delete :prepared_statements
         @connection_parameters, @config = connection_parameters, config
 
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
@@ -269,14 +305,6 @@ module ActiveRecord
         true
       end
 
-      # Enable standard-conforming strings if available.
-      def set_standard_conforming_strings
-        old, self.client_min_messages = client_min_messages, 'panic'
-        execute('SET standard_conforming_strings = on', 'SCHEMA') rescue nil
-      ensure
-        self.client_min_messages = old
-      end
-
       def supports_ddl_transactions?
         true
       end
@@ -285,30 +313,46 @@ module ActiveRecord
         true
       end
 
+      # Returns true if pg > 9.1
       def supports_extensions?
-        false
+        redshift_version >= 90100
       end
 
+      # Range datatypes weren't introduced until PostgreSQL 9.2
       def supports_ranges?
-        false
+        redshift_version >= 90200
       end
 
       def supports_materialized_views?
-        false
-      end
-
-      def supports_import?
-        true
+        redshift_version >= 90300
       end
 
       def enable_extension(name)
+        exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
+          reload_type_map
+        }
       end
 
       def disable_extension(name)
+        exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
+          reload_type_map
+        }
       end
 
       def extension_enabled?(name)
-        false
+        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.cast_values.first
+        end
+      end
+
+      def extensions
+        if supports_extensions?
+          exec_query("SELECT extname from pg_extension", "SCHEMA").cast_values
+        else
+          super
+        end
       end
 
       # Returns the configured supported identifier length supported by PostgreSQL
@@ -356,13 +400,17 @@ module ActiveRecord
           @connection.server_version
         end
 
+        # See http://www.postgresql.org/docs/9.1/static/errcodes-appendix.html
+        FOREIGN_KEY_VIOLATION = "23503"
+        UNIQUE_VIOLATION      = "23505"
+
         def translate_exception(exception, message)
           return exception unless exception.respond_to?(:result)
 
-          case exception.message
-          when /duplicate key value violates unique constraint/
+          case exception.result.try(:error_field, PGresult::PG_DIAG_SQLSTATE)
+          when UNIQUE_VIOLATION
             RecordNotUnique.new(message, exception)
-          when /violates foreign key constraint/
+          when FOREIGN_KEY_VIOLATION
             InvalidForeignKey.new(message, exception)
           else
             super
@@ -377,7 +425,11 @@ module ActiveRecord
           end
 
           type_map.fetch(oid, fmod, sql_type) {
-            warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+            # oid=2205 maps to t2.oid::regclass, which seems to do fine as string
+            if oid != 2205
+              warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+            end
+
             Type::Value.new.tap do |cast_type|
               type_map.register_type(oid, cast_type)
             end
@@ -397,10 +449,36 @@ module ActiveRecord
           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)
@@ -450,7 +528,7 @@ module ActiveRecord
             when 'true', 'false'
               default
             # Numeric types
-            when /\A\(?(-?\d+(\.\d*)?)\)?\z/
+            when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
               $1
             # Object identifier types
             when /\A-?\d+\z/
@@ -471,8 +549,6 @@ module ActiveRecord
         end
 
         def load_additional_types(type_map, oids = nil) # :nodoc:
-          initializer = OID::TypeMapInitializer.new(type_map)
-
           if supports_ranges?
             query = <<-SQL
               SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
@@ -490,9 +566,9 @@ module ActiveRecord
             query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
           end
 
-          execute_and_clear(query, 'SCHEMA', []) do |records|
-            initializer.run(records)
-          end
+          initializer = OID::TypeMapInitializer.new(type_map)
+          records = execute(query, 'SCHEMA')
+          initializer.run(records)
         end
 
         FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
@@ -567,6 +643,11 @@ module ActiveRecord
         def connect
           @connection = PGconn.connect(@connection_parameters)
 
+          # 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.
+          OID::Money.precision = (redshift_version >= 80300) ? 19 : 10
+
           configure_connection
         rescue ::PG::Error => error
           if error.message.include?("does not exist")