BasicTypeRegistry

class
Superclass
Object
Included Modules
PG::BasicTypeRegistry::Checker

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)

Constants

DEFAULT_TYPE_REGISTRY

@private

Public Class Methods

anchor
new()
# File lib/pg/basic_type_registry.rb, line 164
def initialize
        # The key of these hashs maps to the `typname` column from the table pg_type.
        @coders_by_name = []
end

Public Instance Methods

anchor
alias_type(format, new, old)

Alias the old type to the new type.

# File lib/pg/basic_type_registry.rb, line 200
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
anchor
coders_for(format, direction)

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 172
def coders_for(format, direction)
        check_format_and_direction(format, direction)
        @coders_by_name[format]&.[](direction)
end
anchor
define_default_types()
anchor
register_coder(coder)

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 181
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
anchor
register_default_types()

Populate the registry with all builtin types of ruby-pg

# File lib/pg/basic_type_registry.rb, line 213
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'

        register_type 0, 'numeric', PG::TextEncoder::Numeric, PG::TextDecoder::Numeric
        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
        # There is no PG::TextEncoder::Bytea, because it's simple and more efficient to send bytea-data
        # in binary format, either with PG::BinaryEncoder::Bytea or in Hash param format.
        register_type 0, 'bytea', nil, 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'

        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 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', nil, PG::BinaryDecoder::Float
        register_type 1, 'float8', nil, PG::BinaryDecoder::Float
        register_type 1, 'timestamp', nil, PG::BinaryDecoder::TimestampUtc
        register_type 1, 'timestamptz', nil, PG::BinaryDecoder::TimestampUtcToLocal

        self
end
Also aliased as: define_default_types
anchor
register_type(format, name, encoder_class, decoder_class)

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 193
def register_type(format, name, encoder_class, decoder_class)
        register_coder(encoder_class.new(name: name, format: format)) if encoder_class
        register_coder(decoder_class.new(name: name, format: format)) if decoder_class
        self
end