mac.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/inet.h"
#include "utils/sortsupport.h"

Include dependency graph for mac.c:

Go to the source code of this file.

Data Structures
struct	macaddr_sortsupport_state

Macros
#define	hibits(addr)    ((unsigned long)(((addr)->a<<16)|((addr)->b<<8)|((addr)->c)))
#define	lobits(addr)    ((unsigned long)(((addr)->d<<16)|((addr)->e<<8)|((addr)->f)))

Functions
static int	macaddr_cmp_internal (macaddr *a1, macaddr *a2)
static int	macaddr_fast_cmp (Datum x, Datum y, SortSupport ssup)
static bool	macaddr_abbrev_abort (int memtupcount, SortSupport ssup)
static Datum	macaddr_abbrev_convert (Datum original, SortSupport ssup)
Datum	macaddr_in (PG_FUNCTION_ARGS)
Datum	macaddr_out (PG_FUNCTION_ARGS)
Datum	macaddr_recv (PG_FUNCTION_ARGS)
Datum	macaddr_send (PG_FUNCTION_ARGS)
Datum	macaddr_cmp (PG_FUNCTION_ARGS)
Datum	macaddr_lt (PG_FUNCTION_ARGS)
Datum	macaddr_le (PG_FUNCTION_ARGS)
Datum	macaddr_eq (PG_FUNCTION_ARGS)
Datum	macaddr_ge (PG_FUNCTION_ARGS)
Datum	macaddr_gt (PG_FUNCTION_ARGS)
Datum	macaddr_ne (PG_FUNCTION_ARGS)
Datum	hashmacaddr (PG_FUNCTION_ARGS)
Datum	hashmacaddrextended (PG_FUNCTION_ARGS)
Datum	macaddr_not (PG_FUNCTION_ARGS)
Datum	macaddr_and (PG_FUNCTION_ARGS)
Datum	macaddr_or (PG_FUNCTION_ARGS)
Datum	macaddr_trunc (PG_FUNCTION_ARGS)
Datum	macaddr_sortsupport (PG_FUNCTION_ARGS)

Macro Definition Documentation

hibits

#define hibits

(

addr

)

((unsigned long)(((addr)->a<<16)|((addr)->b<<8)|((addr)->c)))

Definition at line 30 of file mac.c.

{
    int64       input_count;    /* number of non-null values seen */
    bool        estimating;     /* true if estimating cardinality */
 
    hyperLogLogState abbr_card; /* cardinality estimator */
} macaddr_sortsupport_state;
 
static int  macaddr_cmp_internal(macaddr *a1, macaddr *a2);
static int  macaddr_fast_cmp(Datum x, Datum y, SortSupport ssup);
static bool macaddr_abbrev_abort(int memtupcount, SortSupport ssup);
static Datum macaddr_abbrev_convert(Datum original, SortSupport ssup);
 
/*
 *  MAC address reader.  Accepts several common notations.
 */
 
Datum
macaddr_in(PG_FUNCTION_ARGS)
{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    macaddr    *result;
    int         a,
                b,
                c,
                d,
                e,
                f;
    char        junk[2];
    int         count;
 
    /* %1s matches iff there is trailing non-whitespace garbage */
 
    count = sscanf(str, "%x:%x:%x:%x:%x:%x%1s",
                   &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%x-%x-%x-%x-%x-%x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x:%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x-%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x.%2x%2x.%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x-%2x%2x-%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"", "macaddr",
                        str)));
 
    if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
        (c < 0) || (c > 255) || (d < 0) || (d > 255) ||
        (e < 0) || (e > 255) || (f < 0) || (f > 255))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("invalid octet value in \"macaddr\" value: \"%s\"", str)));
 
    result = palloc_object(macaddr);
 
    result->a = a;
    result->b = b;
    result->c = c;
    result->d = d;
    result->e = e;
    result->f = f;
 
    PG_RETURN_MACADDR_P(result);
}
 
/*
 *  MAC address output function.  Fixed format.
 */
 
Datum
macaddr_out(PG_FUNCTION_ARGS)
{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    char       *result;
 
    result = (char *) palloc(32);
 
    snprintf(result, 32, "%02x:%02x:%02x:%02x:%02x:%02x",
             addr->a, addr->b, addr->c, addr->d, addr->e, addr->f);
 
    PG_RETURN_CSTRING(result);
}
 
/*
 *      macaddr_recv            - converts external binary format to macaddr
 *
 * The external representation is just the six bytes, MSB first.
 */
Datum
macaddr_recv(PG_FUNCTION_ARGS)
{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    macaddr    *addr;
 
    addr = palloc_object(macaddr);
 
    addr->a = pq_getmsgbyte(buf);
    addr->b = pq_getmsgbyte(buf);
    addr->c = pq_getmsgbyte(buf);
    addr->d = pq_getmsgbyte(buf);
    addr->e = pq_getmsgbyte(buf);
    addr->f = pq_getmsgbyte(buf);
 
    PG_RETURN_MACADDR_P(addr);
}
 
/*
 *      macaddr_send            - converts macaddr to binary format
 */
Datum
macaddr_send(PG_FUNCTION_ARGS)
{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendbyte(&buf, addr->a);
    pq_sendbyte(&buf, addr->b);
    pq_sendbyte(&buf, addr->c);
    pq_sendbyte(&buf, addr->d);
    pq_sendbyte(&buf, addr->e);
    pq_sendbyte(&buf, addr->f);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}
 
 
/*
 *  Comparison function for sorting:
 */
 
static int
macaddr_cmp_internal(macaddr *a1, macaddr *a2)
{
    if (hibits(a1) < hibits(a2))
        return -1;
    else if (hibits(a1) > hibits(a2))
        return 1;
    else if (lobits(a1) < lobits(a2))
        return -1;
    else if (lobits(a1) > lobits(a2))
        return 1;
    else
        return 0;
}
 
Datum
macaddr_cmp(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_INT32(macaddr_cmp_internal(a1, a2));
}
 
/*
 *  Boolean comparisons.
 */
 
Datum
macaddr_lt(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) < 0);
}
 
Datum
macaddr_le(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) <= 0);
}
 
Datum
macaddr_eq(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) == 0);
}
 
Datum
macaddr_ge(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) >= 0);
}
 
Datum
macaddr_gt(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) > 0);
}
 
Datum
macaddr_ne(PG_FUNCTION_ARGS)
{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) != 0);
}
 
/*
 * Support function for hash indexes on macaddr.
 */
Datum
hashmacaddr(PG_FUNCTION_ARGS)
{
    macaddr    *key = PG_GETARG_MACADDR_P(0);
 
    return hash_any((unsigned char *) key, sizeof(macaddr));
}
 
Datum
hashmacaddrextended(PG_FUNCTION_ARGS)
{
    macaddr    *key = PG_GETARG_MACADDR_P(0);
 
    return hash_any_extended((unsigned char *) key, sizeof(macaddr),
                             PG_GETARG_INT64(1));
}
 
/*
 * Arithmetic functions: bitwise NOT, AND, OR.
 */
Datum
macaddr_not(PG_FUNCTION_ARGS)
{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = ~addr->a;
    result->b = ~addr->b;
    result->c = ~addr->c;
    result->d = ~addr->d;
    result->e = ~addr->e;
    result->f = ~addr->f;
    PG_RETURN_MACADDR_P(result);
}
 
Datum
macaddr_and(PG_FUNCTION_ARGS)
{
    macaddr    *addr1 = PG_GETARG_MACADDR_P(0);
    macaddr    *addr2 = PG_GETARG_MACADDR_P(1);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = addr1->a & addr2->a;
    result->b = addr1->b & addr2->b;
    result->c = addr1->c & addr2->c;
    result->d = addr1->d & addr2->d;
    result->e = addr1->e & addr2->e;
    result->f = addr1->f & addr2->f;
    PG_RETURN_MACADDR_P(result);
}
 
Datum
macaddr_or(PG_FUNCTION_ARGS)
{
    macaddr    *addr1 = PG_GETARG_MACADDR_P(0);
    macaddr    *addr2 = PG_GETARG_MACADDR_P(1);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = addr1->a | addr2->a;
    result->b = addr1->b | addr2->b;
    result->c = addr1->c | addr2->c;
    result->d = addr1->d | addr2->d;
    result->e = addr1->e | addr2->e;
    result->f = addr1->f | addr2->f;
    PG_RETURN_MACADDR_P(result);
}
 
/*
 *  Truncation function to allow comparing mac manufacturers.
 *  From suggestion by Alex Pilosov <alex@pilosoft.com>
 */
Datum
macaddr_trunc(PG_FUNCTION_ARGS)
{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    macaddr    *result;
 
    result = palloc_object(macaddr);
 
    result->a = addr->a;
    result->b = addr->b;
    result->c = addr->c;
    result->d = 0;
    result->e = 0;
    result->f = 0;
 
    PG_RETURN_MACADDR_P(result);
}
 
/*
 * SortSupport strategy function. Populates a SortSupport struct with the
 * information necessary to use comparison by abbreviated keys.
 */
Datum
macaddr_sortsupport(PG_FUNCTION_ARGS)
{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = macaddr_fast_cmp;
    ssup->ssup_extra = NULL;
 
    if (ssup->abbreviate)
    {
        macaddr_sortsupport_state *uss;
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
        uss = palloc_object(macaddr_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 = macaddr_abbrev_convert;
        ssup->abbrev_abort = macaddr_abbrev_abort;
        ssup->abbrev_full_comparator = macaddr_fast_cmp;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    PG_RETURN_VOID();
}
 
/*
 * SortSupport "traditional" comparison function. Pulls two MAC addresses from
 * the heap and runs a standard comparison on them.
 */
static int
macaddr_fast_cmp(Datum x, Datum y, SortSupport ssup)
{
    macaddr    *arg1 = DatumGetMacaddrP(x);
    macaddr    *arg2 = DatumGetMacaddrP(y);
 
    return macaddr_cmp_internal(arg1, arg2);
}
 
/*
 * Callback for estimating effectiveness of abbreviated key optimization.
 *
 * We pay no attention to the cardinality of the non-abbreviated data, because
 * there is no equality fast-path within authoritative macaddr comparator.
 */
static bool
macaddr_abbrev_abort(int memtupcount, SortSupport ssup)
{
    macaddr_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. At this point
     * we stop counting because we know that we're now fully committed.
     */
    if (abbr_card > 100000.0)
    {
        if (trace_sort)
            elog(LOG,
                 "macaddr_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count, memtupcount);
        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)
    {
        if (trace_sort)
            elog(LOG,
                 "macaddr_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);
        return true;
    }
 
    if (trace_sort)
        elog(LOG,
             "macaddr_abbrev: cardinality %f after " INT64_FORMAT
             " values (%d rows)", abbr_card, uss->input_count, memtupcount);
 
    return false;
}
 
/*
 * SortSupport conversion routine. Converts original macaddr representation
 * to abbreviated key representation.
 *
 * Packs the bytes of a 6-byte MAC address into a Datum and treats it as an
 * unsigned integer for purposes of comparison. On a 64-bit machine, there
 * will be two zeroed bytes of padding. The integer is converted to native
 * endianness to facilitate easy comparison.
 */
static Datum
macaddr_abbrev_convert(Datum original, SortSupport ssup)
{
    macaddr_sortsupport_state *uss = ssup->ssup_extra;
    macaddr    *authoritative = DatumGetMacaddrP(original);
    Datum       res;
 
    /*
     * Zero out the 8-byte Datum and copy in the 6 bytes of the MAC address.
     * There will be two bytes of zero padding on the end of the least
     * significant bits.
     */
    StaticAssertDecl(sizeof(res) >= sizeof(macaddr),
                     "Datum is too small for macaddr");
    memset(&res, 0, sizeof(res));
    memcpy(&res, authoritative, sizeof(macaddr));
    uss->input_count += 1;
 
    /*
     * Cardinality estimation. The estimate uses uint32, so XOR the two 32-bit
     * halves together to produce slightly more entropy. The two zeroed bytes
     * won't have any practical impact on this operation.
     */
    if (uss->estimating)
    {
        uint32      tmp;
 
        tmp = DatumGetUInt32(res) ^ (uint32) (DatumGetUInt64(res) >> 32);
 
        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. Without 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;
}

lobits

#define lobits

(

addr

)

((unsigned long)(((addr)->d<<16)|((addr)->e<<8)|((addr)->f)))

Definition at line 33 of file mac.c.

Function Documentation

hashmacaddr()

Datum hashmacaddr

(

PG_FUNCTION_ARGS

)

Definition at line 267 of file mac.c.

{
    macaddr    *key = PG_GETARG_MACADDR_P(0);
 
    return hash_any((unsigned char *) key, sizeof(macaddr));
}

References hash_any(), and PG_GETARG_MACADDR_P.

hashmacaddrextended()

Datum hashmacaddrextended

(

PG_FUNCTION_ARGS

)

Definition at line 275 of file mac.c.

{
    macaddr    *key = PG_GETARG_MACADDR_P(0);
 
    return hash_any_extended((unsigned char *) key, sizeof(macaddr),
                             PG_GETARG_INT64(1));
}

References hash_any_extended(), PG_GETARG_INT64, and PG_GETARG_MACADDR_P.

macaddr_abbrev_abort()

static bool macaddr_abbrev_abort ( int  memtupcount, SortSupport  ssup  )

static

Definition at line 415 of file mac.c.

{
    macaddr_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. At this point
     * we stop counting because we know that we're now fully committed.
     */
    if (abbr_card > 100000.0)
    {
        if (trace_sort)
            elog(LOG,
                 "macaddr_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count, memtupcount);
        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)
    {
        if (trace_sort)
            elog(LOG,
                 "macaddr_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);
        return true;
    }
 
    if (trace_sort)
        elog(LOG,
             "macaddr_abbrev: cardinality %f after " INT64_FORMAT
             " values (%d rows)", abbr_card, uss->input_count, memtupcount);
 
    return false;
}

References elog, estimateHyperLogLog(), fb(), INT64_FORMAT, LOG, SortSupportData::ssup_extra, and trace_sort.

Referenced by macaddr_sortsupport().

macaddr_abbrev_convert()

static Datum macaddr_abbrev_convert ( Datum  original, SortSupport  ssup  )

static

Definition at line 477 of file mac.c.

{
    macaddr_sortsupport_state *uss = ssup->ssup_extra;
    macaddr    *authoritative = DatumGetMacaddrP(original);
    Datum       res;
 
    /*
     * Zero out the 8-byte Datum and copy in the 6 bytes of the MAC address.
     * There will be two bytes of zero padding on the end of the least
     * significant bits.
     */
    StaticAssertDecl(sizeof(res) >= sizeof(macaddr),
                     "Datum is too small for macaddr");
    memset(&res, 0, sizeof(res));
    memcpy(&res, authoritative, sizeof(macaddr));
    uss->input_count += 1;
 
    /*
     * Cardinality estimation. The estimate uses uint32, so XOR the two 32-bit
     * halves together to produce slightly more entropy. The two zeroed bytes
     * won't have any practical impact on this operation.
     */
    if (uss->estimating)
    {
        uint32      tmp;
 
        tmp = DatumGetUInt32(res) ^ (uint32) (DatumGetUInt64(res) >> 32);
 
        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. Without 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 addHyperLogLog(), DatumBigEndianToNative, DatumGetMacaddrP(), DatumGetUInt32(), DatumGetUInt64(), fb(), hash_uint32(), SortSupportData::ssup_extra, and StaticAssertDecl.

Referenced by macaddr_sortsupport().

macaddr_and()

Datum macaddr_and

(

PG_FUNCTION_ARGS

)

Definition at line 303 of file mac.c.

{
    macaddr    *addr1 = PG_GETARG_MACADDR_P(0);
    macaddr    *addr2 = PG_GETARG_MACADDR_P(1);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = addr1->a & addr2->a;
    result->b = addr1->b & addr2->b;
    result->c = addr1->c & addr2->c;
    result->d = addr1->d & addr2->d;
    result->e = addr1->e & addr2->e;
    result->f = addr1->f & addr2->f;
    PG_RETURN_MACADDR_P(result);
}

References macaddr::a, macaddr::b, macaddr::c, macaddr::d, macaddr::e, macaddr::f, fb(), palloc_object, PG_GETARG_MACADDR_P, and PG_RETURN_MACADDR_P.

macaddr_cmp()

Datum macaddr_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 197 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_INT32(macaddr_cmp_internal(a1, a2));
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_INT32.

Referenced by gbt_macaddr_ssup_cmp(), and gbt_macadkey_cmp().

macaddr_cmp_internal()

static int macaddr_cmp_internal ( macaddr *  a1, macaddr *  a2  )

static

Definition at line 182 of file mac.c.

{
    if (hibits(a1) < hibits(a2))
        return -1;
    else if (hibits(a1) > hibits(a2))
        return 1;
    else if (lobits(a1) < lobits(a2))
        return -1;
    else if (lobits(a1) > lobits(a2))
        return 1;
    else
        return 0;
}

References a1, a2, hibits, and lobits.

Referenced by macaddr_cmp(), macaddr_eq(), macaddr_fast_cmp(), macaddr_ge(), macaddr_gt(), macaddr_le(), macaddr_lt(), and macaddr_ne().

macaddr_eq()

Datum macaddr_eq

(

PG_FUNCTION_ARGS

)

Definition at line 228 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) == 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

Referenced by gbt_macadeq().

macaddr_fast_cmp()

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

static

Definition at line 400 of file mac.c.

{
    macaddr    *arg1 = DatumGetMacaddrP(x);
    macaddr    *arg2 = DatumGetMacaddrP(y);
 
    return macaddr_cmp_internal(arg1, arg2);
}

References DatumGetMacaddrP(), fb(), macaddr_cmp_internal(), x, and y.

Referenced by macaddr_sortsupport().

macaddr_ge()

Datum macaddr_ge

(

PG_FUNCTION_ARGS

)

Definition at line 237 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) >= 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

Referenced by gbt_macadge().

macaddr_gt()

Datum macaddr_gt

(

PG_FUNCTION_ARGS

)

Definition at line 246 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) > 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

Referenced by gbt_macadgt().

macaddr_in()

Datum macaddr_in

(

PG_FUNCTION_ARGS

)

Definition at line 55 of file mac.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    macaddr    *result;
    int         a,
                b,
                c,
                d,
                e,
                f;
    char        junk[2];
    int         count;
 
    /* %1s matches iff there is trailing non-whitespace garbage */
 
    count = sscanf(str, "%x:%x:%x:%x:%x:%x%1s",
                   &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%x-%x-%x-%x-%x-%x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x:%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x-%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x.%2x%2x.%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x-%2x%2x-%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        count = sscanf(str, "%2x%2x%2x%2x%2x%2x%1s",
                       &a, &b, &c, &d, &e, &f, junk);
    if (count != 6)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"", "macaddr",
                        str)));
 
    if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
        (c < 0) || (c > 255) || (d < 0) || (d > 255) ||
        (e < 0) || (e > 255) || (f < 0) || (f > 255))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("invalid octet value in \"macaddr\" value: \"%s\"", str)));
 
    result = palloc_object(macaddr);
 
    result->a = a;
    result->b = b;
    result->c = c;
    result->d = d;
    result->e = e;
    result->f = f;
 
    PG_RETURN_MACADDR_P(result);
}

References a, macaddr::a, b, macaddr::b, macaddr::c, macaddr::d, macaddr::e, ereturn, errcode(), errmsg(), macaddr::f, fb(), palloc_object, PG_GETARG_CSTRING, PG_RETURN_MACADDR_P, and str.

macaddr_le()

Datum macaddr_le

(

PG_FUNCTION_ARGS

)

Definition at line 219 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) <= 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

Referenced by gbt_macadle().

macaddr_lt()

Datum macaddr_lt

(

PG_FUNCTION_ARGS

)

Definition at line 210 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) < 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

Referenced by gbt_macadlt().

macaddr_ne()

Datum macaddr_ne

(

PG_FUNCTION_ARGS

)

Definition at line 255 of file mac.c.

{
    macaddr    *a1 = PG_GETARG_MACADDR_P(0);
    macaddr    *a2 = PG_GETARG_MACADDR_P(1);
 
    PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) != 0);
}

References a1, a2, macaddr_cmp_internal(), PG_GETARG_MACADDR_P, and PG_RETURN_BOOL.

macaddr_not()

Datum macaddr_not

(

PG_FUNCTION_ARGS

)

Definition at line 287 of file mac.c.

{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = ~addr->a;
    result->b = ~addr->b;
    result->c = ~addr->c;
    result->d = ~addr->d;
    result->e = ~addr->e;
    result->f = ~addr->f;
    PG_RETURN_MACADDR_P(result);
}

References macaddr::a, macaddr::b, macaddr::c, macaddr::d, macaddr::e, macaddr::f, fb(), palloc_object, PG_GETARG_MACADDR_P, and PG_RETURN_MACADDR_P.

macaddr_or()

Datum macaddr_or

(

PG_FUNCTION_ARGS

)

Definition at line 320 of file mac.c.

{
    macaddr    *addr1 = PG_GETARG_MACADDR_P(0);
    macaddr    *addr2 = PG_GETARG_MACADDR_P(1);
    macaddr    *result;
 
    result = palloc_object(macaddr);
    result->a = addr1->a | addr2->a;
    result->b = addr1->b | addr2->b;
    result->c = addr1->c | addr2->c;
    result->d = addr1->d | addr2->d;
    result->e = addr1->e | addr2->e;
    result->f = addr1->f | addr2->f;
    PG_RETURN_MACADDR_P(result);
}

References macaddr::a, macaddr::b, macaddr::c, macaddr::d, macaddr::e, macaddr::f, fb(), palloc_object, PG_GETARG_MACADDR_P, and PG_RETURN_MACADDR_P.

macaddr_out()

Datum macaddr_out

(

PG_FUNCTION_ARGS

)

Definition at line 121 of file mac.c.

{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    char       *result;
 
    result = (char *) palloc(32);
 
    snprintf(result, 32, "%02x:%02x:%02x:%02x:%02x:%02x",
             addr->a, addr->b, addr->c, addr->d, addr->e, addr->f);
 
    PG_RETURN_CSTRING(result);
}

References macaddr::a, macaddr::b, macaddr::c, macaddr::d, macaddr::e, macaddr::f, palloc(), PG_GETARG_MACADDR_P, PG_RETURN_CSTRING, and snprintf.

macaddr_recv()

Datum macaddr_recv

(

PG_FUNCTION_ARGS

)

Definition at line 140 of file mac.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    macaddr    *addr;
 
    addr = palloc_object(macaddr);
 
    addr->a = pq_getmsgbyte(buf);
    addr->b = pq_getmsgbyte(buf);
    addr->c = pq_getmsgbyte(buf);
    addr->d = pq_getmsgbyte(buf);
    addr->e = pq_getmsgbyte(buf);
    addr->f = pq_getmsgbyte(buf);
 
    PG_RETURN_MACADDR_P(addr);
}

References macaddr::a, macaddr::b, buf, macaddr::c, macaddr::d, macaddr::e, macaddr::f, palloc_object, PG_GETARG_POINTER, PG_RETURN_MACADDR_P, and pq_getmsgbyte().

macaddr_send()

Datum macaddr_send

(

PG_FUNCTION_ARGS

)

Definition at line 161 of file mac.c.

{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendbyte(&buf, addr->a);
    pq_sendbyte(&buf, addr->b);
    pq_sendbyte(&buf, addr->c);
    pq_sendbyte(&buf, addr->d);
    pq_sendbyte(&buf, addr->e);
    pq_sendbyte(&buf, addr->f);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References macaddr::a, macaddr::b, buf, macaddr::c, macaddr::d, macaddr::e, macaddr::f, PG_GETARG_MACADDR_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendbyte().

macaddr_sortsupport()

Datum macaddr_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 363 of file mac.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = macaddr_fast_cmp;
    ssup->ssup_extra = NULL;
 
    if (ssup->abbreviate)
    {
        macaddr_sortsupport_state *uss;
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
        uss = palloc_object(macaddr_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 = macaddr_abbrev_convert;
        ssup->abbrev_abort = macaddr_abbrev_abort;
        ssup->abbrev_full_comparator = macaddr_fast_cmp;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    PG_RETURN_VOID();
}

References SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, SortSupportData::comparator, fb(), initHyperLogLog(), macaddr_abbrev_abort(), macaddr_abbrev_convert(), macaddr_fast_cmp(), MemoryContextSwitchTo(), palloc_object, PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, ssup_datum_unsigned_cmp(), and SortSupportData::ssup_extra.

macaddr_trunc()

Datum macaddr_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 341 of file mac.c.

{
    macaddr    *addr = PG_GETARG_MACADDR_P(0);
    macaddr    *result;
 
    result = palloc_object(macaddr);
 
    result->a = addr->a;
    result->b = addr->b;
    result->c = addr->c;
    result->d = 0;
    result->e = 0;
    result->f = 0;
 
    PG_RETURN_MACADDR_P(result);
}

References macaddr::a, macaddr::b, macaddr::c, macaddr::d, macaddr::e, macaddr::f, palloc_object, PG_GETARG_MACADDR_P, and PG_RETURN_MACADDR_P.