datum.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Size	datumGetSize (Datum value, bool typByVal, int typLen)
Datum	datumCopy (Datum value, bool typByVal, int typLen)
Datum	datumTransfer (Datum value, bool typByVal, int typLen)
bool	datumIsEqual (Datum value1, Datum value2, bool typByVal, int typLen)
bool	datum_image_eq (Datum value1, Datum value2, bool typByVal, int typLen)
Size	datumEstimateSpace (Datum value, bool isnull, bool typByVal, int typLen)
void	datumSerialize (Datum value, bool isnull, bool typByVal, int typLen, char **start_address)
Datum	datumRestore (char **start_address, bool *isnull)

Function Documentation

datum_image_eq()

bool datum_image_eq	(	Datum	value1,
		Datum	value2,
		bool	typByVal,
		int	typLen
	)

Definition at line 264 of file datum.c.

References DatumGetPointer, pfree(), PG_DETOAST_DATUM_PACKED, toast_raw_datum_size(), VARDATA_ANY, and VARHDRSZ.

Referenced by record_image_eq(), and ri_KeysEqual().

{
    bool        result = true;

    if (typLen == -1)
    {
        Size        len1,
                    len2;

        len1 = toast_raw_datum_size(value1);
        len2 = toast_raw_datum_size(value2);
        /* No need to de-toast if lengths don't match. */
        if (len1 != len2)
            result = false;
        else
        {
            struct varlena *arg1val;
            struct varlena *arg2val;

            arg1val = PG_DETOAST_DATUM_PACKED(value1);
            arg2val = PG_DETOAST_DATUM_PACKED(value2);

            result = (memcmp(VARDATA_ANY(arg1val),
                             VARDATA_ANY(arg2val),
                             len1 - VARHDRSZ) == 0);

            /* Only free memory if it's a copy made here. */
            if ((Pointer) arg1val != (Pointer) value1)
                pfree(arg1val);
            if ((Pointer) arg2val != (Pointer) value2)
                pfree(arg2val);
        }
    }
    else if (typByVal)
    {
        result = (value1 == value2);
    }
    else
    {
        result = (memcmp(DatumGetPointer(value1),
                         DatumGetPointer(value2),
                         typLen) == 0);
    }

    return result;
}

datumCopy()

Datum datumCopy	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 130 of file datum.c.

References DatumGetEOHP(), DatumGetPointer, datumGetSize(), EOH_flatten_into(), EOH_get_flat_size(), palloc(), PointerGetDatum, value, VARATT_IS_EXTERNAL_EXPANDED, and VARSIZE_ANY.

Referenced by _copyConst(), accumArrayResult(), advance_transition_function(), advance_windowaggregate(), advance_windowaggregate_base(), array_set_element_expanded(), assign_simple_var(), brin_deform_tuple(), brin_inclusion_add_value(), brin_inclusion_union(), brin_minmax_add_value(), brin_minmax_union(), CatCacheCopyKeys(), collectMatchBitmap(), compute_array_stats(), compute_distinct_stats(), compute_index_stats(), compute_scalar_stats(), copyParamList(), create_list_bounds(), create_range_bounds(), CreateTupleDescCopyConstr(), datumTransfer(), eval_const_expressions_mutator(), eval_windowaggregates(), eval_windowfunction(), evaluate_expr(), exec_eval_using_params(), ExecAggInitGroup(), ExecAggTransReparent(), ExecComputeStoredGenerated(), ExecWindowAgg(), expanded_record_set_field_internal(), expanded_record_set_fields(), finalize_aggregate(), finalize_partialaggregate(), finalize_windowaggregate(), get_actual_variable_endpoint(), get_qual_for_list(), get_variable_range(), getDatumCopy(), initialize_aggregate(), initialize_windowaggregate(), partition_bounds_copy(), pattern_fixed_prefix(), postquel_get_single_result(), RelationBuildTupleDesc(), reorderqueue_push(), spg_range_quad_inner_consistent(), spg_text_inner_consistent(), spgMakeInnerItem(), spgNewHeapItem(), tuplesort_getdatum(), and tuplesort_putdatum().

{
    Datum       res;

    if (typByVal)
        res = value;
    else if (typLen == -1)
    {
        /* It is a varlena datatype */
        struct varlena *vl = (struct varlena *) DatumGetPointer(value);

        if (VARATT_IS_EXTERNAL_EXPANDED(vl))
        {
            /* Flatten into the caller's memory context */
            ExpandedObjectHeader *eoh = DatumGetEOHP(value);
            Size        resultsize;
            char       *resultptr;

            resultsize = EOH_get_flat_size(eoh);
            resultptr = (char *) palloc(resultsize);
            EOH_flatten_into(eoh, (void *) resultptr, resultsize);
            res = PointerGetDatum(resultptr);
        }
        else
        {
            /* Otherwise, just copy the varlena datum verbatim */
            Size        realSize;
            char       *resultptr;

            realSize = (Size) VARSIZE_ANY(vl);
            resultptr = (char *) palloc(realSize);
            memcpy(resultptr, vl, realSize);
            res = PointerGetDatum(resultptr);
        }
    }
    else
    {
        /* Pass by reference, but not varlena, so not toasted */
        Size        realSize;
        char       *resultptr;

        realSize = datumGetSize(value, typByVal, typLen);

        resultptr = (char *) palloc(realSize);
        memcpy(resultptr, DatumGetPointer(value), realSize);
        res = PointerGetDatum(resultptr);
    }
    return res;
}

datumEstimateSpace()

Size datumEstimateSpace	(	Datum	value,
		bool	isnull,
		bool	typByVal,
		int	typLen
	)

Definition at line 319 of file datum.c.

References DatumGetEOHP(), DatumGetPointer, datumGetSize(), EOH_get_flat_size(), and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by EstimateParamExecSpace(), and EstimateParamListSpace().

{
    Size        sz = sizeof(int);

    if (!isnull)
    {
        /* no need to use add_size, can't overflow */
        if (typByVal)
            sz += sizeof(Datum);
        else if (typLen == -1 &&
                 VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(value)))
        {
            /* Expanded objects need to be flattened, see comment below */
            sz += EOH_get_flat_size(DatumGetEOHP(value));
        }
        else
            sz += datumGetSize(value, typByVal, typLen);
    }

    return sz;
}

datumGetSize()

Size datumGetSize	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 63 of file datum.c.

References Assert, DatumGetPointer, elog, ereport, errcode(), errmsg(), ERROR, PointerIsValid, and VARSIZE_ANY.

Referenced by datumCopy(), datumEstimateSpace(), datumIsEqual(), datumSerialize(), outDatum(), and writetup_datum().

{
    Size        size;

    if (typByVal)
    {
        /* Pass-by-value types are always fixed-length */
        Assert(typLen > 0 && typLen <= sizeof(Datum));
        size = (Size) typLen;
    }
    else
    {
        if (typLen > 0)
        {
            /* Fixed-length pass-by-ref type */
            size = (Size) typLen;
        }
        else if (typLen == -1)
        {
            /* It is a varlena datatype */
            struct varlena *s = (struct varlena *) DatumGetPointer(value);

            if (!PointerIsValid(s))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_EXCEPTION),
                         errmsg("invalid Datum pointer")));

            size = (Size) VARSIZE_ANY(s);
        }
        else if (typLen == -2)
        {
            /* It is a cstring datatype */
            char       *s = (char *) DatumGetPointer(value);

            if (!PointerIsValid(s))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_EXCEPTION),
                         errmsg("invalid Datum pointer")));

            size = (Size) (strlen(s) + 1);
        }
        else
        {
            elog(ERROR, "invalid typLen: %d", typLen);
            size = 0;           /* keep compiler quiet */
        }
    }

    return size;
}

datumIsEqual()

bool datumIsEqual	(	Datum	value1,
		Datum	value2,
		bool	typByVal,
		int	typLen
	)

Definition at line 221 of file datum.c.

References DatumGetPointer, datumGetSize(), s1, and s2.

Referenced by _bt_keep_natts_fast(), _equalConst(), coerce_type(), equalTupleDescs(), find_compatible_pertrans(), heap_tuple_attr_equals(), and partition_bounds_equal().

{
    bool        res;

    if (typByVal)
    {
        /*
         * just compare the two datums. NOTE: just comparing "len" bytes will
         * not do the work, because we do not know how these bytes are aligned
         * inside the "Datum".  We assume instead that any given datatype is
         * consistent about how it fills extraneous bits in the Datum.
         */
        res = (value1 == value2);
    }
    else
    {
        Size        size1,
                    size2;
        char       *s1,
                   *s2;

        /*
         * Compare the bytes pointed by the pointers stored in the datums.
         */
        size1 = datumGetSize(value1, typByVal, typLen);
        size2 = datumGetSize(value2, typByVal, typLen);
        if (size1 != size2)
            return false;
        s1 = (char *) DatumGetPointer(value1);
        s2 = (char *) DatumGetPointer(value2);
        res = (memcmp(s1, s2, size1) == 0);
    }
    return res;
}

datumRestore()

Datum datumRestore	(	char **	start_address,
		bool *	isnull
	)

Definition at line 428 of file datum.c.

References Assert, header(), palloc(), PointerGetDatum, and val.

Referenced by RestoreParamExecParams(), and RestoreParamList().

{
    int         header;
    void       *d;

    /* Read header word. */
    memcpy(&header, *start_address, sizeof(int));
    *start_address += sizeof(int);

    /* If this datum is NULL, we can stop here. */
    if (header == -2)
    {
        *isnull = true;
        return (Datum) 0;
    }

    /* OK, datum is not null. */
    *isnull = false;

    /* If this datum is pass-by-value, sizeof(Datum) bytes follow. */
    if (header == -1)
    {
        Datum       val;

        memcpy(&val, *start_address, sizeof(Datum));
        *start_address += sizeof(Datum);
        return val;
    }

    /* Pass-by-reference case; copy indicated number of bytes. */
    Assert(header > 0);
    d = palloc(header);
    memcpy(d, *start_address, header);
    *start_address += header;
    return PointerGetDatum(d);
}

datumSerialize()

void datumSerialize	(	Datum	value,
		bool	isnull,
		bool	typByVal,
		int	typLen,
		char **	start_address
	)

Definition at line 366 of file datum.c.

References DatumGetEOHP(), DatumGetPointer, datumGetSize(), EOH_flatten_into(), EOH_get_flat_size(), header(), palloc(), pfree(), and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by SerializeParamExecParams(), and SerializeParamList().

{
    ExpandedObjectHeader *eoh = NULL;
    int         header;

    /* Write header word. */
    if (isnull)
        header = -2;
    else if (typByVal)
        header = -1;
    else if (typLen == -1 &&
             VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(value)))
    {
        eoh = DatumGetEOHP(value);
        header = EOH_get_flat_size(eoh);
    }
    else
        header = datumGetSize(value, typByVal, typLen);
    memcpy(*start_address, &header, sizeof(int));
    *start_address += sizeof(int);

    /* If not null, write payload bytes. */
    if (!isnull)
    {
        if (typByVal)
        {
            memcpy(*start_address, &value, sizeof(Datum));
            *start_address += sizeof(Datum);
        }
        else if (eoh)
        {
            char       *tmp;

            /*
             * EOH_flatten_into expects the target address to be maxaligned,
             * so we can't store directly to *start_address.
             */
            tmp = (char *) palloc(header);
            EOH_flatten_into(eoh, (void *) tmp, header);
            memcpy(*start_address, tmp, header);
            *start_address += header;

            /* be tidy. */
            pfree(tmp);
        }
        else
        {
            memcpy(*start_address, DatumGetPointer(value), header);
            *start_address += header;
        }
    }
}

datumTransfer()

Datum datumTransfer	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 192 of file datum.c.

References CurrentMemoryContext, datumCopy(), DatumGetPointer, TransferExpandedObject(), value, and VARATT_IS_EXTERNAL_EXPANDED_RW.

Referenced by exec_assign_value(), exec_stmt_block(), and SPI_datumTransfer().

{
    if (!typByVal && typLen == -1 &&
        VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(value)))
        value = TransferExpandedObject(value, CurrentMemoryContext);
    else
        value = datumCopy(value, typByVal, typLen);
    return value;
}