class PG::BasicTypeMapForQueries - pg-0.21.0 Documentation

# class PG::BasicTypeMapForQueries

Simple set of rules for type casting common Ruby types to PostgreSQL.

OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the PostgreSQL's pg_type table in ::new .

Query params are type casted based on the class of the given value.

Higher level libraries will most likely not make use of this class, but use their own derivation of PG::TypeMapByClass or another set of rules to choose suitable encoders and decoders for the values to be sent.

Example:

    conn = PG::Connection.new
    # Assign a default ruleset for type casts of input and output values.
    conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
    # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
    # The format of the parameter is set to 1 (binary) and the OID of this parameter is set to 20 (int8).
    res = conn.exec_params( "SELECT $1", [5] )

### Constants

DEFAULT_ARRAY_TYPE_MAP
DEFAULT_TYPE_MAP

### Public Class Methods

new(connection) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 359
    def initialize(connection)
            @coder_maps = build_coder_maps(connection)

            populate_encoder_list
            @array_encoders_by_klass = array_encoders_by_klass
            @anyarray_encoder = coder_by_name(0, :encoder, '_any')
    end

### Private Instance Methods

array_encoders_by_klass() click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 391
    def array_encoders_by_klass
            DEFAULT_ARRAY_TYPE_MAP.inject({}) do |h, (klass, (format, name))|
                    h[klass] = coder_by_name(format, :encoder, name)
                    h
            end
    end

coder_by_name(format, direction, name) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 369
    def coder_by_name(format, direction, name)
            check_format_and_direction(format, direction)
            @coder_maps[format][direction].coder_by_name(name)
    end

get_array_type(value) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 398
    def get_array_type(value)
            elem = value
            while elem.kind_of?(Array)
                    elem = elem.first
            end
            @array_encoders_by_klass[elem.class] ||
                            elem.class.ancestors.lazy.map{|ancestor| @array_encoders_by_klass[ancestor] }.find{|a| a } ||
                            @anyarray_encoder
    end

populate_encoder_list() click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 374
    def populate_encoder_list
            DEFAULT_TYPE_MAP.each do |klass, selector|
                    if Array === selector
                            format, name, oid_name = selector
                            coder = coder_by_name(format, :encoder, name).dup
                            if oid_name
                                    coder.oid = coder_by_name(format, :encoder, oid_name).oid
                            else
                                    coder.oid = 0
                            end
                            self[klass] = coder
                    else
                            self[klass] = selector
                    end
            end
    end