# class PG::BasicTypeRegistry

This class defines the mapping between PostgreSQL types and encoder/decoder classes for `PG::BasicTypeMapForResults`, `PG::BasicTypeMapForQueries` and `PG::BasicTypeMapBasedOnResult`.

Additional types can be added like so:

    require 'pg'
    require 'ipaddr'

    class InetDecoder < PG::SimpleDecoder
      def decode(string, tuple=nil, field=nil)
        IPAddr.new(string)
      end
    end
    class InetEncoder < PG::SimpleEncoder
      def encode(ip_addr)
        ip_addr.to_s
      end
    end

    conn = PG.connect
    regi = PG::BasicTypeRegistry.new.register_default_types
    regi.register_type(0, 'inet', InetEncoder, InetDecoder)
    conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn, registry: regi)

### Public Class Methods

new() click to toggle source

    # File lib/pg/basic_type_registry.rb, line 172
    def initialize
            # @coders_by_name has a content of
            #    Array< Hash< Symbol: Hash< String: Coder > > >
            #
            # The layers are:
            #   * index of Array is 0 (text) and 1 (binary)
            #   * Symbol key in the middle Hash is :encoder and :decoder
            #   * String key in the inner Hash corresponds to the `typname` column in the table pg_type
            #   * Coder value in the inner Hash is the associated coder object
            @coders_by_name = []
    end

### Public Instance Methods

alias_type(format, new, old) click to toggle source

Alias the `old` type to the `new` type.

    # File lib/pg/basic_type_registry.rb, line 215
    def alias_type(format, new, old)
            [:encoder, :decoder].each do |ende|
                    enc = @coders_by_name[format][ende][old]
                    if enc
                            @coders_by_name[format][ende][new] = enc
                    else
                            @coders_by_name[format][ende].delete(new)
                    end
            end
            self
    end

coders_for(format, direction) click to toggle source

Retrieve a Hash of all en- or decoders for a given wire format. The hash key is the name as defined in table `pg_type`. The hash value is the registered coder object.

    # File lib/pg/basic_type_registry.rb, line 187
    def coders_for(format, direction)
            check_format_and_direction(format, direction)
            @coders_by_name[format]&.[](direction)
    end

define_default_types()
Alias for: register_default_types
register_coder(coder) click to toggle source

Register an encoder or decoder instance for casting a PostgreSQL type.

Coder#name must correspond to the `typname` column in the `pg_type` table. Coder#format can be 0 for text format and 1 for binary.

    # File lib/pg/basic_type_registry.rb, line 196
    def register_coder(coder)
            h = @coders_by_name[coder.format] ||= { encoder: {}, decoder: {} }
            name = coder.name || raise(ArgumentError, "name of #{coder.inspect} must be defined")
            h[:encoder][name] = coder if coder.respond_to?(:encode)
            h[:decoder][name] = coder if coder.respond_to?(:decode)
            self
    end

register_default_types() click to toggle source

Populate the registry with all builtin types of ruby-pg

    # File lib/pg/basic_type_registry.rb, line 228
    def register_default_types
            register_type 0, 'int2', PG::TextEncoder::Integer, PG::TextDecoder::Integer
            alias_type    0, 'int4', 'int2'
            alias_type    0, 'int8', 'int2'
            alias_type    0, 'oid',  'int2'

            begin
                    PG.require_bigdecimal_without_warning
                    register_type 0, 'numeric', PG::TextEncoder::Numeric, PG::TextDecoder::Numeric
            rescue LoadError
            end
            register_type 0, 'text', PG::TextEncoder::String, PG::TextDecoder::String
            alias_type 0, 'varchar', 'text'
            alias_type 0, 'char', 'text'
            alias_type 0, 'bpchar', 'text'
            alias_type 0, 'xml', 'text'
            alias_type 0, 'name', 'text'

            # FIXME: why are we keeping these types as strings?
            # alias_type 'tsvector', 'text'
            # alias_type 'interval', 'text'
            # alias_type 'macaddr',  'text'
            # alias_type 'uuid',     'text'
            #
            # register_type 'money', OID::Money.new
            register_type 0, 'bytea', PG::TextEncoder::Bytea, PG::TextDecoder::Bytea
            register_type 0, 'bool', PG::TextEncoder::Boolean, PG::TextDecoder::Boolean
            # register_type 'bit', OID::Bit.new
            # register_type 'varbit', OID::Bit.new

            register_type 0, 'float4', PG::TextEncoder::Float, PG::TextDecoder::Float
            alias_type 0, 'float8', 'float4'

            # For compatibility reason the timestamp in text format is encoded as local time (TimestampWithoutTimeZone) instead of UTC
            register_type 0, 'timestamp', PG::TextEncoder::TimestampWithoutTimeZone, PG::TextDecoder::TimestampWithoutTimeZone
            register_type 0, 'timestamptz', PG::TextEncoder::TimestampWithTimeZone, PG::TextDecoder::TimestampWithTimeZone
            register_type 0, 'date', PG::TextEncoder::Date, PG::TextDecoder::Date
            # register_type 'time', OID::Time.new
            #
            # register_type 'path', OID::Text.new
            # register_type 'point', OID::Point.new
            # register_type 'polygon', OID::Text.new
            # register_type 'circle', OID::Text.new
            # register_type 'hstore', OID::Hstore.new
            register_type 0, 'json', PG::TextEncoder::JSON, PG::TextDecoder::JSON
            alias_type    0, 'jsonb',  'json'
            # register_type 'citext', OID::Text.new
            # register_type 'ltree', OID::Text.new
            #
            register_type 0, 'inet', PG::TextEncoder::Inet, PG::TextDecoder::Inet
            alias_type 0, 'cidr', 'inet'

            register_type 0, 'record', PG::TextEncoder::Record, PG::TextDecoder::Record

            register_type 1, 'int2', PG::BinaryEncoder::Int2, PG::BinaryDecoder::Integer
            register_type 1, 'int4', PG::BinaryEncoder::Int4, PG::BinaryDecoder::Integer
            register_type 1, 'int8', PG::BinaryEncoder::Int8, PG::BinaryDecoder::Integer
            alias_type    1, 'oid',  'int2'

            register_type 1, 'text', PG::BinaryEncoder::String, PG::BinaryDecoder::String
            alias_type 1, 'varchar', 'text'
            alias_type 1, 'char', 'text'
            alias_type 1, 'bpchar', 'text'
            alias_type 1, 'xml', 'text'
            alias_type 1, 'name', 'text'

            register_type 1, 'bytea', PG::BinaryEncoder::Bytea, PG::BinaryDecoder::Bytea
            register_type 1, 'bool', PG::BinaryEncoder::Boolean, PG::BinaryDecoder::Boolean
            register_type 1, 'float4', PG::BinaryEncoder::Float4, PG::BinaryDecoder::Float
            register_type 1, 'float8', PG::BinaryEncoder::Float8, PG::BinaryDecoder::Float
            register_type 1, 'timestamp', PG::BinaryEncoder::TimestampUtc, PG::BinaryDecoder::TimestampUtc
            register_type 1, 'timestamptz', PG::BinaryEncoder::TimestampUtc, PG::BinaryDecoder::TimestampUtcToLocal
            register_type 1, 'date', PG::BinaryEncoder::Date, PG::BinaryDecoder::Date

            self
    end

Also aliased as: define_default_types
register_type(format, name, encoder_class, decoder_class) click to toggle source

Register the given `encoder_class` and/or `decoder_class` for casting a PostgreSQL type.

`name` must correspond to the `typname` column in the `pg_type` table. `format` can be 0 for text format and 1 for binary.

    # File lib/pg/basic_type_registry.rb, line 208
    def register_type(format, name, encoder_class, decoder_class)
            register_coder(encoder_class.new(name: name, format: format).freeze) if encoder_class
            register_coder(decoder_class.new(name: name, format: format).freeze) if decoder_class
            self
    end