Class: PG::BasicTypeRegistry::CoderMap

### Home Classes Methods

### In Files

- lib/pg/basic_type_mapping.rb

### Parent

Object

### Methods

- ::new
- #coder_by_name
- #coder_by_oid

### Files

- LICENSE
- Manifest.txt
- POSTGRES
- README-OS_X.rdoc
- README-Windows.rdoc
- README.ja.rdoc
- README.rdoc
- errorcodes.txt

### Class/Module Index

Quicksearch

- PG
- PG::BasicTypeMapBasedOnResult
- PG::BasicTypeMapForQueries
- PG::BasicTypeMapForResults
- PG::BasicTypeMapForResults::WarningTypeMap
- PG::BasicTypeRegistry
- PG::BasicTypeRegistry::CoderMap
- PG::Coder
- PG::Coder::BinaryFormatting
- PG::CompositeCoder
- PG::Connection
- PG::Connection
- PG::Constants
- PG::CopyCoder
- PG::Error
- PG::NotAllCopyDataRetrieved
- PG::Result
- PG::Result
- PG::TextDecoder
- PG::TextDecoder::Date
- PG::TextDecoder::TimestampWithTimeZone
- PG::TextDecoder::TimestampWithoutTimeZone
- PG::TextEncoder
- PG::TextEncoder::Date
- PG::TextEncoder::TimestampWithTimeZone
- PG::TextEncoder::TimestampWithoutTimeZone
- PG::TypeMapByColumn
- Object
- Object::PGconn
- Object::PGresult

No matching classes.

# 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.