# class PG::CompositeCoder

This is the base class for all type cast classes of PostgreSQL types, that are made up of some sub type.

See `PG::TextEncoder::Array`, `PG::TextDecoder::Array`, `PG::BinaryEncoder::Array`, `PG::BinaryDecoder::Array`, etc.

### Attributes

elements_type[R]

### Public Instance Methods

delimiter → String click to toggle source

The character that separates values within the composite type.

    static VALUE
    pg_coder_delimiter_get(VALUE self)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            return rb_str_new(&this->delimiter, 1);
    }

delimiter = String click to toggle source

Specifies the character that separates values within the composite type. The default is a comma. This must be a single one-byte character. It is only used by text coders and ignored by binary coders.

    static VALUE
    pg_coder_delimiter_set(VALUE self, VALUE delimiter)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            rb_check_frozen(self);
            StringValue(delimiter);
            if(RSTRING_LEN(delimiter) != 1)
                    rb_raise( rb_eArgError, "delimiter size must be one byte");
            this->delimiter = *RSTRING_PTR(delimiter);
            return delimiter;
    }

dimensions → Integer | nil click to toggle source

Get number of enforced array dimensions or `nil` if not set.

See `dimensions=`

    static VALUE
    pg_coder_dimensions_get(VALUE self)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            return this->dimensions < 0 ? Qnil : INT2NUM(this->dimensions);
    }

dimensions = Integer click to toggle source
dimensions = nil

Set number of array dimensions to be encoded.

This property ensures, that this number of dimensions is always encoded. If less dimensions than this number are in the given value, an ArgumentError is raised. If more dimensions than this number are in the value, the Array value is passed to the next encoder.

Setting dimensions is especially useful, when a Record shall be encoded into an Array, since the Array encoder can not distinguish if the array shall be encoded as a higher dimension or as a record otherwise.

The default is `nil`.

See `dimensions`

    static VALUE
    pg_coder_dimensions_set(VALUE self, VALUE dimensions)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            rb_check_frozen(self);
            if(!NIL_P(dimensions) && NUM2INT(dimensions) < 0)
                    rb_raise( rb_eArgError, "dimensions must be nil or >= 0");
            this->dimensions = NIL_P(dimensions) ? -1 : NUM2INT(dimensions);
            return dimensions;
    }

elements_type = coder click to toggle source

Specifies the `PG::Coder` object that is used to encode or decode the single elementes of this composite type.

If set to `nil` all values are encoded and decoded as String objects.

    static VALUE
    pg_coder_elements_type_set(VALUE self, VALUE elem_type)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA( self );

            rb_check_frozen(self);
            if ( NIL_P(elem_type) ){
                    this->elem = NULL;
            } else if ( rb_obj_is_kind_of(elem_type, rb_cPG_Coder) ){
                    this->elem = RTYPEDDATA_DATA( elem_type );
            } else {
                    rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::Coder)",
                                    rb_obj_classname( elem_type ) );
            }

            rb_iv_set( self, "@elements_type", elem_type );
            return elem_type;
    }

inspect() click to toggle source
Calls superclass method `PG::Coder#inspect`

    # File lib/pg/coder.rb, line 83
    def inspect
            str = super
            str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation#{dimensions && " #{dimensions} dimensions"}"
            str
    end

needs_quotation = Boolean click to toggle source

Specifies whether the assigned `elements_type` requires quotation marks to be transferred safely. Encoding with `needs_quotation=`false is somewhat faster. It is only used by text coders and ignored by binary coders.

The default is `true`. This option is ignored for decoding of values.

    static VALUE
    pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            rb_check_frozen(self);
            this->needs_quotation = RTEST(needs_quotation);
            return needs_quotation;
    }

needs_quotation → Boolean click to toggle source

Specifies whether the assigned `elements_type` requires quotation marks to be transferred safely.

    static VALUE
    pg_coder_needs_quotation_get(VALUE self)
    {
            t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
            return this->needs_quotation ? Qtrue : Qfalse;
    }

to_h() click to toggle source
Calls superclass method `PG::Coder#to_h`

    # File lib/pg/coder.rb, line 73
    def to_h
            h = { **super,
                    elements_type: elements_type,
                    needs_quotation: needs_quotation?,
                    delimiter: delimiter,
            }
            h[:dimensions] = dimensions if dimensions # Write only when set, for Marshal compat with pg<1.6
            h
    end