]> pd.if.org Git - uuid/blob - postgres/uuid.c
added warn and die implementations
[uuid] / postgres / uuid.c
1 /*
2  * uuid type support functions for Postgres 8.4
3  *
4  * written by Nathan Wagner and placed in the public domain
5  */
6 #include "postgres.h"
7 #include "fmgr.h"
8
9 #include "utils/builtins.h"
10 #include "utils/uuid.h"
11 #include "utils/numeric.h"
12 #include "utils/inet.h"
13 #include "utils/timestamp.h"
14 #include "utils/datetime.h"
15 #include "utils/varbit.h"
16
17 #include "pduuid.h"
18
19 #define UUID_LEN_BIN 16
20
21 PG_MODULE_MAGIC;
22
23 void _PG_init(void);
24 void _PG_fini(void);
25
26 Datum uuid_nil(PG_FUNCTION_ARGS);
27 Datum uuid_dns(PG_FUNCTION_ARGS);
28 Datum uuid_url(PG_FUNCTION_ARGS);
29 Datum uuid_oid(PG_FUNCTION_ARGS);
30 Datum uuid_x500(PG_FUNCTION_ARGS);
31 Datum uuid_recent(PG_FUNCTION_ARGS);
32 Datum uuid_gen_v1(PG_FUNCTION_ARGS);
33 Datum uuid_gen_v1_mc(PG_FUNCTION_ARGS);
34 Datum uuid_gen_v3(PG_FUNCTION_ARGS);
35 Datum uuid_gen_v4(PG_FUNCTION_ARGS);
36 Datum uuid_gen_v5(PG_FUNCTION_ARGS);
37 Datum uuid_cast_bit(PG_FUNCTION_ARGS);
38 Datum uuid_cast_from_bit(PG_FUNCTION_ARGS);
39 Datum uuid_cast_numeric(PG_FUNCTION_ARGS);
40 Datum uuid_cast_from_numeric(PG_FUNCTION_ARGS);
41 Datum uuid_cast_bytea(PG_FUNCTION_ARGS);
42 Datum uuid_cast_from_bytea(PG_FUNCTION_ARGS);
43 Datum uuid_extract_version(PG_FUNCTION_ARGS);
44 Datum uuid_extract_macaddr(PG_FUNCTION_ARGS);
45 Datum uuid_extract_timestamp(PG_FUNCTION_ARGS);
46
47 Datum uuid_ns_dns(PG_FUNCTION_ARGS);
48 Datum uuid_ns_url(PG_FUNCTION_ARGS);
49 Datum uuid_ns_oid(PG_FUNCTION_ARGS);
50 Datum uuid_ns_x500(PG_FUNCTION_ARGS);
51
52 static pd_uuid_t        i_gid;
53 static pd_uuid_t        i_ns_uuid;
54 static pd_uuid_t        *gid = NULL;
55 static pd_uuid_t        *ns_uuid = NULL;
56 static struct pd_uuid_state     us;
57
58 void _PG_init(void) {
59         gid = &i_gid;
60         memset(gid, 0, 16);
61         ns_uuid = &i_ns_uuid;
62         memset(ns_uuid, 0, 16);
63
64         pd_uuid_init_state(&us);
65
66         return;
67 }
68
69 #if 0
70 void _PG_fini(void) {
71         if (gid) {
72                 uuid_destroy(gid);
73         }
74         if (ns_uuid) {
75                 uuid_destroy(ns_uuid);
76         }
77         return;
78 }
79 #endif
80
81 PG_FUNCTION_INFO_V1(uuid_nil);
82 Datum uuid_nil(PG_FUNCTION_ARGS) {
83         pg_uuid_t *uuid;
84
85         uuid = palloc(UUID_LEN_BIN);
86         memset(uuid, 0, 16);
87         PG_RETURN_UUID_P(uuid);
88 }
89
90 PG_FUNCTION_INFO_V1(uuid_dns);
91 Datum uuid_dns(PG_FUNCTION_ARGS) {
92         pg_uuid_t *uuid;
93         unsigned char bytes[] = { 0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11,
94                 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 };
95
96         uuid = palloc(UUID_LEN_BIN);
97         memcpy(uuid, bytes, 16);
98         PG_RETURN_UUID_P(uuid);
99 }
100
101 PG_FUNCTION_INFO_V1(uuid_url);
102 Datum uuid_url(PG_FUNCTION_ARGS) {
103         pg_uuid_t *uuid;
104         unsigned char bytes[] = { 0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11,
105                 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 };
106
107         uuid = palloc(UUID_LEN_BIN);
108         memcpy(uuid, bytes, 16);
109         PG_RETURN_UUID_P(uuid);
110 }
111
112 PG_FUNCTION_INFO_V1(uuid_oid);
113 Datum uuid_oid(PG_FUNCTION_ARGS) {
114         pg_uuid_t *uuid;
115         unsigned char bytes[] = { 0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11,
116                 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 };
117
118         uuid = palloc(UUID_LEN_BIN);
119         memcpy(uuid, bytes, 16);
120         PG_RETURN_UUID_P(uuid);
121 }
122
123 PG_FUNCTION_INFO_V1(uuid_x500);
124 Datum uuid_x500(PG_FUNCTION_ARGS) {
125         pg_uuid_t *uuid;
126         unsigned char bytes[] = { 0x6b, 0xa7, 0xb8, 0x13, 0x9d, 0xad, 0x11,
127                 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 };
128
129         uuid = palloc(UUID_LEN_BIN);
130         memcpy(uuid, bytes, 16);
131         PG_RETURN_UUID_P(uuid);
132 }
133
134 static pg_uuid_t *export(pd_uuid_t *u) {
135         pg_uuid_t *pgid;
136
137         pgid = palloc(UUID_LEN_BIN);
138         memcpy(pgid, u, 16);
139
140         return pgid;
141 }
142
143 static void import(pd_uuid_t *u, pg_uuid_t *pgid) {
144         memcpy(u, pgid, 16);
145 }
146
147 PG_FUNCTION_INFO_V1(uuid_recent);
148
149 Datum uuid_recent(PG_FUNCTION_ARGS) {
150         pg_uuid_t *pgid;
151
152         pgid = export(gid);
153         PG_RETURN_UUID_P(pgid);
154 }
155
156 PG_FUNCTION_INFO_V1(uuid_gen_v1);
157
158 Datum uuid_gen_v1(PG_FUNCTION_ARGS) {
159         pg_uuid_t *pgid;
160         
161         if (!pd_uuid_make_v1(&us, gid)) {
162                 elog(ERROR, "can't make uuid");
163         }
164
165         pgid = export(gid);
166         PG_RETURN_UUID_P(pgid);
167 }
168
169 PG_FUNCTION_INFO_V1(uuid_gen_v1_mc);
170
171 Datum uuid_gen_v1_mc(PG_FUNCTION_ARGS) {
172         pg_uuid_t *pgid;
173         
174         if (!pd_uuid_make_v1mc(&us, gid)) {
175                 elog(ERROR, "can't make uuid");
176         }
177
178         pgid = export(gid);
179         PG_RETURN_UUID_P(pgid);
180 }
181
182 PG_FUNCTION_INFO_V1(uuid_gen_v3);
183
184 Datum uuid_gen_v3(PG_FUNCTION_ARGS) {
185         pg_uuid_t *pgid;
186         pg_uuid_t *ns;
187         text    *t;
188         char *string;
189         
190         ns = PG_GETARG_UUID_P(0);
191         t = PG_GETARG_TEXT_P(1);
192
193         import(ns_uuid, ns);
194
195         string = text_to_cstring(t);
196
197         if (!pd_uuid_make_v3(&us, gid, ns_uuid, string, strlen(string))) {
198                 elog(ERROR, "can't make uuid");
199         }
200         pfree(string);
201
202         pgid = export(gid);
203         PG_RETURN_UUID_P(pgid);
204 }
205
206 PG_FUNCTION_INFO_V1(uuid_gen_v4);
207
208 Datum uuid_gen_v4(PG_FUNCTION_ARGS) {
209         pg_uuid_t *pgid;
210
211         if (!pd_uuid_make_v4(&us, gid)) {
212                 elog(ERROR, "can't make uuid");
213         }
214
215         pgid = export(gid);
216         PG_RETURN_UUID_P(pgid);
217 }
218
219 PG_FUNCTION_INFO_V1(uuid_gen_v5);
220
221 Datum uuid_gen_v5(PG_FUNCTION_ARGS) {
222         pg_uuid_t *pgid;
223         pg_uuid_t *ns;
224         text    *t;
225         char *string;
226         
227         if (!gid || !ns_uuid) {
228                 elog(ERROR, "UUID library failed to initialize");
229         }
230
231         ns = PG_GETARG_UUID_P(0);
232         t = PG_GETARG_TEXT_P(1);
233
234         import(ns_uuid, ns);
235
236         string = text_to_cstring(t);
237
238         if (!pd_uuid_make_v5(&us, gid,ns_uuid, string, strlen(string))) {
239                 elog(ERROR, "can't make uuid");
240         }
241         pfree(string);
242
243         pgid = export(gid);
244         PG_RETURN_UUID_P(pgid);
245 }
246
247 PG_FUNCTION_INFO_V1(uuid_cast_bit);
248 Datum uuid_cast_bit(PG_FUNCTION_ARGS) {
249         VarBit  *bit;
250
251         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
252
253         bit = palloc(VARBITTOTALLEN(128));
254         bit->bit_len = 128;
255         bit->vl_len_ = VARBITTOTALLEN(128);
256         memcpy(VARBITS(bit), uuid, 16);
257         PG_RETURN_VARBIT_P(bit);
258 }
259
260 PG_FUNCTION_INFO_V1(uuid_cast_from_bit);
261 Datum uuid_cast_from_bit(PG_FUNCTION_ARGS) {
262         pg_uuid_t *uuid;
263
264         VarBit  *bit = PG_GETARG_VARBIT_P(0);
265
266         if (bit->bit_len != 128) {
267                 /* Throw error? */
268                 elog(ERROR, "can't cast from bit(%d) to uuid, must cast from bit(128)", bit->bit_len);
269         }
270
271         uuid = palloc(UUID_LEN_BIN);
272         memcpy(uuid, VARBITS(bit), 16);
273         PG_RETURN_UUID_P(uuid);
274 }
275
276 PG_FUNCTION_INFO_V1(uuid_cast_bytea);
277 Datum uuid_cast_bytea(PG_FUNCTION_ARGS) {
278         bytea   *bit;
279
280         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
281
282         bit = palloc(VARHDRSZ + 16);
283         SET_VARSIZE(bit, VARHDRSZ + 16);
284         memcpy(VARDATA(bit), uuid, 16);
285         PG_RETURN_BYTEA_P(bit);
286 }
287
288 PG_FUNCTION_INFO_V1(uuid_cast_from_bytea);
289 Datum uuid_cast_from_bytea(PG_FUNCTION_ARGS) {
290         pg_uuid_t *uuid; 
291
292         bytea   *bit = PG_GETARG_BYTEA_P(0);
293
294         if (VARSIZE_ANY_EXHDR(bit) != 16) {
295                 elog(ERROR, "invalid length of bytea for cast to uuid, need 16, attempted %d", VARSIZE_ANY_EXHDR(bit));
296         }
297
298         uuid = palloc(UUID_LEN_BIN);
299         memcpy(uuid, VARDATA(bit), 16);
300         PG_RETURN_UUID_P(uuid);
301 }
302
303 /* TODO construct the uuid directly from the numeric */
304 /* TODO have a static c256 numeric */
305
306 PG_FUNCTION_INFO_V1(uuid_cast_from_numeric);
307 Datum uuid_cast_from_numeric(PG_FUNCTION_ARGS) {
308         int i;
309         unsigned char *data;
310         int32   byte;
311
312         Numeric c256;
313         Numeric input;
314         Numeric result;
315         pg_uuid_t       *uuid;
316
317         input = PG_GETARG_NUMERIC(0);
318         uuid = palloc(UUID_LEN_BIN);
319         data = (unsigned char *)uuid;
320
321         c256 = DatumGetNumeric(DirectFunctionCall1(int4_numeric, Int32GetDatum(256)));
322
323         for (i=15;i>=0;i--) {
324                 result = DatumGetNumeric(DirectFunctionCall2(numeric_mod, NumericGetDatum(input), NumericGetDatum(c256)));
325
326                 input = DatumGetNumeric(DirectFunctionCall2(numeric_div_trunc, NumericGetDatum(input), NumericGetDatum(c256)));
327
328                 byte = DatumGetInt32(DirectFunctionCall1(numeric_int4, NumericGetDatum(result)));
329                 data[i] = byte & 0xff;
330         }
331
332         /* TODO will this leak if I don't do this?  Segfault if i do? */
333         pfree(c256);
334
335         PG_RETURN_UUID_P(uuid);
336 }
337
338 /*
339  * TODO construct the numeric directly
340  */
341 PG_FUNCTION_INFO_V1(uuid_cast_numeric);
342 Datum uuid_cast_numeric(PG_FUNCTION_ARGS) {
343         int i;
344         unsigned char *data;
345         int32   byte;
346
347         Numeric result;
348         Numeric c256;
349
350         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
351
352         data = (unsigned char *)uuid;
353
354         result = DatumGetNumeric(DirectFunctionCall1(int4_numeric, Int32GetDatum(0)));
355         
356         c256 = DatumGetNumeric(DirectFunctionCall1(int4_numeric, Int32GetDatum(256)));
357
358         for (i=0;i<16;i++) {
359                 byte = (int32) data[i];
360
361                 result = DatumGetNumeric(DirectFunctionCall2(numeric_mul, NumericGetDatum(result), NumericGetDatum(c256)));
362
363                 result = DatumGetNumeric(
364                                 DirectFunctionCall2(numeric_add,
365                                         NumericGetDatum(result),
366                                         DirectFunctionCall1(int4_numeric, Int32GetDatum(byte))));
367
368         }
369
370         pfree(c256);
371
372         PG_RETURN_NUMERIC(result);
373 }
374
375 PG_FUNCTION_INFO_V1(uuid_extract_version);
376 Datum uuid_extract_version(PG_FUNCTION_ARGS) {
377         int32 version;
378         unsigned char *data;
379
380         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
381         data = (unsigned char *)uuid;
382
383         version = data[6] >> 4;
384         PG_RETURN_INT32(version);
385 }
386
387 PG_FUNCTION_INFO_V1(uuid_extract_macaddr);
388 Datum uuid_extract_macaddr(PG_FUNCTION_ARGS) {
389         macaddr *mac;
390         unsigned char *data;
391
392         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
393         data = (unsigned char *)uuid;
394
395         mac = palloc(sizeof *mac);
396         mac->a = data[10];
397         mac->b = data[11];
398         mac->c = data[12];
399         mac->d = data[13];
400         mac->e = data[14];
401         mac->f = data[15];
402
403         PG_RETURN_MACADDR_P(mac);
404 }
405
406 /* number of 100 nanosecond intervals from 1585-10-15 to 1970-01-01 */
407 #define GREGORIAN 122192928000000000ULL
408
409 PG_FUNCTION_INFO_V1(uuid_extract_timestamp);
410 Datum uuid_extract_timestamp(PG_FUNCTION_ARGS) {
411         Timestamp ts;
412         unsigned char *data;
413
414         pg_uuid_t *uuid = PG_GETARG_UUID_P(0);
415         data = (unsigned char *)uuid;
416
417         ts = (data[6] & 0xf);
418         ts *= 256; ts += (data[7] & 0xff);
419         ts *= 256; ts += (data[4] & 0xff);
420         ts *= 256; ts += (data[5] & 0xff);
421         ts *= 256; ts += (data[0] & 0xff);
422         ts *= 256; ts += (data[1] & 0xff);
423         ts *= 256; ts += (data[2] & 0xff);
424         ts *= 256; ts += (data[3] & 0xff);
425
426         /* TODO could probably combine some of this */
427         ts -= GREGORIAN; /* adjust by offset from gregorian to unix epoch */
428         ts /= 10; /* convert from 100 ns to us */
429
430         ts -= ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY * 1000000LL);
431
432 #ifdef HAVE_INT64_TIMESTAMP
433         PG_RETURN_TIMESTAMP(ts);
434 #else
435         PG_RETURN_TIMESTAMP(ts/1000000UL);
436 #endif
437 }