rowtypes.c File Reference

#include "postgres.h"
#include <ctype.h>
#include "access/detoast.h"
#include "access/htup_details.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"

Include dependency graph for rowtypes.c:

Go to the source code of this file.

Data Structures
struct	ColumnIOData
struct	RecordIOData
struct	ColumnCompareData
struct	RecordCompareData

Typedefs
typedef struct ColumnIOData	ColumnIOData
typedef struct RecordIOData	RecordIOData
typedef struct ColumnCompareData	ColumnCompareData
typedef struct RecordCompareData	RecordCompareData

Functions
Datum	record_in (PG_FUNCTION_ARGS)
Datum	record_out (PG_FUNCTION_ARGS)
Datum	record_recv (PG_FUNCTION_ARGS)
Datum	record_send (PG_FUNCTION_ARGS)
static int	record_cmp (FunctionCallInfo fcinfo)
Datum	record_eq (PG_FUNCTION_ARGS)
Datum	record_ne (PG_FUNCTION_ARGS)
Datum	record_lt (PG_FUNCTION_ARGS)
Datum	record_gt (PG_FUNCTION_ARGS)
Datum	record_le (PG_FUNCTION_ARGS)
Datum	record_ge (PG_FUNCTION_ARGS)
Datum	btrecordcmp (PG_FUNCTION_ARGS)
Datum	record_larger (PG_FUNCTION_ARGS)
Datum	record_smaller (PG_FUNCTION_ARGS)
static int	record_image_cmp (FunctionCallInfo fcinfo)
Datum	record_image_eq (PG_FUNCTION_ARGS)
Datum	record_image_ne (PG_FUNCTION_ARGS)
Datum	record_image_lt (PG_FUNCTION_ARGS)
Datum	record_image_gt (PG_FUNCTION_ARGS)
Datum	record_image_le (PG_FUNCTION_ARGS)
Datum	record_image_ge (PG_FUNCTION_ARGS)
Datum	btrecordimagecmp (PG_FUNCTION_ARGS)
Datum	hash_record (PG_FUNCTION_ARGS)
Datum	hash_record_extended (PG_FUNCTION_ARGS)

Typedef Documentation

ColumnCompareData

typedef struct ColumnCompareData ColumnCompareData

ColumnIOData

typedef struct ColumnIOData ColumnIOData

RecordCompareData

typedef struct RecordCompareData RecordCompareData

RecordIOData

typedef struct RecordIOData RecordIOData

Function Documentation

btrecordcmp()

Datum btrecordcmp

(

PG_FUNCTION_ARGS

)

Definition at line 1313 of file rowtypes.c.

{
    PG_RETURN_INT32(record_cmp(fcinfo));
}

References PG_RETURN_INT32, and record_cmp().

btrecordimagecmp()

Datum btrecordimagecmp

(

PG_FUNCTION_ARGS

)

Definition at line 1801 of file rowtypes.c.

{
    PG_RETURN_INT32(record_image_cmp(fcinfo));
}

References PG_RETURN_INT32, and record_image_cmp().

hash_record()

Datum hash_record

(

PG_FUNCTION_ARGS

)

Definition at line 1812 of file rowtypes.c.

{
    HeapTupleHeader record = PG_GETARG_HEAPTUPLEHEADER(0);
    uint32      result = 0;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupdesc;
    HeapTupleData tuple;
    int         ncolumns;
    RecordCompareData *my_extra;
    Datum      *values;
    bool       *nulls;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from tuple */
    tupType = HeapTupleHeaderGetTypeId(record);
    tupTypmod = HeapTupleHeaderGetTypMod(record);
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /* Build temporary HeapTuple control structure */
    tuple.t_len = HeapTupleHeaderGetDatumLength(record);
    ItemPointerSetInvalid(&(tuple.t_self));
    tuple.t_tableOid = InvalidOid;
    tuple.t_data = record;
 
    /*
     * We arrange to look up the needed hashing info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncolumns * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncolumns;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType ||
        my_extra->record1_typmod != tupTypmod)
    {
        MemSet(my_extra->columns, 0, ncolumns * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType;
        my_extra->record1_typmod = tupTypmod;
    }
 
    /* Break down the tuple into fields */
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
    heap_deform_tuple(&tuple, tupdesc, values, nulls);
 
    for (int i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att;
        TypeCacheEntry *typentry;
        uint32      element_hash;
 
        att = TupleDescAttr(tupdesc, i);
 
        if (att->attisdropped)
            continue;
 
        /*
         * Lookup the hash function if not done already
         */
        typentry = my_extra->columns[i].typentry;
        if (typentry == NULL ||
            typentry->type_id != att->atttypid)
        {
            typentry = lookup_type_cache(att->atttypid,
                                         TYPECACHE_HASH_PROC_FINFO);
            if (!OidIsValid(typentry->hash_proc_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify a hash function for type %s",
                                format_type_be(typentry->type_id))));
            my_extra->columns[i].typentry = typentry;
        }
 
        /* Compute hash of element */
        if (nulls[i])
        {
            element_hash = 0;
        }
        else
        {
            LOCAL_FCINFO(locfcinfo, 1);
 
            InitFunctionCallInfoData(*locfcinfo, &typentry->hash_proc_finfo, 1,
                                     att->attcollation, NULL, NULL);
            locfcinfo->args[0].value = values[i];
            locfcinfo->args[0].isnull = false;
            element_hash = DatumGetUInt32(FunctionCallInvoke(locfcinfo));
 
            /* We don't expect hash support functions to return null */
            Assert(!locfcinfo->isnull);
        }
 
        /* see hash_array() */
        result = (result << 5) - result + element_hash;
    }
 
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record, 0);
 
    PG_RETURN_UINT32(result);
}

References Assert, check_stack_depth(), RecordCompareData::columns, DatumGetUInt32(), element_hash(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, TypeCacheEntry::hash_proc_finfo, heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, if(), InitFunctionCallInfoData, InvalidOid, ItemPointerSetInvalid(), LOCAL_FCINFO, lookup_rowtype_tupdesc(), lookup_type_cache(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordCompareData::ncolumns, OidIsValid, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, PG_RETURN_UINT32, RecordCompareData::record1_type, RecordCompareData::record1_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, TypeCacheEntry::type_id, TYPECACHE_HASH_PROC_FINFO, ColumnCompareData::typentry, and values.

hash_record_extended()

Datum hash_record_extended

(

PG_FUNCTION_ARGS

)

Definition at line 1932 of file rowtypes.c.

{
    HeapTupleHeader record = PG_GETARG_HEAPTUPLEHEADER(0);
    uint64      seed = PG_GETARG_INT64(1);
    uint64      result = 0;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupdesc;
    HeapTupleData tuple;
    int         ncolumns;
    RecordCompareData *my_extra;
    Datum      *values;
    bool       *nulls;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from tuple */
    tupType = HeapTupleHeaderGetTypeId(record);
    tupTypmod = HeapTupleHeaderGetTypMod(record);
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /* Build temporary HeapTuple control structure */
    tuple.t_len = HeapTupleHeaderGetDatumLength(record);
    ItemPointerSetInvalid(&(tuple.t_self));
    tuple.t_tableOid = InvalidOid;
    tuple.t_data = record;
 
    /*
     * We arrange to look up the needed hashing info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncolumns * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncolumns;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType ||
        my_extra->record1_typmod != tupTypmod)
    {
        MemSet(my_extra->columns, 0, ncolumns * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType;
        my_extra->record1_typmod = tupTypmod;
    }
 
    /* Break down the tuple into fields */
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
    heap_deform_tuple(&tuple, tupdesc, values, nulls);
 
    for (int i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att;
        TypeCacheEntry *typentry;
        uint64      element_hash;
 
        att = TupleDescAttr(tupdesc, i);
 
        if (att->attisdropped)
            continue;
 
        /*
         * Lookup the hash function if not done already
         */
        typentry = my_extra->columns[i].typentry;
        if (typentry == NULL ||
            typentry->type_id != att->atttypid)
        {
            typentry = lookup_type_cache(att->atttypid,
                                         TYPECACHE_HASH_EXTENDED_PROC_FINFO);
            if (!OidIsValid(typentry->hash_extended_proc_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify an extended hash function for type %s",
                                format_type_be(typentry->type_id))));
            my_extra->columns[i].typentry = typentry;
        }
 
        /* Compute hash of element */
        if (nulls[i])
        {
            element_hash = 0;
        }
        else
        {
            LOCAL_FCINFO(locfcinfo, 2);
 
            InitFunctionCallInfoData(*locfcinfo, &typentry->hash_extended_proc_finfo, 2,
                                     att->attcollation, NULL, NULL);
            locfcinfo->args[0].value = values[i];
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = Int64GetDatum(seed);
            locfcinfo->args[0].isnull = false;
            element_hash = DatumGetUInt64(FunctionCallInvoke(locfcinfo));
 
            /* We don't expect hash support functions to return null */
            Assert(!locfcinfo->isnull);
        }
 
        /* see hash_array_extended() */
        result = (result << 5) - result + element_hash;
    }
 
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record, 0);
 
    PG_RETURN_UINT64(result);
}

References Assert, check_stack_depth(), RecordCompareData::columns, DatumGetUInt64(), element_hash(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, TypeCacheEntry::hash_extended_proc_finfo, heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, if(), InitFunctionCallInfoData, Int64GetDatum(), InvalidOid, ItemPointerSetInvalid(), LOCAL_FCINFO, lookup_rowtype_tupdesc(), lookup_type_cache(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordCompareData::ncolumns, OidIsValid, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, PG_GETARG_INT64, PG_RETURN_UINT64, RecordCompareData::record1_type, RecordCompareData::record1_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC_FINFO, ColumnCompareData::typentry, and values.

record_cmp()

static int record_cmp ( FunctionCallInfo  fcinfo )

static

Definition at line 823 of file rowtypes.c.

{
    HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    int         result = 0;
    Oid         tupType1;
    Oid         tupType2;
    int32       tupTypmod1;
    int32       tupTypmod2;
    TupleDesc   tupdesc1;
    TupleDesc   tupdesc2;
    HeapTupleData tuple1;
    HeapTupleData tuple2;
    int         ncolumns1;
    int         ncolumns2;
    RecordCompareData *my_extra;
    int         ncols;
    Datum      *values1;
    Datum      *values2;
    bool       *nulls1;
    bool       *nulls2;
    int         i1;
    int         i2;
    int         j;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from the tuples */
    tupType1 = HeapTupleHeaderGetTypeId(record1);
    tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    ncolumns1 = tupdesc1->natts;
    tupType2 = HeapTupleHeaderGetTypeId(record2);
    tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    ncolumns2 = tupdesc2->natts;
 
    /* Build temporary HeapTuple control structures */
    tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    ItemPointerSetInvalid(&(tuple1.t_self));
    tuple1.t_tableOid = InvalidOid;
    tuple1.t_data = record1;
    tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    ItemPointerSetInvalid(&(tuple2.t_self));
    tuple2.t_tableOid = InvalidOid;
    tuple2.t_data = record2;
 
    /*
     * We arrange to look up the needed comparison info just once per series
     * of calls, assuming the record types don't change underneath us.
     */
    ncols = Max(ncolumns1, ncolumns2);
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncols)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncols * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncols;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
        my_extra->record2_type = InvalidOid;
        my_extra->record2_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType1 ||
        my_extra->record1_typmod != tupTypmod1 ||
        my_extra->record2_type != tupType2 ||
        my_extra->record2_typmod != tupTypmod2)
    {
        MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType1;
        my_extra->record1_typmod = tupTypmod1;
        my_extra->record2_type = tupType2;
        my_extra->record2_typmod = tupTypmod2;
    }
 
    /* Break down the tuples into fields */
    values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
 
    /*
     * Scan corresponding columns, allowing for dropped columns in different
     * places in the two rows.  i1 and i2 are physical column indexes, j is
     * the logical column index.
     */
    i1 = i2 = j = 0;
    while (i1 < ncolumns1 || i2 < ncolumns2)
    {
        Form_pg_attribute att1;
        Form_pg_attribute att2;
        TypeCacheEntry *typentry;
        Oid         collation;
 
        /*
         * Skip dropped columns
         */
        if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
        {
            i1++;
            continue;
        }
        if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
        {
            i2++;
            continue;
        }
        if (i1 >= ncolumns1 || i2 >= ncolumns2)
            break;              /* we'll deal with mismatch below loop */
 
        att1 = TupleDescAttr(tupdesc1, i1);
        att2 = TupleDescAttr(tupdesc2, i2);
 
        /*
         * Have two matching columns, they must be same type
         */
        if (att1->atttypid != att2->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare dissimilar column types %s and %s at record column %d",
                            format_type_be(att1->atttypid),
                            format_type_be(att2->atttypid),
                            j + 1)));
 
        /*
         * If they're not same collation, we don't complain here, but the
         * comparison function might.
         */
        collation = att1->attcollation;
        if (collation != att2->attcollation)
            collation = InvalidOid;
 
        /*
         * Lookup the comparison function if not done already
         */
        typentry = my_extra->columns[j].typentry;
        if (typentry == NULL ||
            typentry->type_id != att1->atttypid)
        {
            typentry = lookup_type_cache(att1->atttypid,
                                         TYPECACHE_CMP_PROC_FINFO);
            if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify a comparison function for type %s",
                                format_type_be(typentry->type_id))));
            my_extra->columns[j].typentry = typentry;
        }
 
        /*
         * We consider two NULLs equal; NULL > not-NULL.
         */
        if (!nulls1[i1] || !nulls2[i2])
        {
            LOCAL_FCINFO(locfcinfo, 2);
            int32       cmpresult;
 
            if (nulls1[i1])
            {
                /* arg1 is greater than arg2 */
                result = 1;
                break;
            }
            if (nulls2[i2])
            {
                /* arg1 is less than arg2 */
                result = -1;
                break;
            }
 
            /* Compare the pair of elements */
            InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
                                     collation, NULL, NULL);
            locfcinfo->args[0].value = values1[i1];
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = values2[i2];
            locfcinfo->args[1].isnull = false;
            cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));
 
            /* We don't expect comparison support functions to return null */
            Assert(!locfcinfo->isnull);
 
            if (cmpresult < 0)
            {
                /* arg1 is less than arg2 */
                result = -1;
                break;
            }
            else if (cmpresult > 0)
            {
                /* arg1 is greater than arg2 */
                result = 1;
                break;
            }
        }
 
        /* equal, so continue to next column */
        i1++, i2++, j++;
    }
 
    /*
     * If we didn't break out of the loop early, check for column count
     * mismatch.  (We do not report such mismatch if we found unequal column
     * values; is that a feature or a bug?)
     */
    if (result == 0)
    {
        if (i1 != ncolumns1 || i2 != ncolumns2)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare record types with different numbers of columns")));
    }
 
    pfree(values1);
    pfree(nulls1);
    pfree(values2);
    pfree(nulls2);
    ReleaseTupleDesc(tupdesc1);
    ReleaseTupleDesc(tupdesc2);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record1, 0);
    PG_FREE_IF_COPY(record2, 1);
 
    return result;
}

References Assert, check_stack_depth(), TypeCacheEntry::cmp_proc_finfo, RecordCompareData::columns, DatumGetInt32(), ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, if(), InitFunctionCallInfoData, InvalidOid, ItemPointerSetInvalid(), j, LOCAL_FCINFO, lookup_rowtype_tupdesc(), lookup_type_cache(), Max, MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordCompareData::ncolumns, OidIsValid, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, RecordCompareData::record1_type, RecordCompareData::record1_typmod, RecordCompareData::record2_type, RecordCompareData::record2_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, TypeCacheEntry::type_id, TYPECACHE_CMP_PROC_FINFO, and ColumnCompareData::typentry.

Referenced by btrecordcmp(), record_ge(), record_gt(), record_larger(), record_le(), record_lt(), and record_smaller().

record_eq()

Datum record_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1067 of file rowtypes.c.

{
    HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    bool        result = true;
    Oid         tupType1;
    Oid         tupType2;
    int32       tupTypmod1;
    int32       tupTypmod2;
    TupleDesc   tupdesc1;
    TupleDesc   tupdesc2;
    HeapTupleData tuple1;
    HeapTupleData tuple2;
    int         ncolumns1;
    int         ncolumns2;
    RecordCompareData *my_extra;
    int         ncols;
    Datum      *values1;
    Datum      *values2;
    bool       *nulls1;
    bool       *nulls2;
    int         i1;
    int         i2;
    int         j;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from the tuples */
    tupType1 = HeapTupleHeaderGetTypeId(record1);
    tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    ncolumns1 = tupdesc1->natts;
    tupType2 = HeapTupleHeaderGetTypeId(record2);
    tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    ncolumns2 = tupdesc2->natts;
 
    /* Build temporary HeapTuple control structures */
    tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    ItemPointerSetInvalid(&(tuple1.t_self));
    tuple1.t_tableOid = InvalidOid;
    tuple1.t_data = record1;
    tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    ItemPointerSetInvalid(&(tuple2.t_self));
    tuple2.t_tableOid = InvalidOid;
    tuple2.t_data = record2;
 
    /*
     * We arrange to look up the needed comparison info just once per series
     * of calls, assuming the record types don't change underneath us.
     */
    ncols = Max(ncolumns1, ncolumns2);
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncols)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncols * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncols;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
        my_extra->record2_type = InvalidOid;
        my_extra->record2_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType1 ||
        my_extra->record1_typmod != tupTypmod1 ||
        my_extra->record2_type != tupType2 ||
        my_extra->record2_typmod != tupTypmod2)
    {
        MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType1;
        my_extra->record1_typmod = tupTypmod1;
        my_extra->record2_type = tupType2;
        my_extra->record2_typmod = tupTypmod2;
    }
 
    /* Break down the tuples into fields */
    values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
 
    /*
     * Scan corresponding columns, allowing for dropped columns in different
     * places in the two rows.  i1 and i2 are physical column indexes, j is
     * the logical column index.
     */
    i1 = i2 = j = 0;
    while (i1 < ncolumns1 || i2 < ncolumns2)
    {
        LOCAL_FCINFO(locfcinfo, 2);
        Form_pg_attribute att1;
        Form_pg_attribute att2;
        TypeCacheEntry *typentry;
        Oid         collation;
        bool        oprresult;
 
        /*
         * Skip dropped columns
         */
        if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
        {
            i1++;
            continue;
        }
        if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
        {
            i2++;
            continue;
        }
        if (i1 >= ncolumns1 || i2 >= ncolumns2)
            break;              /* we'll deal with mismatch below loop */
 
        att1 = TupleDescAttr(tupdesc1, i1);
        att2 = TupleDescAttr(tupdesc2, i2);
 
        /*
         * Have two matching columns, they must be same type
         */
        if (att1->atttypid != att2->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare dissimilar column types %s and %s at record column %d",
                            format_type_be(att1->atttypid),
                            format_type_be(att2->atttypid),
                            j + 1)));
 
        /*
         * If they're not same collation, we don't complain here, but the
         * equality function might.
         */
        collation = att1->attcollation;
        if (collation != att2->attcollation)
            collation = InvalidOid;
 
        /*
         * Lookup the equality function if not done already
         */
        typentry = my_extra->columns[j].typentry;
        if (typentry == NULL ||
            typentry->type_id != att1->atttypid)
        {
            typentry = lookup_type_cache(att1->atttypid,
                                         TYPECACHE_EQ_OPR_FINFO);
            if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify an equality operator for type %s",
                                format_type_be(typentry->type_id))));
            my_extra->columns[j].typentry = typentry;
        }
 
        /*
         * We consider two NULLs equal; NULL > not-NULL.
         */
        if (!nulls1[i1] || !nulls2[i2])
        {
            if (nulls1[i1] || nulls2[i2])
            {
                result = false;
                break;
            }
 
            /* Compare the pair of elements */
            InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
                                     collation, NULL, NULL);
            locfcinfo->args[0].value = values1[i1];
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = values2[i2];
            locfcinfo->args[1].isnull = false;
            oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
            if (locfcinfo->isnull || !oprresult)
            {
                result = false;
                break;
            }
        }
 
        /* equal, so continue to next column */
        i1++, i2++, j++;
    }
 
    /*
     * If we didn't break out of the loop early, check for column count
     * mismatch.  (We do not report such mismatch if we found unequal column
     * values; is that a feature or a bug?)
     */
    if (result)
    {
        if (i1 != ncolumns1 || i2 != ncolumns2)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare record types with different numbers of columns")));
    }
 
    pfree(values1);
    pfree(nulls1);
    pfree(values2);
    pfree(nulls2);
    ReleaseTupleDesc(tupdesc1);
    ReleaseTupleDesc(tupdesc2);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record1, 0);
    PG_FREE_IF_COPY(record2, 1);
 
    PG_RETURN_BOOL(result);
}

References check_stack_depth(), RecordCompareData::columns, DatumGetBool(), TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, if(), InitFunctionCallInfoData, InvalidOid, ItemPointerSetInvalid(), j, LOCAL_FCINFO, lookup_rowtype_tupdesc(), lookup_type_cache(), Max, MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordCompareData::ncolumns, OidIsValid, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, PG_RETURN_BOOL, RecordCompareData::record1_type, RecordCompareData::record1_typmod, RecordCompareData::record2_type, RecordCompareData::record2_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, and ColumnCompareData::typentry.

Referenced by record_ne().

record_ge()

Datum record_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1307 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_cmp(fcinfo) >= 0);
}

References PG_RETURN_BOOL, and record_cmp().

record_gt()

Datum record_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1295 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_cmp(fcinfo) > 0);
}

References PG_RETURN_BOOL, and record_cmp().

record_image_cmp()

static int record_image_cmp ( FunctionCallInfo  fcinfo )

static

Definition at line 1349 of file rowtypes.c.

{
    HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    int         result = 0;
    Oid         tupType1;
    Oid         tupType2;
    int32       tupTypmod1;
    int32       tupTypmod2;
    TupleDesc   tupdesc1;
    TupleDesc   tupdesc2;
    HeapTupleData tuple1;
    HeapTupleData tuple2;
    int         ncolumns1;
    int         ncolumns2;
    RecordCompareData *my_extra;
    int         ncols;
    Datum      *values1;
    Datum      *values2;
    bool       *nulls1;
    bool       *nulls2;
    int         i1;
    int         i2;
    int         j;
 
    /* Extract type info from the tuples */
    tupType1 = HeapTupleHeaderGetTypeId(record1);
    tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    ncolumns1 = tupdesc1->natts;
    tupType2 = HeapTupleHeaderGetTypeId(record2);
    tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    ncolumns2 = tupdesc2->natts;
 
    /* Build temporary HeapTuple control structures */
    tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    ItemPointerSetInvalid(&(tuple1.t_self));
    tuple1.t_tableOid = InvalidOid;
    tuple1.t_data = record1;
    tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    ItemPointerSetInvalid(&(tuple2.t_self));
    tuple2.t_tableOid = InvalidOid;
    tuple2.t_data = record2;
 
    /*
     * We arrange to look up the needed comparison info just once per series
     * of calls, assuming the record types don't change underneath us.
     */
    ncols = Max(ncolumns1, ncolumns2);
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncols)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncols * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncols;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
        my_extra->record2_type = InvalidOid;
        my_extra->record2_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType1 ||
        my_extra->record1_typmod != tupTypmod1 ||
        my_extra->record2_type != tupType2 ||
        my_extra->record2_typmod != tupTypmod2)
    {
        MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType1;
        my_extra->record1_typmod = tupTypmod1;
        my_extra->record2_type = tupType2;
        my_extra->record2_typmod = tupTypmod2;
    }
 
    /* Break down the tuples into fields */
    values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
 
    /*
     * Scan corresponding columns, allowing for dropped columns in different
     * places in the two rows.  i1 and i2 are physical column indexes, j is
     * the logical column index.
     */
    i1 = i2 = j = 0;
    while (i1 < ncolumns1 || i2 < ncolumns2)
    {
        Form_pg_attribute att1;
        Form_pg_attribute att2;
 
        /*
         * Skip dropped columns
         */
        if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
        {
            i1++;
            continue;
        }
        if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
        {
            i2++;
            continue;
        }
        if (i1 >= ncolumns1 || i2 >= ncolumns2)
            break;              /* we'll deal with mismatch below loop */
 
        att1 = TupleDescAttr(tupdesc1, i1);
        att2 = TupleDescAttr(tupdesc2, i2);
 
        /*
         * Have two matching columns, they must be same type
         */
        if (att1->atttypid != att2->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare dissimilar column types %s and %s at record column %d",
                            format_type_be(att1->atttypid),
                            format_type_be(att2->atttypid),
                            j + 1)));
 
        /*
         * The same type should have the same length (or both should be
         * variable).
         */
        Assert(att1->attlen == att2->attlen);
 
        /*
         * We consider two NULLs equal; NULL > not-NULL.
         */
        if (!nulls1[i1] || !nulls2[i2])
        {
            int         cmpresult = 0;
 
            if (nulls1[i1])
            {
                /* arg1 is greater than arg2 */
                result = 1;
                break;
            }
            if (nulls2[i2])
            {
                /* arg1 is less than arg2 */
                result = -1;
                break;
            }
 
            /* Compare the pair of elements */
            if (att1->attbyval)
            {
                if (values1[i1] != values2[i2])
                    cmpresult = (values1[i1] < values2[i2]) ? -1 : 1;
            }
            else if (att1->attlen > 0)
            {
                cmpresult = memcmp(DatumGetPointer(values1[i1]),
                                   DatumGetPointer(values2[i2]),
                                   att1->attlen);
            }
            else if (att1->attlen == -1)
            {
                Size        len1,
                            len2;
                struct varlena *arg1val;
                struct varlena *arg2val;
 
                len1 = toast_raw_datum_size(values1[i1]);
                len2 = toast_raw_datum_size(values2[i2]);
                arg1val = PG_DETOAST_DATUM_PACKED(values1[i1]);
                arg2val = PG_DETOAST_DATUM_PACKED(values2[i2]);
 
                cmpresult = memcmp(VARDATA_ANY(arg1val),
                                   VARDATA_ANY(arg2val),
                                   Min(len1, len2) - VARHDRSZ);
                if ((cmpresult == 0) && (len1 != len2))
                    cmpresult = (len1 < len2) ? -1 : 1;
 
                if ((Pointer) arg1val != (Pointer) values1[i1])
                    pfree(arg1val);
                if ((Pointer) arg2val != (Pointer) values2[i2])
                    pfree(arg2val);
            }
            else
                elog(ERROR, "unexpected attlen: %d", att1->attlen);
 
            if (cmpresult < 0)
            {
                /* arg1 is less than arg2 */
                result = -1;
                break;
            }
            else if (cmpresult > 0)
            {
                /* arg1 is greater than arg2 */
                result = 1;
                break;
            }
        }
 
        /* equal, so continue to next column */
        i1++, i2++, j++;
    }
 
    /*
     * If we didn't break out of the loop early, check for column count
     * mismatch.  (We do not report such mismatch if we found unequal column
     * values; is that a feature or a bug?)
     */
    if (result == 0)
    {
        if (i1 != ncolumns1 || i2 != ncolumns2)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare record types with different numbers of columns")));
    }
 
    pfree(values1);
    pfree(nulls1);
    pfree(values2);
    pfree(nulls2);
    ReleaseTupleDesc(tupdesc1);
    ReleaseTupleDesc(tupdesc2);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record1, 0);
    PG_FREE_IF_COPY(record2, 1);
 
    return result;
}

References Assert, RecordCompareData::columns, DatumGetPointer(), elog, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, format_type_be(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, if(), InvalidOid, ItemPointerSetInvalid(), j, lookup_rowtype_tupdesc(), Max, MemoryContextAlloc(), MemSet, Min, TupleDescData::natts, RecordCompareData::ncolumns, palloc(), pfree(), PG_DETOAST_DATUM_PACKED, PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, RecordCompareData::record1_type, RecordCompareData::record1_typmod, RecordCompareData::record2_type, RecordCompareData::record2_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, toast_raw_datum_size(), TupleDescAttr, VARDATA_ANY, and VARHDRSZ.

Referenced by btrecordimagecmp(), record_image_ge(), record_image_gt(), record_image_le(), and record_image_lt().

record_image_eq()

Datum record_image_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1595 of file rowtypes.c.

{
    HeapTupleHeader record1 = PG_GETARG_HEAPTUPLEHEADER(0);
    HeapTupleHeader record2 = PG_GETARG_HEAPTUPLEHEADER(1);
    bool        result = true;
    Oid         tupType1;
    Oid         tupType2;
    int32       tupTypmod1;
    int32       tupTypmod2;
    TupleDesc   tupdesc1;
    TupleDesc   tupdesc2;
    HeapTupleData tuple1;
    HeapTupleData tuple2;
    int         ncolumns1;
    int         ncolumns2;
    RecordCompareData *my_extra;
    int         ncols;
    Datum      *values1;
    Datum      *values2;
    bool       *nulls1;
    bool       *nulls2;
    int         i1;
    int         i2;
    int         j;
 
    /* Extract type info from the tuples */
    tupType1 = HeapTupleHeaderGetTypeId(record1);
    tupTypmod1 = HeapTupleHeaderGetTypMod(record1);
    tupdesc1 = lookup_rowtype_tupdesc(tupType1, tupTypmod1);
    ncolumns1 = tupdesc1->natts;
    tupType2 = HeapTupleHeaderGetTypeId(record2);
    tupTypmod2 = HeapTupleHeaderGetTypMod(record2);
    tupdesc2 = lookup_rowtype_tupdesc(tupType2, tupTypmod2);
    ncolumns2 = tupdesc2->natts;
 
    /* Build temporary HeapTuple control structures */
    tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
    ItemPointerSetInvalid(&(tuple1.t_self));
    tuple1.t_tableOid = InvalidOid;
    tuple1.t_data = record1;
    tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
    ItemPointerSetInvalid(&(tuple2.t_self));
    tuple2.t_tableOid = InvalidOid;
    tuple2.t_data = record2;
 
    /*
     * We arrange to look up the needed comparison info just once per series
     * of calls, assuming the record types don't change underneath us.
     */
    ncols = Max(ncolumns1, ncolumns2);
    my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns < ncols)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordCompareData, columns) +
                               ncols * sizeof(ColumnCompareData));
        my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
        my_extra->ncolumns = ncols;
        my_extra->record1_type = InvalidOid;
        my_extra->record1_typmod = 0;
        my_extra->record2_type = InvalidOid;
        my_extra->record2_typmod = 0;
    }
 
    if (my_extra->record1_type != tupType1 ||
        my_extra->record1_typmod != tupTypmod1 ||
        my_extra->record2_type != tupType2 ||
        my_extra->record2_typmod != tupTypmod2)
    {
        MemSet(my_extra->columns, 0, ncols * sizeof(ColumnCompareData));
        my_extra->record1_type = tupType1;
        my_extra->record1_typmod = tupTypmod1;
        my_extra->record2_type = tupType2;
        my_extra->record2_typmod = tupTypmod2;
    }
 
    /* Break down the tuples into fields */
    values1 = (Datum *) palloc(ncolumns1 * sizeof(Datum));
    nulls1 = (bool *) palloc(ncolumns1 * sizeof(bool));
    heap_deform_tuple(&tuple1, tupdesc1, values1, nulls1);
    values2 = (Datum *) palloc(ncolumns2 * sizeof(Datum));
    nulls2 = (bool *) palloc(ncolumns2 * sizeof(bool));
    heap_deform_tuple(&tuple2, tupdesc2, values2, nulls2);
 
    /*
     * Scan corresponding columns, allowing for dropped columns in different
     * places in the two rows.  i1 and i2 are physical column indexes, j is
     * the logical column index.
     */
    i1 = i2 = j = 0;
    while (i1 < ncolumns1 || i2 < ncolumns2)
    {
        Form_pg_attribute att1;
        Form_pg_attribute att2;
 
        /*
         * Skip dropped columns
         */
        if (i1 < ncolumns1 && TupleDescAttr(tupdesc1, i1)->attisdropped)
        {
            i1++;
            continue;
        }
        if (i2 < ncolumns2 && TupleDescAttr(tupdesc2, i2)->attisdropped)
        {
            i2++;
            continue;
        }
        if (i1 >= ncolumns1 || i2 >= ncolumns2)
            break;              /* we'll deal with mismatch below loop */
 
        att1 = TupleDescAttr(tupdesc1, i1);
        att2 = TupleDescAttr(tupdesc2, i2);
 
        /*
         * Have two matching columns, they must be same type
         */
        if (att1->atttypid != att2->atttypid)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare dissimilar column types %s and %s at record column %d",
                            format_type_be(att1->atttypid),
                            format_type_be(att2->atttypid),
                            j + 1)));
 
        /*
         * We consider two NULLs equal; NULL > not-NULL.
         */
        if (!nulls1[i1] || !nulls2[i2])
        {
            if (nulls1[i1] || nulls2[i2])
            {
                result = false;
                break;
            }
 
            /* Compare the pair of elements */
            result = datum_image_eq(values1[i1], values2[i2], att1->attbyval, att2->attlen);
            if (!result)
                break;
        }
 
        /* equal, so continue to next column */
        i1++, i2++, j++;
    }
 
    /*
     * If we didn't break out of the loop early, check for column count
     * mismatch.  (We do not report such mismatch if we found unequal column
     * values; is that a feature or a bug?)
     */
    if (result)
    {
        if (i1 != ncolumns1 || i2 != ncolumns2)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("cannot compare record types with different numbers of columns")));
    }
 
    pfree(values1);
    pfree(nulls1);
    pfree(values2);
    pfree(nulls2);
    ReleaseTupleDesc(tupdesc1);
    ReleaseTupleDesc(tupdesc2);
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(record1, 0);
    PG_FREE_IF_COPY(record2, 1);
 
    PG_RETURN_BOOL(result);
}

References RecordCompareData::columns, datum_image_eq(), ereport, errcode(), errmsg(), ERROR, format_type_be(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, if(), InvalidOid, ItemPointerSetInvalid(), j, lookup_rowtype_tupdesc(), Max, MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordCompareData::ncolumns, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_HEAPTUPLEHEADER, PG_RETURN_BOOL, RecordCompareData::record1_type, RecordCompareData::record1_typmod, RecordCompareData::record2_type, RecordCompareData::record2_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and TupleDescAttr.

Referenced by record_image_ne().

record_image_ge()

Datum record_image_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1795 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_image_cmp(fcinfo) >= 0);
}

References PG_RETURN_BOOL, and record_image_cmp().

record_image_gt()

Datum record_image_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1783 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_image_cmp(fcinfo) > 0);
}

References PG_RETURN_BOOL, and record_image_cmp().

record_image_le()

Datum record_image_le

(

PG_FUNCTION_ARGS

)

Definition at line 1789 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_image_cmp(fcinfo) <= 0);
}

References PG_RETURN_BOOL, and record_image_cmp().

record_image_lt()

Datum record_image_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1777 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_image_cmp(fcinfo) < 0);
}

References PG_RETURN_BOOL, and record_image_cmp().

record_image_ne()

Datum record_image_ne

(

PG_FUNCTION_ARGS

)

Definition at line 1771 of file rowtypes.c.

{
    PG_RETURN_BOOL(!DatumGetBool(record_image_eq(fcinfo)));
}

References DatumGetBool(), PG_RETURN_BOOL, and record_image_eq().

record_in()

Datum record_in

(

PG_FUNCTION_ARGS

)

Definition at line 74 of file rowtypes.c.

{
    char       *string = PG_GETARG_CSTRING(0);
    Oid         tupType = PG_GETARG_OID(1);
    int32       tupTypmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    HeapTupleHeader result;
    TupleDesc   tupdesc;
    HeapTuple   tuple;
    RecordIOData *my_extra;
    bool        needComma = false;
    int         ncolumns;
    int         i;
    char       *ptr;
    Datum      *values;
    bool       *nulls;
    StringInfoData buf;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /*
     * Give a friendly error message if we did not get enough info to identify
     * the target record type.  (lookup_rowtype_tupdesc would fail anyway, but
     * with a non-user-friendly message.)  In ordinary SQL usage, we'll get -1
     * for typmod, since composite types and RECORD have no type modifiers at
     * the SQL level, and thus must fail for RECORD.  However some callers can
     * supply a valid typmod, and then we can do something useful for RECORD.
     */
    if (tupType == RECORDOID && tupTypmod < 0)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("input of anonymous composite types is not implemented")));
 
    /*
     * This comes from the composite type's pg_type.oid and stores system oids
     * in user tables, specifically DatumTupleFields. This oid must be
     * preserved by binary upgrades.
     */
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /*
     * We arrange to look up the needed I/O info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns != ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordIOData, columns) +
                               ncolumns * sizeof(ColumnIOData));
        my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
        my_extra->record_type = InvalidOid;
        my_extra->record_typmod = 0;
    }
 
    if (my_extra->record_type != tupType ||
        my_extra->record_typmod != tupTypmod)
    {
        MemSet(my_extra, 0,
               offsetof(RecordIOData, columns) +
               ncolumns * sizeof(ColumnIOData));
        my_extra->record_type = tupType;
        my_extra->record_typmod = tupTypmod;
        my_extra->ncolumns = ncolumns;
    }
 
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
 
    /*
     * Scan the string.  We use "buf" to accumulate the de-quoted data for
     * each column, which is then fed to the appropriate input converter.
     */
    ptr = string;
    /* Allow leading whitespace */
    while (*ptr && isspace((unsigned char) *ptr))
        ptr++;
    if (*ptr++ != '(')
    {
        errsave(escontext,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed record literal: \"%s\"", string),
                 errdetail("Missing left parenthesis.")));
        goto fail;
    }
 
    initStringInfo(&buf);
 
    for (i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        ColumnIOData *column_info = &my_extra->columns[i];
        Oid         column_type = att->atttypid;
        char       *column_data;
 
        /* Ignore dropped columns in datatype, but fill with nulls */
        if (att->attisdropped)
        {
            values[i] = (Datum) 0;
            nulls[i] = true;
            continue;
        }
 
        if (needComma)
        {
            /* Skip comma that separates prior field from this one */
            if (*ptr == ',')
                ptr++;
            else
                /* *ptr must be ')' */
            {
                errsave(escontext,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed record literal: \"%s\"", string),
                         errdetail("Too few columns.")));
                goto fail;
            }
        }
 
        /* Check for null: completely empty input means null */
        if (*ptr == ',' || *ptr == ')')
        {
            column_data = NULL;
            nulls[i] = true;
        }
        else
        {
            /* Extract string for this column */
            bool        inquote = false;
 
            resetStringInfo(&buf);
            while (inquote || !(*ptr == ',' || *ptr == ')'))
            {
                char        ch = *ptr++;
 
                if (ch == '\0')
                {
                    errsave(escontext,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed record literal: \"%s\"",
                                    string),
                             errdetail("Unexpected end of input.")));
                    goto fail;
                }
                if (ch == '\\')
                {
                    if (*ptr == '\0')
                    {
                        errsave(escontext,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                 errmsg("malformed record literal: \"%s\"",
                                        string),
                                 errdetail("Unexpected end of input.")));
                        goto fail;
                    }
                    appendStringInfoChar(&buf, *ptr++);
                }
                else if (ch == '"')
                {
                    if (!inquote)
                        inquote = true;
                    else if (*ptr == '"')
                    {
                        /* doubled quote within quote sequence */
                        appendStringInfoChar(&buf, *ptr++);
                    }
                    else
                        inquote = false;
                }
                else
                    appendStringInfoChar(&buf, ch);
            }
 
            column_data = buf.data;
            nulls[i] = false;
        }
 
        /*
         * Convert the column value
         */
        if (column_info->column_type != column_type)
        {
            getTypeInputInfo(column_type,
                             &column_info->typiofunc,
                             &column_info->typioparam);
            fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
                          fcinfo->flinfo->fn_mcxt);
            column_info->column_type = column_type;
        }
 
        if (!InputFunctionCallSafe(&column_info->proc,
                                   column_data,
                                   column_info->typioparam,
                                   att->atttypmod,
                                   escontext,
                                   &values[i]))
            goto fail;
 
        /*
         * Prep for next column
         */
        needComma = true;
    }
 
    if (*ptr++ != ')')
    {
        errsave(escontext,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed record literal: \"%s\"", string),
                 errdetail("Too many columns.")));
        goto fail;
    }
    /* Allow trailing whitespace */
    while (*ptr && isspace((unsigned char) *ptr))
        ptr++;
    if (*ptr)
    {
        errsave(escontext,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed record literal: \"%s\"", string),
                 errdetail("Junk after right parenthesis.")));
        goto fail;
    }
 
    tuple = heap_form_tuple(tupdesc, values, nulls);
 
    /*
     * We cannot return tuple->t_data because heap_form_tuple allocates it as
     * part of a larger chunk, and our caller may expect to be able to pfree
     * our result.  So must copy the info into a new palloc chunk.
     */
    result = (HeapTupleHeader) palloc(tuple->t_len);
    memcpy(result, tuple->t_data, tuple->t_len);
 
    heap_freetuple(tuple);
    pfree(buf.data);
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    PG_RETURN_HEAPTUPLEHEADER(result);
 
    /* exit here once we've done lookup_rowtype_tupdesc */
fail:
    ReleaseTupleDesc(tupdesc);
    PG_RETURN_NULL();
}

References appendStringInfoChar(), buf, check_stack_depth(), ColumnIOData::column_type, RecordIOData::columns, ereturn, errcode(), errdetail(), errmsg(), errsave, fmgr_info_cxt(), FmgrInfo::fn_mcxt, getTypeInputInfo(), heap_form_tuple(), heap_freetuple(), i, if(), initStringInfo(), InputFunctionCallSafe(), InvalidOid, lookup_rowtype_tupdesc(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordIOData::ncolumns, palloc(), pfree(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_HEAPTUPLEHEADER, PG_RETURN_NULL, ColumnIOData::proc, RecordIOData::record_type, RecordIOData::record_typmod, ReleaseTupleDesc, resetStringInfo(), HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr, ColumnIOData::typiofunc, ColumnIOData::typioparam, and values.

record_larger()

Datum record_larger

(

PG_FUNCTION_ARGS

)

Definition at line 1319 of file rowtypes.c.

{
    if (record_cmp(fcinfo) > 0)
        PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    else
        PG_RETURN_DATUM(PG_GETARG_DATUM(1));
}

References PG_GETARG_DATUM, PG_RETURN_DATUM, and record_cmp().

record_le()

Datum record_le

(

PG_FUNCTION_ARGS

)

Definition at line 1301 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_cmp(fcinfo) <= 0);
}

References PG_RETURN_BOOL, and record_cmp().

record_lt()

Datum record_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1289 of file rowtypes.c.

{
    PG_RETURN_BOOL(record_cmp(fcinfo) < 0);
}

References PG_RETURN_BOOL, and record_cmp().

record_ne()

Datum record_ne

(

PG_FUNCTION_ARGS

)

Definition at line 1283 of file rowtypes.c.

{
    PG_RETURN_BOOL(!DatumGetBool(record_eq(fcinfo)));
}

References DatumGetBool(), PG_RETURN_BOOL, and record_eq().

record_out()

Datum record_out

(

PG_FUNCTION_ARGS

)

Definition at line 329 of file rowtypes.c.

{
    HeapTupleHeader rec = PG_GETARG_HEAPTUPLEHEADER(0);
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupdesc;
    HeapTupleData tuple;
    RecordIOData *my_extra;
    bool        needComma = false;
    int         ncolumns;
    int         i;
    Datum      *values;
    bool       *nulls;
    StringInfoData buf;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from the tuple itself */
    tupType = HeapTupleHeaderGetTypeId(rec);
    tupTypmod = HeapTupleHeaderGetTypMod(rec);
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /* Build a temporary HeapTuple control structure */
    tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
    ItemPointerSetInvalid(&(tuple.t_self));
    tuple.t_tableOid = InvalidOid;
    tuple.t_data = rec;
 
    /*
     * We arrange to look up the needed I/O info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns != ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordIOData, columns) +
                               ncolumns * sizeof(ColumnIOData));
        my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
        my_extra->record_type = InvalidOid;
        my_extra->record_typmod = 0;
    }
 
    if (my_extra->record_type != tupType ||
        my_extra->record_typmod != tupTypmod)
    {
        MemSet(my_extra, 0,
               offsetof(RecordIOData, columns) +
               ncolumns * sizeof(ColumnIOData));
        my_extra->record_type = tupType;
        my_extra->record_typmod = tupTypmod;
        my_extra->ncolumns = ncolumns;
    }
 
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
 
    /* Break down the tuple into fields */
    heap_deform_tuple(&tuple, tupdesc, values, nulls);
 
    /* And build the result string */
    initStringInfo(&buf);
 
    appendStringInfoChar(&buf, '(');
 
    for (i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        ColumnIOData *column_info = &my_extra->columns[i];
        Oid         column_type = att->atttypid;
        Datum       attr;
        char       *value;
        char       *tmp;
        bool        nq;
 
        /* Ignore dropped columns in datatype */
        if (att->attisdropped)
            continue;
 
        if (needComma)
            appendStringInfoChar(&buf, ',');
        needComma = true;
 
        if (nulls[i])
        {
            /* emit nothing... */
            continue;
        }
 
        /*
         * Convert the column value to text
         */
        if (column_info->column_type != column_type)
        {
            getTypeOutputInfo(column_type,
                              &column_info->typiofunc,
                              &column_info->typisvarlena);
            fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
                          fcinfo->flinfo->fn_mcxt);
            column_info->column_type = column_type;
        }
 
        attr = values[i];
        value = OutputFunctionCall(&column_info->proc, attr);
 
        /* Detect whether we need double quotes for this value */
        nq = (value[0] == '\0');    /* force quotes for empty string */
        for (tmp = value; *tmp; tmp++)
        {
            char        ch = *tmp;
 
            if (ch == '"' || ch == '\\' ||
                ch == '(' || ch == ')' || ch == ',' ||
                isspace((unsigned char) ch))
            {
                nq = true;
                break;
            }
        }
 
        /* And emit the string */
        if (nq)
            appendStringInfoCharMacro(&buf, '"');
        for (tmp = value; *tmp; tmp++)
        {
            char        ch = *tmp;
 
            if (ch == '"' || ch == '\\')
                appendStringInfoCharMacro(&buf, ch);
            appendStringInfoCharMacro(&buf, ch);
        }
        if (nq)
            appendStringInfoCharMacro(&buf, '"');
    }
 
    appendStringInfoChar(&buf, ')');
 
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    PG_RETURN_CSTRING(buf.data);
}

References appendStringInfoChar(), appendStringInfoCharMacro, buf, check_stack_depth(), ColumnIOData::column_type, RecordIOData::columns, fmgr_info_cxt(), FmgrInfo::fn_mcxt, getTypeOutputInfo(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, if(), initStringInfo(), InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordIOData::ncolumns, OutputFunctionCall(), palloc(), pfree(), PG_GETARG_HEAPTUPLEHEADER, PG_RETURN_CSTRING, ColumnIOData::proc, RecordIOData::record_type, RecordIOData::record_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, ColumnIOData::typiofunc, ColumnIOData::typisvarlena, value, and values.

record_recv()

Datum record_recv

(

PG_FUNCTION_ARGS

)

Definition at line 480 of file rowtypes.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Oid         tupType = PG_GETARG_OID(1);
    int32       tupTypmod = PG_GETARG_INT32(2);
    HeapTupleHeader result;
    TupleDesc   tupdesc;
    HeapTuple   tuple;
    RecordIOData *my_extra;
    int         ncolumns;
    int         usercols;
    int         validcols;
    int         i;
    Datum      *values;
    bool       *nulls;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /*
     * Give a friendly error message if we did not get enough info to identify
     * the target record type.  (lookup_rowtype_tupdesc would fail anyway, but
     * with a non-user-friendly message.)  In ordinary SQL usage, we'll get -1
     * for typmod, since composite types and RECORD have no type modifiers at
     * the SQL level, and thus must fail for RECORD.  However some callers can
     * supply a valid typmod, and then we can do something useful for RECORD.
     */
    if (tupType == RECORDOID && tupTypmod < 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("input of anonymous composite types is not implemented")));
 
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /*
     * We arrange to look up the needed I/O info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns != ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordIOData, columns) +
                               ncolumns * sizeof(ColumnIOData));
        my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
        my_extra->record_type = InvalidOid;
        my_extra->record_typmod = 0;
    }
 
    if (my_extra->record_type != tupType ||
        my_extra->record_typmod != tupTypmod)
    {
        MemSet(my_extra, 0,
               offsetof(RecordIOData, columns) +
               ncolumns * sizeof(ColumnIOData));
        my_extra->record_type = tupType;
        my_extra->record_typmod = tupTypmod;
        my_extra->ncolumns = ncolumns;
    }
 
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
 
    /* Fetch number of columns user thinks it has */
    usercols = pq_getmsgint(buf, 4);
 
    /* Need to scan to count nondeleted columns */
    validcols = 0;
    for (i = 0; i < ncolumns; i++)
    {
        if (!TupleDescAttr(tupdesc, i)->attisdropped)
            validcols++;
    }
    if (usercols != validcols)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("wrong number of columns: %d, expected %d",
                        usercols, validcols)));
 
    /* Process each column */
    for (i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        ColumnIOData *column_info = &my_extra->columns[i];
        Oid         column_type = att->atttypid;
        Oid         coltypoid;
        int         itemlen;
        StringInfoData item_buf;
        StringInfo  bufptr;
 
        /* Ignore dropped columns in datatype, but fill with nulls */
        if (att->attisdropped)
        {
            values[i] = (Datum) 0;
            nulls[i] = true;
            continue;
        }
 
        /* Check column type recorded in the data */
        coltypoid = pq_getmsgint(buf, sizeof(Oid));
 
        /*
         * From a security standpoint, it doesn't matter whether the input's
         * column type matches what we expect: the column type's receive
         * function has to be robust enough to cope with invalid data.
         * However, from a user-friendliness standpoint, it's nicer to
         * complain about type mismatches than to throw "improper binary
         * format" errors.  But there's a problem: only built-in types have
         * OIDs that are stable enough to believe that a mismatch is a real
         * issue.  So complain only if both OIDs are in the built-in range.
         * Otherwise, carry on with the column type we "should" be getting.
         */
        if (coltypoid != column_type &&
            coltypoid < FirstGenbkiObjectId &&
            column_type < FirstGenbkiObjectId)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("binary data has type %u (%s) instead of expected %u (%s) in record column %d",
                            coltypoid,
                            format_type_extended(coltypoid, -1,
                                                 FORMAT_TYPE_ALLOW_INVALID),
                            column_type,
                            format_type_extended(column_type, -1,
                                                 FORMAT_TYPE_ALLOW_INVALID),
                            i + 1)));
 
        /* Get and check the item length */
        itemlen = pq_getmsgint(buf, 4);
        if (itemlen < -1 || itemlen > (buf->len - buf->cursor))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("insufficient data left in message")));
 
        if (itemlen == -1)
        {
            /* -1 length means NULL */
            bufptr = NULL;
            nulls[i] = true;
        }
        else
        {
            char       *strbuff;
 
            /*
             * Rather than copying data around, we just initialize a
             * StringInfo pointing to the correct portion of the message
             * buffer.
             */
            strbuff = &buf->data[buf->cursor];
            buf->cursor += itemlen;
            initReadOnlyStringInfo(&item_buf, strbuff, itemlen);
 
            bufptr = &item_buf;
            nulls[i] = false;
        }
 
        /* Now call the column's receiveproc */
        if (column_info->column_type != column_type)
        {
            getTypeBinaryInputInfo(column_type,
                                   &column_info->typiofunc,
                                   &column_info->typioparam);
            fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
                          fcinfo->flinfo->fn_mcxt);
            column_info->column_type = column_type;
        }
 
        values[i] = ReceiveFunctionCall(&column_info->proc,
                                        bufptr,
                                        column_info->typioparam,
                                        att->atttypmod);
 
        if (bufptr)
        {
            /* Trouble if it didn't eat the whole buffer */
            if (item_buf.cursor != itemlen)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                         errmsg("improper binary format in record column %d",
                                i + 1)));
        }
    }
 
    tuple = heap_form_tuple(tupdesc, values, nulls);
 
    /*
     * We cannot return tuple->t_data because heap_form_tuple allocates it as
     * part of a larger chunk, and our caller may expect to be able to pfree
     * our result.  So must copy the info into a new palloc chunk.
     */
    result = (HeapTupleHeader) palloc(tuple->t_len);
    memcpy(result, tuple->t_data, tuple->t_len);
 
    heap_freetuple(tuple);
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    PG_RETURN_HEAPTUPLEHEADER(result);
}

References buf, check_stack_depth(), ColumnIOData::column_type, RecordIOData::columns, StringInfoData::cursor, ereport, errcode(), errmsg(), ERROR, FirstGenbkiObjectId, fmgr_info_cxt(), FmgrInfo::fn_mcxt, FORMAT_TYPE_ALLOW_INVALID, format_type_extended(), getTypeBinaryInputInfo(), heap_form_tuple(), heap_freetuple(), i, if(), initReadOnlyStringInfo(), InvalidOid, lookup_rowtype_tupdesc(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordIOData::ncolumns, palloc(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_HEAPTUPLEHEADER, pq_getmsgint(), ColumnIOData::proc, ReceiveFunctionCall(), RecordIOData::record_type, RecordIOData::record_typmod, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr, ColumnIOData::typiofunc, ColumnIOData::typioparam, and values.

record_send()

Datum record_send

(

PG_FUNCTION_ARGS

)

Definition at line 687 of file rowtypes.c.

{
    HeapTupleHeader rec = PG_GETARG_HEAPTUPLEHEADER(0);
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupdesc;
    HeapTupleData tuple;
    RecordIOData *my_extra;
    int         ncolumns;
    int         validcols;
    int         i;
    Datum      *values;
    bool       *nulls;
    StringInfoData buf;
 
    check_stack_depth();        /* recurses for record-type columns */
 
    /* Extract type info from the tuple itself */
    tupType = HeapTupleHeaderGetTypeId(rec);
    tupTypmod = HeapTupleHeaderGetTypMod(rec);
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
    ncolumns = tupdesc->natts;
 
    /* Build a temporary HeapTuple control structure */
    tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
    ItemPointerSetInvalid(&(tuple.t_self));
    tuple.t_tableOid = InvalidOid;
    tuple.t_data = rec;
 
    /*
     * We arrange to look up the needed I/O info just once per series of
     * calls, assuming the record type doesn't change underneath us.
     */
    my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL ||
        my_extra->ncolumns != ncolumns)
    {
        fcinfo->flinfo->fn_extra =
            MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                               offsetof(RecordIOData, columns) +
                               ncolumns * sizeof(ColumnIOData));
        my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
        my_extra->record_type = InvalidOid;
        my_extra->record_typmod = 0;
    }
 
    if (my_extra->record_type != tupType ||
        my_extra->record_typmod != tupTypmod)
    {
        MemSet(my_extra, 0,
               offsetof(RecordIOData, columns) +
               ncolumns * sizeof(ColumnIOData));
        my_extra->record_type = tupType;
        my_extra->record_typmod = tupTypmod;
        my_extra->ncolumns = ncolumns;
    }
 
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
 
    /* Break down the tuple into fields */
    heap_deform_tuple(&tuple, tupdesc, values, nulls);
 
    /* And build the result string */
    pq_begintypsend(&buf);
 
    /* Need to scan to count nondeleted columns */
    validcols = 0;
    for (i = 0; i < ncolumns; i++)
    {
        if (!TupleDescAttr(tupdesc, i)->attisdropped)
            validcols++;
    }
    pq_sendint32(&buf, validcols);
 
    for (i = 0; i < ncolumns; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        ColumnIOData *column_info = &my_extra->columns[i];
        Oid         column_type = att->atttypid;
        Datum       attr;
        bytea      *outputbytes;
 
        /* Ignore dropped columns in datatype */
        if (att->attisdropped)
            continue;
 
        pq_sendint32(&buf, column_type);
 
        if (nulls[i])
        {
            /* emit -1 data length to signify a NULL */
            pq_sendint32(&buf, -1);
            continue;
        }
 
        /*
         * Convert the column value to binary
         */
        if (column_info->column_type != column_type)
        {
            getTypeBinaryOutputInfo(column_type,
                                    &column_info->typiofunc,
                                    &column_info->typisvarlena);
            fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
                          fcinfo->flinfo->fn_mcxt);
            column_info->column_type = column_type;
        }
 
        attr = values[i];
        outputbytes = SendFunctionCall(&column_info->proc, attr);
        pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
        pq_sendbytes(&buf, VARDATA(outputbytes),
                     VARSIZE(outputbytes) - VARHDRSZ);
    }
 
    pfree(values);
    pfree(nulls);
    ReleaseTupleDesc(tupdesc);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, check_stack_depth(), ColumnIOData::column_type, RecordIOData::columns, fmgr_info_cxt(), FmgrInfo::fn_mcxt, getTypeBinaryOutputInfo(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, if(), InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), MemoryContextAlloc(), MemSet, TupleDescData::natts, RecordIOData::ncolumns, palloc(), pfree(), PG_GETARG_HEAPTUPLEHEADER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), pq_sendint32(), ColumnIOData::proc, RecordIOData::record_type, RecordIOData::record_typmod, ReleaseTupleDesc, SendFunctionCall(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescAttr, ColumnIOData::typiofunc, ColumnIOData::typisvarlena, values, VARDATA, VARHDRSZ, and VARSIZE.

record_smaller()

Datum record_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 1328 of file rowtypes.c.

{
    if (record_cmp(fcinfo) < 0)
        PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    else
        PG_RETURN_DATUM(PG_GETARG_DATUM(1));
}

References PG_GETARG_DATUM, PG_RETURN_DATUM, and record_cmp().