PostgreSQL Source Code: src/backend/utils/adt/mac.c Source File

PostgreSQL Source Code git master
mac.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * mac.c
4 * PostgreSQL type definitions for 6 byte, EUI-48, MAC addresses.
5 *
6 * Portions Copyright (c) 1998-2025, PostgreSQL Global Development Group
7 *
8 * IDENTIFICATION
9 * src/backend/utils/adt/mac.c
10 *
11 *-------------------------------------------------------------------------
12 */
13
14#include "postgres.h"
15
16#include "common/hashfn.h"
17#include "lib/hyperloglog.h"
18#include "libpq/pqformat.h"
19#include "port/pg_bswap.h"
20#include "utils/fmgrprotos.h"
21#include "utils/guc.h"
22#include "utils/inet.h"
23#include "utils/sortsupport.h"
24
25
26/*
27 * Utility macros used for sorting and comparing:
28 */
29
30 #define hibits(addr) \
31 ((unsigned long)(((addr)->a<<16)|((addr)->b<<8)|((addr)->c)))
32
33 #define lobits(addr) \
34 ((unsigned long)(((addr)->d<<16)|((addr)->e<<8)|((addr)->f)))
35
36/* sortsupport for macaddr */
37 typedef struct
38{
39 int64 input_count; /* number of non-null values seen */
40 bool estimating; /* true if estimating cardinality */
41
42 hyperLogLogState abbr_card; /* cardinality estimator */
43} macaddr_sortsupport_state;
44
45static int macaddr_cmp_internal(macaddr *a1, macaddr *a2);
46static int macaddr_fast_cmp(Datum x, Datum y, SortSupport ssup);
47static bool macaddr_abbrev_abort(int memtupcount, SortSupport ssup);
48static Datum macaddr_abbrev_convert(Datum original, SortSupport ssup);
49
50/*
51 * MAC address reader. Accepts several common notations.
52 */
53
54Datum
55 macaddr_in(PG_FUNCTION_ARGS)
56{
57 char *str = PG_GETARG_CSTRING(0);
58 Node *escontext = fcinfo->context;
59 macaddr *result;
60 int a,
61 b,
62 c,
63 d,
64 e,
65 f;
66 char junk[2];
67 int count;
68
69 /* %1s matches iff there is trailing non-whitespace garbage */
70
71 count = sscanf(str, "%x:%x:%x:%x:%x:%x%1s",
72 &a, &b, &c, &d, &e, &f, junk);
73 if (count != 6)
74 count = sscanf(str, "%x-%x-%x-%x-%x-%x%1s",
75 &a, &b, &c, &d, &e, &f, junk);
76 if (count != 6)
77 count = sscanf(str, "%2x%2x%2x:%2x%2x%2x%1s",
78 &a, &b, &c, &d, &e, &f, junk);
79 if (count != 6)
80 count = sscanf(str, "%2x%2x%2x-%2x%2x%2x%1s",
81 &a, &b, &c, &d, &e, &f, junk);
82 if (count != 6)
83 count = sscanf(str, "%2x%2x.%2x%2x.%2x%2x%1s",
84 &a, &b, &c, &d, &e, &f, junk);
85 if (count != 6)
86 count = sscanf(str, "%2x%2x-%2x%2x-%2x%2x%1s",
87 &a, &b, &c, &d, &e, &f, junk);
88 if (count != 6)
89 count = sscanf(str, "%2x%2x%2x%2x%2x%2x%1s",
90 &a, &b, &c, &d, &e, &f, junk);
91 if (count != 6)
92 ereturn(escontext, (Datum) 0,
93 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
94 errmsg("invalid input syntax for type %s: \"%s\"", "macaddr",
95 str)));
96
97 if ((a < 0) || (a > 255) || (b < 0) || (b > 255) ||
98 (c < 0) || (c > 255) || (d < 0) || (d > 255) ||
99 (e < 0) || (e > 255) || (f < 0) || (f > 255))
100 ereturn(escontext, (Datum) 0,
101 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
102 errmsg("invalid octet value in \"macaddr\" value: \"%s\"", str)));
103
104 result = (macaddr *) palloc(sizeof(macaddr));
105
106 result->a = a;
107 result->b = b;
108 result->c = c;
109 result->d = d;
110 result->e = e;
111 result->f = f;
112
113 PG_RETURN_MACADDR_P(result);
114}
115
116/*
117 * MAC address output function. Fixed format.
118 */
119
120Datum
121 macaddr_out(PG_FUNCTION_ARGS)
122{
123 macaddr *addr = PG_GETARG_MACADDR_P(0);
124 char *result;
125
126 result = (char *) palloc(32);
127
128 snprintf(result, 32, "%02x:%02x:%02x:%02x:%02x:%02x",
129 addr->a, addr->b, addr->c, addr->d, addr->e, addr->f);
130
131 PG_RETURN_CSTRING(result);
132}
133
134/*
135 * macaddr_recv - converts external binary format to macaddr
136 *
137 * The external representation is just the six bytes, MSB first.
138 */
139Datum
140 macaddr_recv(PG_FUNCTION_ARGS)
141{
142 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
143 macaddr *addr;
144
145 addr = (macaddr *) palloc(sizeof(macaddr));
146
147 addr->a = pq_getmsgbyte(buf);
148 addr->b = pq_getmsgbyte(buf);
149 addr->c = pq_getmsgbyte(buf);
150 addr->d = pq_getmsgbyte(buf);
151 addr->e = pq_getmsgbyte(buf);
152 addr->f = pq_getmsgbyte(buf);
153
154 PG_RETURN_MACADDR_P(addr);
155}
156
157/*
158 * macaddr_send - converts macaddr to binary format
159 */
160Datum
161 macaddr_send(PG_FUNCTION_ARGS)
162{
163 macaddr *addr = PG_GETARG_MACADDR_P(0);
164 StringInfoData buf;
165
166 pq_begintypsend(&buf);
167 pq_sendbyte(&buf, addr->a);
168 pq_sendbyte(&buf, addr->b);
169 pq_sendbyte(&buf, addr->c);
170 pq_sendbyte(&buf, addr->d);
171 pq_sendbyte(&buf, addr->e);
172 pq_sendbyte(&buf, addr->f);
173 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
174}
175
176
177/*
178 * Comparison function for sorting:
179 */
180
181static int
182 macaddr_cmp_internal(macaddr *a1, macaddr *a2)
183{
184 if (hibits(a1) < hibits(a2))
185 return -1;
186 else if (hibits(a1) > hibits(a2))
187 return 1;
188 else if (lobits(a1) < lobits(a2))
189 return -1;
190 else if (lobits(a1) > lobits(a2))
191 return 1;
192 else
193 return 0;
194}
195
196Datum
197 macaddr_cmp(PG_FUNCTION_ARGS)
198{
199 macaddr *a1 = PG_GETARG_MACADDR_P(0);
200 macaddr *a2 = PG_GETARG_MACADDR_P(1);
201
202 PG_RETURN_INT32(macaddr_cmp_internal(a1, a2));
203}
204
205/*
206 * Boolean comparisons.
207 */
208
209Datum
210 macaddr_lt(PG_FUNCTION_ARGS)
211{
212 macaddr *a1 = PG_GETARG_MACADDR_P(0);
213 macaddr *a2 = PG_GETARG_MACADDR_P(1);
214
215 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) < 0);
216}
217
218Datum
219 macaddr_le(PG_FUNCTION_ARGS)
220{
221 macaddr *a1 = PG_GETARG_MACADDR_P(0);
222 macaddr *a2 = PG_GETARG_MACADDR_P(1);
223
224 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) <= 0);
225}
226
227Datum
228 macaddr_eq(PG_FUNCTION_ARGS)
229{
230 macaddr *a1 = PG_GETARG_MACADDR_P(0);
231 macaddr *a2 = PG_GETARG_MACADDR_P(1);
232
233 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) == 0);
234}
235
236Datum
237 macaddr_ge(PG_FUNCTION_ARGS)
238{
239 macaddr *a1 = PG_GETARG_MACADDR_P(0);
240 macaddr *a2 = PG_GETARG_MACADDR_P(1);
241
242 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) >= 0);
243}
244
245Datum
246 macaddr_gt(PG_FUNCTION_ARGS)
247{
248 macaddr *a1 = PG_GETARG_MACADDR_P(0);
249 macaddr *a2 = PG_GETARG_MACADDR_P(1);
250
251 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) > 0);
252}
253
254Datum
255 macaddr_ne(PG_FUNCTION_ARGS)
256{
257 macaddr *a1 = PG_GETARG_MACADDR_P(0);
258 macaddr *a2 = PG_GETARG_MACADDR_P(1);
259
260 PG_RETURN_BOOL(macaddr_cmp_internal(a1, a2) != 0);
261}
262
263/*
264 * Support function for hash indexes on macaddr.
265 */
266Datum
267 hashmacaddr(PG_FUNCTION_ARGS)
268{
269 macaddr *key = PG_GETARG_MACADDR_P(0);
270
271 return hash_any((unsigned char *) key, sizeof(macaddr));
272}
273
274Datum
275 hashmacaddrextended(PG_FUNCTION_ARGS)
276{
277 macaddr *key = PG_GETARG_MACADDR_P(0);
278
279 return hash_any_extended((unsigned char *) key, sizeof(macaddr),
280 PG_GETARG_INT64(1));
281}
282
283/*
284 * Arithmetic functions: bitwise NOT, AND, OR.
285 */
286Datum
287 macaddr_not(PG_FUNCTION_ARGS)
288{
289 macaddr *addr = PG_GETARG_MACADDR_P(0);
290 macaddr *result;
291
292 result = (macaddr *) palloc(sizeof(macaddr));
293 result->a = ~addr->a;
294 result->b = ~addr->b;
295 result->c = ~addr->c;
296 result->d = ~addr->d;
297 result->e = ~addr->e;
298 result->f = ~addr->f;
299 PG_RETURN_MACADDR_P(result);
300}
301
302Datum
303 macaddr_and(PG_FUNCTION_ARGS)
304{
305 macaddr *addr1 = PG_GETARG_MACADDR_P(0);
306 macaddr *addr2 = PG_GETARG_MACADDR_P(1);
307 macaddr *result;
308
309 result = (macaddr *) palloc(sizeof(macaddr));
310 result->a = addr1->a & addr2->a;
311 result->b = addr1->b & addr2->b;
312 result->c = addr1->c & addr2->c;
313 result->d = addr1->d & addr2->d;
314 result->e = addr1->e & addr2->e;
315 result->f = addr1->f & addr2->f;
316 PG_RETURN_MACADDR_P(result);
317}
318
319Datum
320 macaddr_or(PG_FUNCTION_ARGS)
321{
322 macaddr *addr1 = PG_GETARG_MACADDR_P(0);
323 macaddr *addr2 = PG_GETARG_MACADDR_P(1);
324 macaddr *result;
325
326 result = (macaddr *) palloc(sizeof(macaddr));
327 result->a = addr1->a | addr2->a;
328 result->b = addr1->b | addr2->b;
329 result->c = addr1->c | addr2->c;
330 result->d = addr1->d | addr2->d;
331 result->e = addr1->e | addr2->e;
332 result->f = addr1->f | addr2->f;
333 PG_RETURN_MACADDR_P(result);
334}
335
336/*
337 * Truncation function to allow comparing mac manufacturers.
338 * From suggestion by Alex Pilosov <alex@pilosoft.com>
339 */
340Datum
341 macaddr_trunc(PG_FUNCTION_ARGS)
342{
343 macaddr *addr = PG_GETARG_MACADDR_P(0);
344 macaddr *result;
345
346 result = (macaddr *) palloc(sizeof(macaddr));
347
348 result->a = addr->a;
349 result->b = addr->b;
350 result->c = addr->c;
351 result->d = 0;
352 result->e = 0;
353 result->f = 0;
354
355 PG_RETURN_MACADDR_P(result);
356}
357
358/*
359 * SortSupport strategy function. Populates a SortSupport struct with the
360 * information necessary to use comparison by abbreviated keys.
361 */
362Datum
363 macaddr_sortsupport(PG_FUNCTION_ARGS)
364{
365 SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
366
367 ssup->comparator = macaddr_fast_cmp;
368 ssup->ssup_extra = NULL;
369
370 if (ssup->abbreviate)
371 {
372 macaddr_sortsupport_state *uss;
373 MemoryContext oldcontext;
374
375 oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
376
377 uss = palloc(sizeof(macaddr_sortsupport_state));
378 uss->input_count = 0;
379 uss->estimating = true;
380 initHyperLogLog(&uss->abbr_card, 10);
381
382 ssup->ssup_extra = uss;
383
384 ssup->comparator = ssup_datum_unsigned_cmp;
385 ssup->abbrev_converter = macaddr_abbrev_convert;
386 ssup->abbrev_abort = macaddr_abbrev_abort;
387 ssup->abbrev_full_comparator = macaddr_fast_cmp;
388
389 MemoryContextSwitchTo(oldcontext);
390 }
391
392 PG_RETURN_VOID();
393}
394
395/*
396 * SortSupport "traditional" comparison function. Pulls two MAC addresses from
397 * the heap and runs a standard comparison on them.
398 */
399static int
400 macaddr_fast_cmp(Datum x, Datum y, SortSupport ssup)
401{
402 macaddr *arg1 = DatumGetMacaddrP(x);
403 macaddr *arg2 = DatumGetMacaddrP(y);
404
405 return macaddr_cmp_internal(arg1, arg2);
406}
407
408/*
409 * Callback for estimating effectiveness of abbreviated key optimization.
410 *
411 * We pay no attention to the cardinality of the non-abbreviated data, because
412 * there is no equality fast-path within authoritative macaddr comparator.
413 */
414static bool
415 macaddr_abbrev_abort(int memtupcount, SortSupport ssup)
416{
417 macaddr_sortsupport_state *uss = ssup->ssup_extra;
418 double abbr_card;
419
420 if (memtupcount < 10000 || uss->input_count < 10000 || !uss->estimating)
421 return false;
422
423 abbr_card = estimateHyperLogLog(&uss->abbr_card);
424
425 /*
426 * If we have >100k distinct values, then even if we were sorting many
427 * billion rows we'd likely still break even, and the penalty of undoing
428 * that many rows of abbrevs would probably not be worth it. At this point
429 * we stop counting because we know that we're now fully committed.
430 */
431 if (abbr_card > 100000.0)
432 {
433 if (trace_sort)
434 elog(LOG,
435 "macaddr_abbrev: estimation ends at cardinality %f"
436 " after " INT64_FORMAT " values (%d rows)",
437 abbr_card, uss->input_count, memtupcount);
438 uss->estimating = false;
439 return false;
440 }
441
442 /*
443 * Target minimum cardinality is 1 per ~2k of non-null inputs. 0.5 row
444 * fudge factor allows us to abort earlier on genuinely pathological data
445 * where we've had exactly one abbreviated value in the first 2k
446 * (non-null) rows.
447 */
448 if (abbr_card < uss->input_count / 2000.0 + 0.5)
449 {
450 if (trace_sort)
451 elog(LOG,
452 "macaddr_abbrev: aborting abbreviation at cardinality %f"
453 " below threshold %f after " INT64_FORMAT " values (%d rows)",
454 abbr_card, uss->input_count / 2000.0 + 0.5, uss->input_count,
455 memtupcount);
456 return true;
457 }
458
459 if (trace_sort)
460 elog(LOG,
461 "macaddr_abbrev: cardinality %f after " INT64_FORMAT
462 " values (%d rows)", abbr_card, uss->input_count, memtupcount);
463
464 return false;
465}
466
467/*
468 * SortSupport conversion routine. Converts original macaddr representation
469 * to abbreviated key representation.
470 *
471 * Packs the bytes of a 6-byte MAC address into a Datum and treats it as an
472 * unsigned integer for purposes of comparison. On a 64-bit machine, there
473 * will be two zeroed bytes of padding. The integer is converted to native
474 * endianness to facilitate easy comparison.
475 */
476static Datum
477 macaddr_abbrev_convert(Datum original, SortSupport ssup)
478{
479 macaddr_sortsupport_state *uss = ssup->ssup_extra;
480 macaddr *authoritative = DatumGetMacaddrP(original);
481 Datum res;
482
483 /*
484 * Zero out the 8-byte Datum and copy in the 6 bytes of the MAC address.
485 * There will be two bytes of zero padding on the end of the least
486 * significant bits.
487 */
488 StaticAssertStmt(sizeof(res) >= sizeof(macaddr),
489 "Datum is too small for macaddr");
490 memset(&res, 0, sizeof(res));
491 memcpy(&res, authoritative, sizeof(macaddr));
492 uss->input_count += 1;
493
494 /*
495 * Cardinality estimation. The estimate uses uint32, so XOR the two 32-bit
496 * halves together to produce slightly more entropy. The two zeroed bytes
497 * won't have any practical impact on this operation.
498 */
499 if (uss->estimating)
500 {
501 uint32 tmp;
502
503 tmp = DatumGetUInt32(res) ^ (uint32) (DatumGetUInt64(res) >> 32);
504
505 addHyperLogLog(&uss->abbr_card, DatumGetUInt32(hash_uint32(tmp)));
506 }
507
508 /*
509 * Byteswap on little-endian machines.
510 *
511 * This is needed so that ssup_datum_unsigned_cmp() (an unsigned integer
512 * 3-way comparator) works correctly on all platforms. Without this, the
513 * comparator would have to call memcmp() with a pair of pointers to the
514 * first byte of each abbreviated key, which is slower.
515 */
516 res = DatumBigEndianToNative(res);
517
518 return res;
519}
#define INT64_FORMAT
Definition: c.h:556
int64_t int64
Definition: c.h:535
uint32_t uint32
Definition: c.h:538
#define StaticAssertStmt(condition, errmessage)
Definition: c.h:937
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define LOG
Definition: elog.h:31
#define ereturn(context, dummy_value,...)
Definition: elog.h:278
#define elog(elevel,...)
Definition: elog.h:226
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:371
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:362
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:277
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
static Datum hash_uint32(uint32 k)
Definition: hashfn.h:43
static Datum hash_any_extended(const unsigned char *k, int keylen, uint64 seed)
Definition: hashfn.h:37
static Datum hash_any(const unsigned char *k, int keylen)
Definition: hashfn.h:31
const char * str
static const FormData_pg_attribute a1
Definition: heap.c:144
static const FormData_pg_attribute a2
Definition: heap.c:157
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
Definition: hyperloglog.c:66
double estimateHyperLogLog(hyperLogLogState *cState)
Definition: hyperloglog.c:186
void addHyperLogLog(hyperLogLogState *cState, uint32 hash)
Definition: hyperloglog.c:167
y
int y
Definition: isn.c:76
b
int b
Definition: isn.c:74
x
int x
Definition: isn.c:75
a
int a
Definition: isn.c:73
Datum macaddr_lt(PG_FUNCTION_ARGS)
Definition: mac.c:210
#define hibits(addr)
Definition: mac.c:30
Datum macaddr_cmp(PG_FUNCTION_ARGS)
Definition: mac.c:197
static int macaddr_cmp_internal(macaddr *a1, macaddr *a2)
Definition: mac.c:182
Datum hashmacaddrextended(PG_FUNCTION_ARGS)
Definition: mac.c:275
Datum hashmacaddr(PG_FUNCTION_ARGS)
Definition: mac.c:267
static Datum macaddr_abbrev_convert(Datum original, SortSupport ssup)
Definition: mac.c:477
Datum macaddr_or(PG_FUNCTION_ARGS)
Definition: mac.c:320
Datum macaddr_recv(PG_FUNCTION_ARGS)
Definition: mac.c:140
Datum macaddr_ne(PG_FUNCTION_ARGS)
Definition: mac.c:255
Datum macaddr_trunc(PG_FUNCTION_ARGS)
Definition: mac.c:341
Datum macaddr_eq(PG_FUNCTION_ARGS)
Definition: mac.c:228
Datum macaddr_in(PG_FUNCTION_ARGS)
Definition: mac.c:55
Datum macaddr_not(PG_FUNCTION_ARGS)
Definition: mac.c:287
static bool macaddr_abbrev_abort(int memtupcount, SortSupport ssup)
Definition: mac.c:415
Datum macaddr_and(PG_FUNCTION_ARGS)
Definition: mac.c:303
Datum macaddr_send(PG_FUNCTION_ARGS)
Definition: mac.c:161
Datum macaddr_sortsupport(PG_FUNCTION_ARGS)
Definition: mac.c:363
#define lobits(addr)
Definition: mac.c:33
Datum macaddr_ge(PG_FUNCTION_ARGS)
Definition: mac.c:237
static int macaddr_fast_cmp(Datum x, Datum y, SortSupport ssup)
Definition: mac.c:400
Datum macaddr_le(PG_FUNCTION_ARGS)
Definition: mac.c:219
Datum macaddr_out(PG_FUNCTION_ARGS)
Definition: mac.c:121
Datum macaddr_gt(PG_FUNCTION_ARGS)
Definition: mac.c:246
void * palloc(Size size)
Definition: mcxt.c:1365
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define DatumBigEndianToNative(x)
Definition: pg_bswap.h:145
static char * buf
Definition: pg_test_fsync.c:72
#define snprintf
Definition: port.h:239
static uint32 DatumGetUInt32(Datum X)
Definition: postgres.h:232
static uint64 DatumGetUInt64(Datum X)
Definition: postgres.h:413
uint64_t Datum
Definition: postgres.h:70
void pq_begintypsend(StringInfo buf)
Definition: pqformat.c:326
int pq_getmsgbyte(StringInfo msg)
Definition: pqformat.c:399
bytea * pq_endtypsend(StringInfo buf)
Definition: pqformat.c:346
static void pq_sendbyte(StringInfo buf, uint8 byt)
Definition: pqformat.h:160
c
char * c
Definition: preproc-cursor.c:31
e
e
Definition: preproc-init.c:82
struct SortSupportData * SortSupport
Definition: sortsupport.h:58
struct StringInfoData * StringInfo
Definition: string.h:15
Definition: nodes.h:135
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:106
Datum(* abbrev_converter)(Datum original, SortSupport ssup)
Definition: sortsupport.h:172
void * ssup_extra
Definition: sortsupport.h:87
MemoryContext ssup_cxt
Definition: sortsupport.h:66
int(* abbrev_full_comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:191
bool(* abbrev_abort)(int memtupcount, SortSupport ssup)
Definition: sortsupport.h:182
Definition: mac.c:38
int64 input_count
Definition: mac.c:39
bool estimating
Definition: mac.c:40
hyperLogLogState abbr_card
Definition: mac.c:42
Definition: inet.h:95
unsigned char e
Definition: inet.h:100
unsigned char b
Definition: inet.h:97
unsigned char f
Definition: inet.h:101
unsigned char c
Definition: inet.h:98
unsigned char a
Definition: inet.h:96
unsigned char d
Definition: inet.h:99
int ssup_datum_unsigned_cmp(Datum x, Datum y, SortSupport ssup)
Definition: tuplesort.c:3133
bool trace_sort
Definition: tuplesort.c:124
#define PG_GETARG_MACADDR_P(n)
Definition: inet.h:158
#define PG_RETURN_MACADDR_P(x)
Definition: inet.h:159
static macaddr * DatumGetMacaddrP(Datum X)
Definition: inet.h:147

AltStyle によって変換されたページ (->オリジナル) /