class PG::BasicTypeRegistry::CoderMap - pg: The Ruby Interface to PostgreSQL

# 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