uuid.c File Reference

#include "postgres.h"
#include "common/hashfn.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "port/pg_bswap.h"
#include "utils/fmgrprotos.h"
#include "utils/guc.h"
#include "utils/sortsupport.h"
#include "utils/timestamp.h"
#include "utils/uuid.h"

Include dependency graph for uuid.c:

Go to the source code of this file.

Data Structures
struct	uuid_sortsupport_state

Macros
#define	UUIDV1_EPOCH_JDATE   2299161 /* == date2j(1582,10,15) */

Functions
static void	string_to_uuid (const char *source, pg_uuid_t *uuid, Node *escontext)
static int	uuid_internal_cmp (const pg_uuid_t *arg1, const pg_uuid_t *arg2)
static int	uuid_fast_cmp (Datum x, Datum y, SortSupport ssup)
static bool	uuid_abbrev_abort (int memtupcount, SortSupport ssup)
static Datum	uuid_abbrev_convert (Datum original, SortSupport ssup)
Datum	uuid_in (PG_FUNCTION_ARGS)
Datum	uuid_out (PG_FUNCTION_ARGS)
Datum	uuid_recv (PG_FUNCTION_ARGS)
Datum	uuid_send (PG_FUNCTION_ARGS)
Datum	uuid_lt (PG_FUNCTION_ARGS)
Datum	uuid_le (PG_FUNCTION_ARGS)
Datum	uuid_eq (PG_FUNCTION_ARGS)
Datum	uuid_ge (PG_FUNCTION_ARGS)
Datum	uuid_gt (PG_FUNCTION_ARGS)
Datum	uuid_ne (PG_FUNCTION_ARGS)
Datum	uuid_cmp (PG_FUNCTION_ARGS)
Datum	uuid_sortsupport (PG_FUNCTION_ARGS)
Datum	uuid_hash (PG_FUNCTION_ARGS)
Datum	uuid_hash_extended (PG_FUNCTION_ARGS)
Datum	gen_random_uuid (PG_FUNCTION_ARGS)
Datum	uuid_extract_timestamp (PG_FUNCTION_ARGS)
Datum	uuid_extract_version (PG_FUNCTION_ARGS)

Macro Definition Documentation

UUIDV1_EPOCH_JDATE

#define UUIDV1_EPOCH_JDATE   2299161 /* == date2j(1582,10,15) */

Definition at line 430 of file uuid.c.

Function Documentation

gen_random_uuid()

Datum gen_random_uuid

(

PG_FUNCTION_ARGS

)

Definition at line 411 of file uuid.c.

{
    pg_uuid_t  *uuid = palloc(UUID_LEN);
 
    if (!pg_strong_random(uuid, UUID_LEN))
        ereport(ERROR,
                (errcode(ERRCODE_INTERNAL_ERROR),
                 errmsg("could not generate random values")));
 
    /*
     * Set magic numbers for a "version 4" (pseudorandom) UUID, see
     * http://tools.ietf.org/html/rfc4122#section-4.4
     */
    uuid->data[6] = (uuid->data[6] & 0x0f) | 0x40;  /* time_hi_and_version */
    uuid->data[8] = (uuid->data[8] & 0x3f) | 0x80;  /* clock_seq_hi_and_reserved */
 
    PG_RETURN_UUID_P(uuid);
}

References pg_uuid_t::data, ereport, errcode(), errmsg(), ERROR, palloc(), PG_RETURN_UUID_P, pg_strong_random(), and UUID_LEN.

Referenced by pg_random_uuid().

string_to_uuid()

static void string_to_uuid ( const char *  source, pg_uuid_t *  uuid, Node *  escontext  )

static

Definition at line 95 of file uuid.c.

{
    const char *src = source;
    bool        braces = false;
    int         i;
 
    if (src[0] == '{')
    {
        src++;
        braces = true;
    }
 
    for (i = 0; i < UUID_LEN; i++)
    {
        char        str_buf[3];
 
        if (src[0] == '\0' || src[1] == '\0')
            goto syntax_error;
        memcpy(str_buf, src, 2);
        if (!isxdigit((unsigned char) str_buf[0]) ||
            !isxdigit((unsigned char) str_buf[1]))
            goto syntax_error;
 
        str_buf[2] = '\0';
        uuid->data[i] = (unsigned char) strtoul(str_buf, NULL, 16);
        src += 2;
        if (src[0] == '-' && (i % 2) == 1 && i < UUID_LEN - 1)
            src++;
    }
 
    if (braces)
    {
        if (*src != '}')
            goto syntax_error;
        src++;
    }
 
    if (*src != '\0')
        goto syntax_error;
 
    return;
 
syntax_error:
    ereturn(escontext,,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "uuid", source)));
}

References pg_uuid_t::data, ereturn, errcode(), errmsg(), i, source, syntax_error(), and UUID_LEN.

Referenced by uuid_in().

uuid_abbrev_abort()

static bool uuid_abbrev_abort ( int  memtupcount, SortSupport  ssup  )

static

Definition at line 292 of file uuid.c.

{
    uuid_sortsupport_state *uss = ssup->ssup_extra;
    double      abbr_card;
 
    if (memtupcount < 10000 || uss->input_count < 10000 || !uss->estimating)
        return false;
 
    abbr_card = estimateHyperLogLog(&uss->abbr_card);
 
    /*
     * If we have >100k distinct values, then even if we were sorting many
     * billion rows we'd likely still break even, and the penalty of undoing
     * that many rows of abbrevs would probably not be worth it.  Stop even
     * counting at that point.
     */
    if (abbr_card > 100000.0)
    {
#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG,
                 "uuid_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count, memtupcount);
#endif
        uss->estimating = false;
        return false;
    }
 
    /*
     * Target minimum cardinality is 1 per ~2k of non-null inputs.  0.5 row
     * fudge factor allows us to abort earlier on genuinely pathological data
     * where we've had exactly one abbreviated value in the first 2k
     * (non-null) rows.
     */
    if (abbr_card < uss->input_count / 2000.0 + 0.5)
    {
#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG,
                 "uuid_abbrev: aborting abbreviation at cardinality %f"
                 " below threshold %f after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count / 2000.0 + 0.5, uss->input_count,
                 memtupcount);
#endif
        return true;
    }
 
#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "uuid_abbrev: cardinality %f after " INT64_FORMAT
             " values (%d rows)", abbr_card, uss->input_count, memtupcount);
#endif
 
    return false;
}

References uuid_sortsupport_state::abbr_card, elog, estimateHyperLogLog(), uuid_sortsupport_state::estimating, uuid_sortsupport_state::input_count, INT64_FORMAT, LOG, SortSupportData::ssup_extra, and trace_sort.

Referenced by uuid_sortsupport().

uuid_abbrev_convert()

static Datum uuid_abbrev_convert ( Datum  original, SortSupport  ssup  )

static

Definition at line 358 of file uuid.c.

{
    uuid_sortsupport_state *uss = ssup->ssup_extra;
    pg_uuid_t  *authoritative = DatumGetUUIDP(original);
    Datum       res;
 
    memcpy(&res, authoritative->data, sizeof(Datum));
    uss->input_count += 1;
 
    if (uss->estimating)
    {
        uint32      tmp;
 
#if SIZEOF_DATUM == 8
        tmp = (uint32) res ^ (uint32) ((uint64) res >> 32);
#else                           /* SIZEOF_DATUM != 8 */
        tmp = (uint32) res;
#endif
 
        addHyperLogLog(&uss->abbr_card, DatumGetUInt32(hash_uint32(tmp)));
    }
 
    /*
     * Byteswap on little-endian machines.
     *
     * This is needed so that ssup_datum_unsigned_cmp() (an unsigned integer
     * 3-way comparator) works correctly on all platforms.  If we didn't do
     * this, the comparator would have to call memcmp() with a pair of
     * pointers to the first byte of each abbreviated key, which is slower.
     */
    res = DatumBigEndianToNative(res);
 
    return res;
}

References uuid_sortsupport_state::abbr_card, addHyperLogLog(), pg_uuid_t::data, DatumGetUInt32(), DatumGetUUIDP(), uuid_sortsupport_state::estimating, hash_uint32(), uuid_sortsupport_state::input_count, res, and SortSupportData::ssup_extra.

Referenced by uuid_sortsupport().

uuid_cmp()

Datum uuid_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 229 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_INT32(uuid_internal_cmp(arg1, arg2));
}

References PG_GETARG_UUID_P, PG_RETURN_INT32, and uuid_internal_cmp().

uuid_eq()

Datum uuid_eq

(

PG_FUNCTION_ARGS

)

Definition at line 192 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) == 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

uuid_extract_timestamp()

Datum uuid_extract_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 438 of file uuid.c.

{
    pg_uuid_t  *uuid = PG_GETARG_UUID_P(0);
    int         version;
    uint64      tms;
    TimestampTz ts;
 
    /* check if RFC 4122 variant */
    if ((uuid->data[8] & 0xc0) != 0x80)
        PG_RETURN_NULL();
 
    version = uuid->data[6] >> 4;
 
    if (version == 1)
    {
        tms = ((uint64) uuid->data[0] << 24)
            + ((uint64) uuid->data[1] << 16)
            + ((uint64) uuid->data[2] << 8)
            + ((uint64) uuid->data[3])
            + ((uint64) uuid->data[4] << 40)
            + ((uint64) uuid->data[5] << 32)
            + (((uint64) uuid->data[6] & 0xf) << 56)
            + ((uint64) uuid->data[7] << 48);
 
        /* convert 100-ns intervals to us, then adjust */
        ts = (TimestampTz) (tms / 10) -
            ((uint64) POSTGRES_EPOCH_JDATE - UUIDV1_EPOCH_JDATE) * SECS_PER_DAY * USECS_PER_SEC;
 
        PG_RETURN_TIMESTAMPTZ(ts);
    }
 
    /* not a timestamp-containing UUID version */
    PG_RETURN_NULL();
}

References pg_uuid_t::data, PG_GETARG_UUID_P, PG_RETURN_NULL, PG_RETURN_TIMESTAMPTZ, POSTGRES_EPOCH_JDATE, SECS_PER_DAY, USECS_PER_SEC, and UUIDV1_EPOCH_JDATE.

uuid_extract_version()

Datum uuid_extract_version

(

PG_FUNCTION_ARGS

)

Definition at line 479 of file uuid.c.

{
    pg_uuid_t  *uuid = PG_GETARG_UUID_P(0);
    uint16      version;
 
    /* check if RFC 4122 variant */
    if ((uuid->data[8] & 0xc0) != 0x80)
        PG_RETURN_NULL();
 
    version = uuid->data[6] >> 4;
 
    PG_RETURN_UINT16(version);
}

References pg_uuid_t::data, PG_GETARG_UUID_P, PG_RETURN_NULL, and PG_RETURN_UINT16.

uuid_fast_cmp()

static int uuid_fast_cmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 277 of file uuid.c.

{
    pg_uuid_t  *arg1 = DatumGetUUIDP(x);
    pg_uuid_t  *arg2 = DatumGetUUIDP(y);
 
    return uuid_internal_cmp(arg1, arg2);
}

References DatumGetUUIDP(), uuid_internal_cmp(), x, and y.

Referenced by uuid_sortsupport().

uuid_ge()

Datum uuid_ge

(

PG_FUNCTION_ARGS

)

Definition at line 201 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) >= 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

uuid_gt()

Datum uuid_gt

(

PG_FUNCTION_ARGS

)

Definition at line 210 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) > 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

uuid_hash()

Datum uuid_hash

(

PG_FUNCTION_ARGS

)

Definition at line 395 of file uuid.c.

{
    pg_uuid_t  *key = PG_GETARG_UUID_P(0);
 
    return hash_any(key->data, UUID_LEN);
}

References hash_any(), sort-test::key, PG_GETARG_UUID_P, and UUID_LEN.

uuid_hash_extended()

Datum uuid_hash_extended

(

PG_FUNCTION_ARGS

)

Definition at line 403 of file uuid.c.

{
    pg_uuid_t  *key = PG_GETARG_UUID_P(0);
 
    return hash_any_extended(key->data, UUID_LEN, PG_GETARG_INT64(1));
}

References hash_any_extended(), sort-test::key, PG_GETARG_INT64, PG_GETARG_UUID_P, and UUID_LEN.

uuid_in()

Datum uuid_in

(

PG_FUNCTION_ARGS

)

Definition at line 42 of file uuid.c.

{
    char       *uuid_str = PG_GETARG_CSTRING(0);
    pg_uuid_t  *uuid;
 
    uuid = (pg_uuid_t *) palloc(sizeof(*uuid));
    string_to_uuid(uuid_str, uuid, fcinfo->context);
    PG_RETURN_UUID_P(uuid);
}

References palloc(), PG_GETARG_CSTRING, PG_RETURN_UUID_P, and string_to_uuid().

Referenced by uuid_generate_internal().

uuid_internal_cmp()

static int uuid_internal_cmp ( const pg_uuid_t *  arg1, const pg_uuid_t *  arg2  )

static

Definition at line 168 of file uuid.c.

{
    return memcmp(arg1->data, arg2->data, UUID_LEN);
}

References pg_uuid_t::data, and UUID_LEN.

Referenced by uuid_cmp(), uuid_eq(), uuid_fast_cmp(), uuid_ge(), uuid_gt(), uuid_le(), uuid_lt(), and uuid_ne().

uuid_le()

Datum uuid_le

(

PG_FUNCTION_ARGS

)

Definition at line 183 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) <= 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

Referenced by brin_minmax_multi_distance_uuid().

uuid_lt()

Datum uuid_lt

(

PG_FUNCTION_ARGS

)

Definition at line 174 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) < 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

uuid_ne()

Datum uuid_ne

(

PG_FUNCTION_ARGS

)

Definition at line 219 of file uuid.c.

{
    pg_uuid_t  *arg1 = PG_GETARG_UUID_P(0);
    pg_uuid_t  *arg2 = PG_GETARG_UUID_P(1);
 
    PG_RETURN_BOOL(uuid_internal_cmp(arg1, arg2) != 0);
}

References PG_GETARG_UUID_P, PG_RETURN_BOOL, and uuid_internal_cmp().

uuid_out()

Datum uuid_out

(

PG_FUNCTION_ARGS

)

Definition at line 53 of file uuid.c.

{
    pg_uuid_t  *uuid = PG_GETARG_UUID_P(0);
    static const char hex_chars[] = "0123456789abcdef";
    char       *buf,
               *p;
    int         i;
 
    /* counts for the four hyphens and the zero-terminator */
    buf = palloc(2 * UUID_LEN + 5);
    p = buf;
    for (i = 0; i < UUID_LEN; i++)
    {
        int         hi;
        int         lo;
 
        /*
         * We print uuid values as a string of 8, 4, 4, 4, and then 12
         * hexadecimal characters, with each group is separated by a hyphen
         * ("-"). Therefore, add the hyphens at the appropriate places here.
         */
        if (i == 4 || i == 6 || i == 8 || i == 10)
            *p++ = '-';
 
        hi = uuid->data[i] >> 4;
        lo = uuid->data[i] & 0x0F;
 
        *p++ = hex_chars[hi];
        *p++ = hex_chars[lo];
    }
    *p = '\0';
 
    PG_RETURN_CSTRING(buf);
}

References buf, pg_uuid_t::data, i, palloc(), PG_GETARG_UUID_P, PG_RETURN_CSTRING, and UUID_LEN.

uuid_recv()

Datum uuid_recv

(

PG_FUNCTION_ARGS

)

Definition at line 145 of file uuid.c.

{
    StringInfo  buffer = (StringInfo) PG_GETARG_POINTER(0);
    pg_uuid_t  *uuid;
 
    uuid = (pg_uuid_t *) palloc(UUID_LEN);
    memcpy(uuid->data, pq_getmsgbytes(buffer, UUID_LEN), UUID_LEN);
    PG_RETURN_POINTER(uuid);
}

References pg_uuid_t::data, palloc(), PG_GETARG_POINTER, PG_RETURN_POINTER, pq_getmsgbytes(), and UUID_LEN.

uuid_send()

Datum uuid_send

(

PG_FUNCTION_ARGS

)

Definition at line 156 of file uuid.c.

{
    pg_uuid_t  *uuid = PG_GETARG_UUID_P(0);
    StringInfoData buffer;
 
    pq_begintypsend(&buffer);
    pq_sendbytes(&buffer, uuid->data, UUID_LEN);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buffer));
}

References pg_uuid_t::data, PG_GETARG_UUID_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), and UUID_LEN.

uuid_sortsupport()

Datum uuid_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 241 of file uuid.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = uuid_fast_cmp;
    ssup->ssup_extra = NULL;
 
    if (ssup->abbreviate)
    {
        uuid_sortsupport_state *uss;
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
        uss = palloc(sizeof(uuid_sortsupport_state));
        uss->input_count = 0;
        uss->estimating = true;
        initHyperLogLog(&uss->abbr_card, 10);
 
        ssup->ssup_extra = uss;
 
        ssup->comparator = ssup_datum_unsigned_cmp;
        ssup->abbrev_converter = uuid_abbrev_convert;
        ssup->abbrev_abort = uuid_abbrev_abort;
        ssup->abbrev_full_comparator = uuid_fast_cmp;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    PG_RETURN_VOID();
}

References uuid_sortsupport_state::abbr_card, SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, SortSupportData::comparator, uuid_sortsupport_state::estimating, initHyperLogLog(), uuid_sortsupport_state::input_count, MemoryContextSwitchTo(), palloc(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, ssup_datum_unsigned_cmp(), SortSupportData::ssup_extra, uuid_abbrev_abort(), uuid_abbrev_convert(), and uuid_fast_cmp().