# class PG::TypeMapByOid

This type map casts values based on the type OID of the given column in the result set.

This type map is only suitable to cast values from `PG::Result` objects. Therefore only decoders might be assigned by the `add_coder` method.

Fields with no match to any of the registered type OID / format combination are forwarded to the default_type_map .

### Public Instance Methods

add_coder( coder ) click to toggle source

Assigns a new `PG::Coder` object to the type map. The decoder is registered for type casts based on it's `PG::Coder#oid` and `PG::Coder#format` attributes.

Later changes of the oid or format code within the coder object will have no effect to the type map.

    static VALUE
    pg_tmbo_add_coder( VALUE self, VALUE coder )
    {
            VALUE hash;
            t_tmbo *this = DATA_PTR( self );
            t_pg_coder *p_coder;
            struct pg_tmbo_oid_cache_entry *p_ce;

            if( !rb_obj_is_kind_of(coder, rb_cPG_Coder) )
                    rb_raise(rb_eArgError, "invalid type %s (should be some kind of PG::Coder)",
                                                            rb_obj_classname( coder ));

            Data_Get_Struct(coder, t_pg_coder, p_coder);

            if( p_coder->format < 0 || p_coder->format > 1 )
                    rb_raise(rb_eArgError, "invalid format code %d", p_coder->format);

            /* Update cache entry */
            p_ce = CACHE_LOOKUP(this, p_coder->format, p_coder->oid);
            p_ce->oid = p_coder->oid;
            p_ce->p_coder = p_coder;
            /* Write coder into the hash of the given format */
            hash = this->format[p_coder->format].oid_to_coder;
            rb_hash_aset( hash, UINT2NUM(p_coder->oid), coder);

            return self;
    }

build_column_map( result ) click to toggle source

This builds a `PG::TypeMapByColumn` that fits to the given `PG::Result` object based on it's type OIDs.

    static VALUE
    pg_tmbo_build_column_map( VALUE self, VALUE result )
    {
            t_tmbo *this = DATA_PTR( self );

            if ( !rb_obj_is_kind_of(result, rb_cPGresult) ) {
                    rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::Result)",
                                    rb_obj_classname( result ) );
            }

            return pg_tmbo_build_type_map_for_result2( this, pgresult_get(result) );
    }

coders → Array click to toggle source

Array of all assigned `PG::Coder` objects.

    static VALUE
    pg_tmbo_coders( VALUE self )
    {
            t_tmbo *this = DATA_PTR( self );

            return rb_ary_concat(
                            rb_funcall(this->format[0].oid_to_coder, rb_intern("values"), 0),
                            rb_funcall(this->format[1].oid_to_coder, rb_intern("values"), 0));
    }

max_rows_for_online_lookup → Integer click to toggle source

    static VALUE
    pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
    {
            t_tmbo *this = DATA_PTR( self );
            return INT2NUM(this->max_rows_for_online_lookup);
    }

max_rows_for_online_lookup = number click to toggle source

Threshold for doing Hash lookups versus creation of a dedicated `PG::TypeMapByColumn`. The type map will do Hash lookups for each result value, if the number of rows is below or equal `number`.

    static VALUE
    pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
    {
            t_tmbo *this = DATA_PTR( self );
            this->max_rows_for_online_lookup = NUM2INT(value);
            return value;
    }

rm_coder( format, oid ) click to toggle source

Removes a `PG::Coder` object from the type map based on the given oid and format codes.

Returns the removed coder object.

    static VALUE
    pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
    {
            VALUE hash;
            VALUE coder;
            t_tmbo *this = DATA_PTR( self );
            int i_format = NUM2INT(format);
            struct pg_tmbo_oid_cache_entry *p_ce;

            if( i_format < 0 || i_format > 1 )
                    rb_raise(rb_eArgError, "invalid format code %d", i_format);

            /* Mark the cache entry as empty */
            p_ce = CACHE_LOOKUP(this, i_format, NUM2UINT(oid));
            p_ce->oid = 0;
            p_ce->p_coder = NULL;
            hash = this->format[i_format].oid_to_coder;
            coder = rb_hash_delete( hash, oid );

            return coder;
    }