This graph shows which files directly or indirectly include 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
	)

extern

Definition at line 271 of file datum.c.

{
    Size        len1,
                len2;
    bool        result = true;
 
    if (typByVal)
    {
        switch (typLen)
        {
            case sizeof(char):
                result = (DatumGetChar(value1) == DatumGetChar(value2));
                break;
            case sizeof(int16):
                result = (DatumGetInt16(value1) == DatumGetInt16(value2));
                break;
            case sizeof(int32):
                result = (DatumGetInt32(value1) == DatumGetInt32(value2));
                break;
            default:
                result = (value1 == value2);
                break;
        }
    }
    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
        {
            varlena    *arg1val;
            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 (arg1val != DatumGetPointer(value1))
                pfree(arg1val);
            if (arg2val != DatumGetPointer(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 DatumGetChar(), DatumGetCString(), DatumGetInt16(), DatumGetInt32(), DatumGetPointer(), elog, ERROR, fb(), pfree(), PG_DETOAST_DATUM_PACKED, result, s1, s2, toast_raw_datum_size(), VARDATA_ANY(), and VARHDRSZ.

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

◆ datum_image_hash()

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

extern

Definition at line 358 of file datum.c.

{
    Size        len;
    uint32      result;
 
    if (typByVal)
    {
        switch (typLen)
        {
            case sizeof(char):
                value = CharGetDatum(DatumGetChar(value));
                break;
            case sizeof(int16):
                value = Int16GetDatum(DatumGetInt16(value));
                break;
            case sizeof(int32):
                value = Int32GetDatum(DatumGetInt32(value));
                break;
                /* Nothing needs done for 64-bit types */
        }
 
        result = hash_bytes((unsigned char *) &value, sizeof(Datum));
    }
    else if (typLen > 0)
        result = hash_bytes((unsigned char *) DatumGetPointer(value), typLen);
    else if (typLen == -1)
    {
        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 (val != DatumGetPointer(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 CharGetDatum(), DatumGetChar(), DatumGetCString(), DatumGetInt16(), DatumGetInt32(), DatumGetPointer(), elog, ERROR, fb(), hash_bytes(), Int16GetDatum(), Int32GetDatum(), len, pfree(), PG_DETOAST_DATUM_PACKED, result, toast_raw_datum_size(), val, value, VARDATA_ANY(), and VARHDRSZ.

Referenced by MemoizeHash_hash().

◆ datumCopy()

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

extern

Definition at line 132 of file datum.c.

{
    Datum       res;
 
    if (typByVal)
        res = value;
    else if (typLen == -1)
    {
        /* It is a varlena datatype */
        varlena    *vl = (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, 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(), fb(), memcpy(), palloc(), PointerGetDatum(), value, VARATT_IS_EXTERNAL_EXPANDED(), and VARSIZE_ANY().

Referenced by _bt_array_decrement(), _bt_array_increment(), _bt_skiparray_set_element(), _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(), calculate_frame_offsets(), CatCacheCopyKeys(), collectMatchBitmap(), compute_array_stats(), compute_distinct_stats(), compute_expr_stats(), compute_index_stats(), compute_scalar_stats(), CopyIndexAttOptions(), copyParamList(), copyScalarSubstructure(), create_list_bounds(), create_range_bounds(), CreateTupleDescCopyConstr(), datumTransfer(), eval_const_expressions_mutator(), eval_windowaggregates(), eval_windowfunction(), evaluate_expr(), exec_eval_using_params(), ExecAggCopyTransValue(), ExecAggInitGroup(), ExecComputeStoredGenerated(), ExecEvalPreOrderedDistinctSingle(), 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(), getmissingattr(), GinBufferStoreTuple(), 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
	)

extern

Definition at line 450 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(), fb(), value, and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by btestimateparallelscan(), EstimateParamExecSpace(), and EstimateParamListSpace().

◆ datumGetSize()

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

extern

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 */
            varlena    *s = (varlena *) DatumGetPointer(value);
 
            if (!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 (!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, fb(), 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
	)

extern

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(), fb(), 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
	)

extern

Definition at line 559 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, fb(), memcpy(), palloc(), PointerGetDatum(), and val.

Referenced by _bt_parallel_restore_arrays(), RestoreParamExecParams(), and RestoreParamList().

◆ datumSerialize()

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

extern

Definition at line 497 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, 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(), fb(), memcpy(), palloc(), pfree(), value, and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by _bt_parallel_serialize_arrays(), SerializeParamExecParams(), and SerializeParamList().

◆ datumTransfer()

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

extern

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().

Functions

Function Documentation

◆ datum_image_eq()

◆ datum_image_hash()

◆ datumCopy()

◆ datumEstimateSpace()

◆ datumGetSize()

◆ datumIsEqual()

◆ datumRestore()

◆ datumSerialize()

◆ datumTransfer()