class PG::BasicTypeRegistry::CoderMap

An instance of this class stores the coders that should be used for a given wire format (text or binary) and type cast direction (encoder or decoder).

Constants

DONT_QUOTE_TYPES

Hash of text types that don't require quotation, when used within composite types.

type.name => true

Attributes

coders[R]
coders_by_name[R]
coders_by_oid[R]
typenames_by_oid[R]

Public Class Methods

new(result, coders_by_name, format, arraycoder) click to toggle source
# File lib/pg/basic_type_mapping.rb, line 19
        def initialize(result, coders_by_name, format, arraycoder)
                coder_map = {}

                _ranges, nodes = result.partition { |row| row['typinput'] == 'range_in' }
                leaves, nodes = nodes.partition { |row| row['typelem'].to_i == 0 }
                arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }

                # populate the enum types
                _enums, leaves = leaves.partition { |row| row['typinput'] == 'enum_in' }
#              enums.each do |row|
#                      coder_map[row['oid'].to_i] = OID::Enum.new
#              end

                # populate the base types
                leaves.find_all { |row| coders_by_name.key?(row['typname']) }.each do |row|
                        coder = coders_by_name[row['typname']].dup
                        coder.oid = row['oid'].to_i
                        coder.name = row['typname']
                        coder.format = format
                        coder_map[coder.oid] = coder
                end

                _records_by_oid = result.group_by { |row| row['oid'] }

                # populate composite types
#              nodes.each do |row|
#                      add_oid row, records_by_oid, coder_map
#              end

                if arraycoder
                        # populate array types
                        arrays.each do |row|
                                elements_coder = coder_map[row['typelem'].to_i]
                                next unless elements_coder

                                coder = arraycoder.new
                                coder.oid = row['oid'].to_i
                                coder.name = row['typname']
                                coder.format = format
                                coder.elements_type = elements_coder
                                coder.needs_quotation = !DONT_QUOTE_TYPES[elements_coder.name]
                                coder_map[coder.oid] = coder
                        end
                end

                # populate range types
#              ranges.find_all { |row| coder_map.key? row['rngsubtype'].to_i }.each do |row|
#                      subcoder = coder_map[row['rngsubtype'].to_i]
#                      range = OID::Range.new subcoder
#                      coder_map[row['oid'].to_i] = range
#              end

                @coders = coder_map.values
                @coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
                @coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }
                @typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }
        end

Public Instance Methods

coder_by_name(name) click to toggle source
# File lib/pg/basic_type_mapping.rb, line 82
def coder_by_name(name)
        @coders_by_name[name]
end
coder_by_oid(oid) click to toggle source
# File lib/pg/basic_type_mapping.rb, line 86
def coder_by_oid(oid)
        @coders_by_oid[oid]
end