class PG::BasicTypeRegistry::CoderMapsBundle

An instance of this class stores CoderMap instances to be used for text and binary wire formats as well as encoder and decoder directions.

A PG::BasicTypeRegistry::CoderMapsBundle instance retrieves all type definitions from the PostgreSQL server and matches them with the coder definitions of the global PG::BasicTypeRegistry . It provides 4 separate CoderMap instances for the combinations of the two formats and directions.

A PG::BasicTypeRegistry::CoderMapsBundle instance can be used to initialize an instance of

by passing it instead of the connection object like so:

conn = PG::Connection.new
maps = PG::BasicTypeRegistry::CoderMapsBundle.new(conn)
conn.type_map_for_results = PG::BasicTypeMapForResults.new(maps)

Attributes

typenames_by_oid[R]

Public Class Methods

new(connection, registry: nil) click to toggle source
# File lib/pg/basic_type_registry.rb, line 112
                def initialize(connection, registry: nil)
                        registry ||= DEFAULT_TYPE_REGISTRY

                        result = connection.exec(<<-SQL).to_a
                                SELECT t.oid, t.typname, t.typelem, t.typdelim, ti.proname AS typinput
                                FROM pg_type as t
                                JOIN pg_proc as ti ON ti.oid = t.typinput
                        SQL

                        init_maps(registry, result.freeze)
                        freeze
                end

Public Instance Methods

each_format(direction) click to toggle source
# File lib/pg/basic_type_registry.rb, line 141
def each_format(direction)
        @maps.map { |f| f[direction] }
end
map_for(format, direction) click to toggle source
# File lib/pg/basic_type_registry.rb, line 145
def map_for(format, direction)
        @maps[format][direction]
end

Private Instance Methods

init_maps(registry, result) click to toggle source
# File lib/pg/basic_type_registry.rb, line 125
        def init_maps(registry, result)
        @maps = [
                [0, :encoder, PG::TextEncoder::Array],
                [0, :decoder, PG::TextDecoder::Array],
                [1, :encoder, nil],
                [1, :decoder, nil],
        ].inject([]) do |h, (format, direction, arraycoder)|
                coders = registry.coders_for(format, direction) || {}
                h[format] ||= {}
                h[format][direction] = CoderMap.new(result, coders, format, arraycoder)
                h
        end.each{|h| h.freeze }.freeze

        @typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }.freeze
end