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)
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 datumCopy	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 128 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_combine_function(), advance_transition_function(), advance_windowaggregate(), advance_windowaggregate_base(), array_set_element_expanded(), brin_deform_tuple(), brin_inclusion_add_value(), brin_inclusion_union(), brin_minmax_add_value(), brin_minmax_union(), collectMatchBitmap(), compute_array_stats(), compute_distinct_stats(), compute_index_stats(), compute_scalar_stats(), copyParamList(), datumTransfer(), eval_const_expressions_mutator(), eval_windowaggregates(), eval_windowfunction(), evaluate_expr(), exec_eval_using_params(), ExecWindowAgg(), finalize_aggregate(), finalize_partialaggregate(), finalize_windowaggregate(), get_actual_variable_range(), get_variable_range(), getDatumCopy(), initialize_aggregate(), initialize_windowaggregate(), postquel_get_single_result(), RelationBuildPartitionDesc(), reorderqueue_push(), spg_range_quad_inner_consistent(), spg_text_inner_consistent(), spgWalk(), 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;
}

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

Definition at line 262 of file datum.c.

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

Referenced by EstimateParamListSpace().

{
    Size        sz = sizeof(int);

    if (!isnull)
    {
        /* no need to use add_size, can't overflow */
        if (typByVal)
            sz += sizeof(Datum);
        else if (VARATT_IS_EXTERNAL_EXPANDED(value))
        {
            ExpandedObjectHeader *eoh = DatumGetEOHP(value);

            sz += EOH_get_flat_size(eoh);
        }
        else
            sz += datumGetSize(value, typByVal, typLen);
    }

    return sz;
}

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

Definition at line 61 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;
}

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

Definition at line 219 of file datum.c.

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

Referenced by _equalConst(), coerce_type(), 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;
}

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

Definition at line 352 of file datum.c.

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

Referenced by 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);
}

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

Definition at line 302 of file datum.c.

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

Referenced by SerializeParamList().

{
    ExpandedObjectHeader *eoh = NULL;
    int         header;

    /* Write header word. */
    if (isnull)
        header = -2;
    else if (typByVal)
        header = -1;
    else if (VARATT_IS_EXTERNAL_EXPANDED(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)
        {
            EOH_flatten_into(eoh, (void *) *start_address, header);
            *start_address += header;
        }
        else
        {
            memcpy(*start_address, DatumGetPointer(value), header);
            *start_address += header;
        }
    }
}

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

Definition at line 190 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;
}