# class PG::TypeMapByColumn

This type map casts values by a coder assigned per field/column.

Each `PG::TypeMapByColumn` has a fixed list of either encoders or decoders, that is defined at `TypeMapByColumn.new` . A type map with encoders is usable for type casting query bind parameters and COPY data for `PG::Connection#put_copy_data` . A type map with decoders is usable for type casting of result values and COPY data from `PG::Connection#get_copy_data` .

`PG::TypeMapByColumn` objects are in particular useful in conjunction with prepared statements, since they can be cached alongside with the statement handle.

This type map strategy is also used internally by `PG::TypeMapByOid`, when the number of rows of a result set exceeds a given limit.

### Public Class Methods

PG::TypeMapByColumn.new( coders ) click to toggle source

Builds a new type map and assigns a list of coders for the given column. `coders` must be an Array of `PG::Coder` objects or `nil` values. The length of the Array corresponds to the number of columns or bind parameters this type map is usable for.

A `nil` value will forward the given field to the `default_type_map` .

    static VALUE
    pg_tmbc_init(VALUE self, VALUE conv_ary)
    {
            int i;
            t_tmbc *this;
            int conv_ary_len;

            Check_Type(self, T_DATA);
            Check_Type(conv_ary, T_ARRAY);
            conv_ary_len = RARRAY_LEN(conv_ary);
            this = xmalloc(sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * conv_ary_len);
            /* Set nfields to 0 at first, so that GC mark function doesn't access uninitialized memory. */
            this->nfields = 0;
            this->typemap.funcs = pg_tmbc_funcs;
            this->typemap.default_typemap = pg_typemap_all_strings;
            DATA_PTR(self) = this;

            for(i=0; i<conv_ary_len; i++)
            {
                    VALUE obj = rb_ary_entry(conv_ary, i);

                    if( obj == Qnil ){
                            /* no type cast */
                            this->convs[i].cconv = NULL;
                    } else if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
                            Data_Get_Struct(obj, t_pg_coder, this->convs[i].cconv);
                    } else {
                            rb_raise(rb_eArgError, "argument %d has invalid type %s (should be nil or some kind of PG::Coder)",
                                                             i+1, rb_obj_classname( obj ));
                    }
            }

            this->nfields = conv_ary_len;

            return self;
    }

### Public Instance Methods

coders → Array click to toggle source

Array of `PG::Coder` objects. The length of the Array corresponds to the number of columns or bind parameters this type map is usable for.

    static VALUE
    pg_tmbc_coders(VALUE self)
    {
            int i;
            t_tmbc *this = DATA_PTR( self );
            VALUE ary_coders = rb_ary_new();

            for( i=0; i<this->nfields; i++){
                    t_pg_coder *conv = this->convs[i].cconv;
                    if( conv ) {
                            rb_ary_push( ary_coders, conv->coder_obj );
                    } else {
                            rb_ary_push( ary_coders, Qnil );
                    }
            }

            return rb_obj_freeze(ary_coders);
    }

inspect() click to toggle source

    # File lib/pg/type_map_by_column.rb, line 11
    def inspect
            type_strings = coders.map{|c| c ? c.inspect_short : 'nil' }
            "#<#{self.class} #{type_strings.join(' ')}>"
    end

oids() click to toggle source

Returns the type oids of the assigned coders.

    # File lib/pg/type_map_by_column.rb, line 7
    def oids
            coders.map{|c| c.oid if c }
    end