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)
uint32	datum_image_hash (Datum value, 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 266 of file datum.c.

{
    Size        len1,
                len2;
    bool        result = true;
 
    if (typByVal)
    {
        result = (value1 == value2);
    }
    else if (typLen > 0)
    {
        result = (memcmp(DatumGetPointer(value1),
                         DatumGetPointer(value2),
                         typLen) == 0);
    }
    else if (typLen == -1)
    {
        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 (typLen == -2)
    {
        char       *s1,
                   *s2;
 
        /* Compare cstring datums */
        s1 = DatumGetCString(value1);
        s2 = DatumGetCString(value2);
        len1 = strlen(s1) + 1;
        len2 = strlen(s2) + 1;
        if (len1 != len2)
            return false;
        result = (memcmp(s1, s2, len1) == 0);
    }
    else
        elog(ERROR, "unexpected typLen: %d", typLen);
 
    return result;
}

References DatumGetCString(), DatumGetPointer(), elog(), ERROR, pfree(), PG_DETOAST_DATUM_PACKED, s1, s2, toast_raw_datum_size(), VARDATA_ANY, and VARHDRSZ.

Referenced by _bt_keep_natts_fast(), MemoizeHash_equal(), record_image_eq(), and ri_KeysEqual().

datum_image_hash()

uint32 datum_image_hash	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 338 of file datum.c.

{
    Size        len;
    uint32      result;
 
    if (typByVal)
        result = hash_bytes((unsigned char *) &value, sizeof(Datum));
    else if (typLen > 0)
        result = hash_bytes((unsigned char *) DatumGetPointer(value), typLen);
    else if (typLen == -1)
    {
        struct varlena *val;
 
        len = toast_raw_datum_size(value);
 
        val = PG_DETOAST_DATUM_PACKED(value);
 
        result = hash_bytes((unsigned char *) VARDATA_ANY(val), len - VARHDRSZ);
 
        /* Only free memory if it's a copy made here. */
        if ((Pointer) val != (Pointer) value)
            pfree(val);
    }
    else if (typLen == -2)
    {
        char       *s;
 
        s = DatumGetCString(value);
        len = strlen(s) + 1;
 
        result = hash_bytes((unsigned char *) s, len);
    }
    else
    {
        elog(ERROR, "unexpected typLen: %d", typLen);
        result = 0;             /* keep compiler quiet */
    }
 
    return result;
}

References DatumGetCString(), DatumGetPointer(), elog(), ERROR, hash_bytes(), len, pfree(), PG_DETOAST_DATUM_PACKED, toast_raw_datum_size(), val, value, VARDATA_ANY, and VARHDRSZ.

Referenced by MemoizeHash_hash().

datumCopy()

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

Definition at line 132 of file datum.c.

{
    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;
}

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

Referenced by _copyConst(), accumArrayResult(), advance_transition_function(), advance_windowaggregate(), advance_windowaggregate_base(), array_agg_combine(), 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_expr_stats(), compute_index_stats(), compute_scalar_stats(), CopyIndexAttOptions(), 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(), ExecEvalPreOrderedDistinctSingle(), ExecWindowAgg(), expanded_record_set_field_internal(), expanded_record_set_fields(), get_actual_variable_endpoint(), get_attoptions(), get_qual_for_list(), get_stats_slot_range(), get_variable_range(), getDatumCopy(), initialize_aggregate(), initialize_windowaggregate(), partition_bounds_copy(), pattern_fixed_prefix(), postquel_get_single_result(), process_ordered_aggregate_single(), range_add_value(), RelationBuildTupleDesc(), reorderqueue_push(), spg_range_quad_inner_consistent(), spg_text_inner_consistent(), spgist_name_inner_consistent(), spgMakeInnerItem(), spgNewHeapItem(), tuplesort_getdatum(), tuplesort_putdatum(), and union_tuples().

datumEstimateSpace()

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

Definition at line 412 of file datum.c.

{
    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;
}

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

Referenced by EstimateParamExecSpace(), and EstimateParamListSpace().

datumGetSize()

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

Definition at line 65 of file datum.c.

{
    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;
}

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

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

datumIsEqual()

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

Definition at line 223 of file datum.c.

{
    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;
}

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

Referenced by _equalConst(), coerce_type(), equalTupleDescs(), find_compatible_trans(), heap_attr_equals(), and partition_bounds_equal().

datumRestore()

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

Definition at line 521 of file datum.c.

{
    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);
}

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

Referenced by RestoreParamExecParams(), and RestoreParamList().

datumSerialize()

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

Definition at line 459 of file datum.c.

{
    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;
        }
    }
}

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

Referenced by SerializeParamExecParams(), and SerializeParamList().

datumTransfer()

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

Definition at line 194 of file datum.c.

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

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

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