?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace the hard-wired type knowledge in TypeCategory() and IsPreferredType()
[PostgreSQL.git] / contrib / hstore / hstore_op.c
blob4f285ee633953d3ab5c13d2a26856183112912fa
1 /*
2 * $PostgreSQL
3 */
4 #include "postgres.h"
5
6 #include "catalog/pg_type.h"
7 #include "funcapi.h"
8 #include "utils/array.h"
9 #include "utils/builtins.h"
10
11 #include "hstore.h"
12
13
14 static HEntry *
15 findkey(HStore * hs, char *key, int keylen)
16 {
17 HEntry *StopLow = ARRPTR(hs);
18 HEntry *StopHigh = StopLow + hs->size;
19 HEntry *StopMiddle;
20 int difference;
21 char *base = STRPTR(hs);
22
23 while (StopLow < StopHigh)
24 {
25 StopMiddle = StopLow + (StopHigh - StopLow) / 2;
26
27 if (StopMiddle->keylen == keylen)
28 difference = strncmp(base + StopMiddle->pos, key, StopMiddle->keylen);
29 else
30 difference = (StopMiddle->keylen > keylen) ? 1 : -1;
31
32 if (difference == 0)
33 return StopMiddle;
34 else if (difference < 0)
35 StopLow = StopMiddle + 1;
36 else
37 StopHigh = StopMiddle;
38 }
39
40 return NULL;
41 }
42
43 PG_FUNCTION_INFO_V1(fetchval);
44 Datum fetchval(PG_FUNCTION_ARGS);
45 Datum
46 fetchval(PG_FUNCTION_ARGS)
47 {
48 HStore *hs = PG_GETARG_HS(0);
49 text *key = PG_GETARG_TEXT_P(1);
50 HEntry *entry;
51 text *out;
52
53 if ((entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ)) == NULL || entry->valisnull)
54 {
55 PG_FREE_IF_COPY(hs, 0);
56 PG_FREE_IF_COPY(key, 1);
57 PG_RETURN_NULL();
58 }
59
60 out = cstring_to_text_with_len(STRPTR(hs) + entry->pos + entry->keylen,
61 entry->vallen);
62
63 PG_FREE_IF_COPY(hs, 0);
64 PG_FREE_IF_COPY(key, 1);
65 PG_RETURN_TEXT_P(out);
66 }
67
68 PG_FUNCTION_INFO_V1(exists);
69 Datum exists(PG_FUNCTION_ARGS);
70 Datum
71 exists(PG_FUNCTION_ARGS)
72 {
73 HStore *hs = PG_GETARG_HS(0);
74 text *key = PG_GETARG_TEXT_P(1);
75 HEntry *entry;
76
77 entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ);
78
79 PG_FREE_IF_COPY(hs, 0);
80 PG_FREE_IF_COPY(key, 1);
81
82 PG_RETURN_BOOL(entry);
83 }
84
85 PG_FUNCTION_INFO_V1(defined);
86 Datum defined(PG_FUNCTION_ARGS);
87 Datum
88 defined(PG_FUNCTION_ARGS)
89 {
90 HStore *hs = PG_GETARG_HS(0);
91 text *key = PG_GETARG_TEXT_P(1);
92 HEntry *entry;
93 bool res;
94
95 entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ);
96
97 res = (entry && !entry->valisnull) ? true : false;
98
99 PG_FREE_IF_COPY(hs, 0);
100 PG_FREE_IF_COPY(key, 1);
101
102 PG_RETURN_BOOL(res);
103 }
104
105 PG_FUNCTION_INFO_V1(delete);
106 Datum delete(PG_FUNCTION_ARGS);
107 Datum
108 delete(PG_FUNCTION_ARGS)
109 {
110 HStore *hs = PG_GETARG_HS(0);
111 text *key = PG_GETARG_TEXT_P(1);
112 HStore *out = palloc(VARSIZE(hs));
113 char *ptrs,
114 *ptrd;
115 HEntry *es,
116 *ed;
117
118 SET_VARSIZE(out, VARSIZE(hs));
119 out->size = hs->size; /* temporary! */
120
121 ptrs = STRPTR(hs);
122 es = ARRPTR(hs);
123 ptrd = STRPTR(out);
124 ed = ARRPTR(out);
125
126 while (es - ARRPTR(hs) < hs->size)
127 {
128 if (!(es->keylen == VARSIZE(key) - VARHDRSZ && strncmp(ptrs, VARDATA(key), es->keylen) == 0))
129 {
130 memcpy(ed, es, sizeof(HEntry));
131 memcpy(ptrd, ptrs, es->keylen + ((es->valisnull) ? 0 : es->vallen));
132 ed->pos = ptrd - STRPTR(out);
133 ptrd += es->keylen + ((es->valisnull) ? 0 : es->vallen);
134 ed++;
135 }
136 ptrs += es->keylen + ((es->valisnull) ? 0 : es->vallen);
137 es++;
138 }
139
140 if (ed - ARRPTR(out) != out->size)
141 {
142 int buflen = ptrd - STRPTR(out);
143
144 ptrd = STRPTR(out);
145
146 out->size = ed - ARRPTR(out);
147
148 memmove(STRPTR(out), ptrd, buflen);
149 SET_VARSIZE(out, CALCDATASIZE(out->size, buflen));
150 }
151
152
153 PG_FREE_IF_COPY(hs, 0);
154 PG_FREE_IF_COPY(key, 1);
155
156 PG_RETURN_POINTER(out);
157 }
158
159 PG_FUNCTION_INFO_V1(hs_concat);
160 Datum hs_concat(PG_FUNCTION_ARGS);
161 Datum
162 hs_concat(PG_FUNCTION_ARGS)
163 {
164 HStore *s1 = PG_GETARG_HS(0);
165 HStore *s2 = PG_GETARG_HS(1);
166 HStore *out = palloc(VARSIZE(s1) + VARSIZE(s2));
167 char *ps1,
168 *ps2,
169 *pd;
170 HEntry *es1,
171 *es2,
172 *ed;
173
174 SET_VARSIZE(out, VARSIZE(s1) + VARSIZE(s2));
175 out->size = s1->size + s2->size;
176
177 ps1 = STRPTR(s1);
178 ps2 = STRPTR(s2);
179 pd = STRPTR(out);
180 es1 = ARRPTR(s1);
181 es2 = ARRPTR(s2);
182 ed = ARRPTR(out);
183
184 while (es1 - ARRPTR(s1) < s1->size && es2 - ARRPTR(s2) < s2->size)
185 {
186 int difference;
187
188 if (es1->keylen == es2->keylen)
189 difference = strncmp(ps1, ps2, es1->keylen);
190 else
191 difference = (es1->keylen > es2->keylen) ? 1 : -1;
192
193 if (difference == 0)
194 {
195 memcpy(ed, es2, sizeof(HEntry));
196 memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen));
197 ed->pos = pd - STRPTR(out);
198 pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
199 ed++;
200
201 ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen);
202 es1++;
203 ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
204 es2++;
205 }
206 else if (difference > 0)
207 {
208 memcpy(ed, es2, sizeof(HEntry));
209 memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen));
210 ed->pos = pd - STRPTR(out);
211 pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
212 ed++;
213
214 ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
215 es2++;
216 }
217 else
218 {
219 memcpy(ed, es1, sizeof(HEntry));
220 memcpy(pd, ps1, es1->keylen + ((es1->valisnull) ? 0 : es1->vallen));
221 ed->pos = pd - STRPTR(out);
222 pd += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen);
223 ed++;
224
225 ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen);
226 es1++;
227 }
228 }
229
230 while (es1 - ARRPTR(s1) < s1->size)
231 {
232 memcpy(ed, es1, sizeof(HEntry));
233 memcpy(pd, ps1, es1->keylen + ((es1->valisnull) ? 0 : es1->vallen));
234 ed->pos = pd - STRPTR(out);
235 pd += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen);
236 ed++;
237
238 ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen);
239 es1++;
240 }
241
242 while (es2 - ARRPTR(s2) < s2->size)
243 {
244 memcpy(ed, es2, sizeof(HEntry));
245 memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen));
246 ed->pos = pd - STRPTR(out);
247 pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
248 ed++;
249
250 ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen);
251 es2++;
252 }
253
254 if (ed - ARRPTR(out) != out->size)
255 {
256 int buflen = pd - STRPTR(out);
257
258 pd = STRPTR(out);
259
260 out->size = ed - ARRPTR(out);
261
262 memmove(STRPTR(out), pd, buflen);
263 SET_VARSIZE(out, CALCDATASIZE(out->size, buflen));
264 }
265
266 PG_FREE_IF_COPY(s1, 0);
267 PG_FREE_IF_COPY(s2, 1);
268
269 PG_RETURN_POINTER(out);
270 }
271
272 PG_FUNCTION_INFO_V1(tconvert);
273 Datum tconvert(PG_FUNCTION_ARGS);
274 Datum
275 tconvert(PG_FUNCTION_ARGS)
276 {
277 text *key;
278 text *val = NULL;
279 int len;
280 HStore *out;
281
282 if (PG_ARGISNULL(0))
283 PG_RETURN_NULL();
284
285 key = PG_GETARG_TEXT_P(0);
286
287 if (PG_ARGISNULL(1))
288 len = CALCDATASIZE(1, VARSIZE(key));
289 else
290 {
291 val = PG_GETARG_TEXT_P(1);
292 len = CALCDATASIZE(1, VARSIZE(key) + VARSIZE(val) - 2 * VARHDRSZ);
293 }
294 out = palloc(len);
295 SET_VARSIZE(out, len);
296 out->size = 1;
297
298 ARRPTR(out)->keylen = VARSIZE(key) - VARHDRSZ;
299 if (PG_ARGISNULL(1))
300 {
301 ARRPTR(out)->vallen = 0;
302 ARRPTR(out)->valisnull = true;
303 }
304 else
305 {
306 ARRPTR(out)->vallen = VARSIZE(val) - VARHDRSZ;
307 ARRPTR(out)->valisnull = false;
308 }
309 ARRPTR(out)->pos = 0;
310
311 memcpy(STRPTR(out), VARDATA(key), ARRPTR(out)->keylen);
312 if (!PG_ARGISNULL(1))
313 {
314 memcpy(STRPTR(out) + ARRPTR(out)->keylen, VARDATA(val), ARRPTR(out)->vallen);
315 PG_FREE_IF_COPY(val, 1);
316 }
317
318 PG_FREE_IF_COPY(key, 0);
319
320 PG_RETURN_POINTER(out);
321 }
322
323 PG_FUNCTION_INFO_V1(akeys);
324 Datum akeys(PG_FUNCTION_ARGS);
325 Datum
326 akeys(PG_FUNCTION_ARGS)
327 {
328 HStore *hs = PG_GETARG_HS(0);
329 Datum *d;
330 ArrayType *a;
331 HEntry *ptr = ARRPTR(hs);
332 char *base = STRPTR(hs);
333
334 d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1));
335 while (ptr - ARRPTR(hs) < hs->size)
336 {
337 text *item;
338
339 item = cstring_to_text_with_len(base + ptr->pos, ptr->keylen);
340 d[ptr - ARRPTR(hs)] = PointerGetDatum(item);
341 ptr++;
342 }
343
344 a = construct_array(d,
345 hs->size,
346 TEXTOID,
347 -1,
348 false,
349 'i');
350
351 ptr = ARRPTR(hs);
352 while (ptr - ARRPTR(hs) < hs->size)
353 {
354 pfree(DatumGetPointer(d[ptr - ARRPTR(hs)]));
355 ptr++;
356 }
357
358 pfree(d);
359 PG_FREE_IF_COPY(hs, 0);
360
361 PG_RETURN_POINTER(a);
362 }
363
364 PG_FUNCTION_INFO_V1(avals);
365 Datum avals(PG_FUNCTION_ARGS);
366 Datum
367 avals(PG_FUNCTION_ARGS)
368 {
369 HStore *hs = PG_GETARG_HS(0);
370 Datum *d;
371 ArrayType *a;
372 HEntry *ptr = ARRPTR(hs);
373 char *base = STRPTR(hs);
374
375 d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1));
376 while (ptr - ARRPTR(hs) < hs->size)
377 {
378 text *item;
379
380 item = cstring_to_text_with_len(base + ptr->pos + ptr->keylen,
381 (ptr->valisnull) ? 0 : ptr->vallen);
382 d[ptr - ARRPTR(hs)] = PointerGetDatum(item);
383 ptr++;
384 }
385
386 a = construct_array(d,
387 hs->size,
388 TEXTOID,
389 -1,
390 false,
391 'i');
392
393 ptr = ARRPTR(hs);
394 while (ptr - ARRPTR(hs) < hs->size)
395 {
396 pfree(DatumGetPointer(d[ptr - ARRPTR(hs)]));
397 ptr++;
398 }
399
400 pfree(d);
401 PG_FREE_IF_COPY(hs, 0);
402
403 PG_RETURN_POINTER(a);
404 }
405
406 typedef struct
407 {
408 HStore *hs;
409 int i;
410 } AKStore;
411
412 static void
413 setup_firstcall(FuncCallContext *funcctx, HStore * hs)
414 {
415 MemoryContext oldcontext;
416 AKStore *st;
417
418 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
419
420 st = (AKStore *) palloc(sizeof(AKStore));
421 st->i = 0;
422 st->hs = (HStore *) palloc(VARSIZE(hs));
423 memcpy(st->hs, hs, VARSIZE(hs));
424
425 funcctx->user_fctx = (void *) st;
426 MemoryContextSwitchTo(oldcontext);
427 }
428
429 PG_FUNCTION_INFO_V1(skeys);
430 Datum skeys(PG_FUNCTION_ARGS);
431 Datum
432 skeys(PG_FUNCTION_ARGS)
433 {
434 FuncCallContext *funcctx;
435 AKStore *st;
436
437 if (SRF_IS_FIRSTCALL())
438 {
439 HStore *hs = PG_GETARG_HS(0);
440
441 funcctx = SRF_FIRSTCALL_INIT();
442 setup_firstcall(funcctx, hs);
443 PG_FREE_IF_COPY(hs, 0);
444 }
445
446 funcctx = SRF_PERCALL_SETUP();
447 st = (AKStore *) funcctx->user_fctx;
448
449 if (st->i < st->hs->size)
450 {
451 HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
452 text *item;
453
454 item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos,
455 ptr->keylen);
456 st->i++;
457
458 SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
459 }
460
461 pfree(st->hs);
462 pfree(st);
463
464 SRF_RETURN_DONE(funcctx);
465 }
466
467 PG_FUNCTION_INFO_V1(svals);
468 Datum svals(PG_FUNCTION_ARGS);
469 Datum
470 svals(PG_FUNCTION_ARGS)
471 {
472 FuncCallContext *funcctx;
473 AKStore *st;
474
475 if (SRF_IS_FIRSTCALL())
476 {
477 HStore *hs = PG_GETARG_HS(0);
478
479 funcctx = SRF_FIRSTCALL_INIT();
480 setup_firstcall(funcctx, hs);
481 PG_FREE_IF_COPY(hs, 0);
482 }
483
484 funcctx = SRF_PERCALL_SETUP();
485 st = (AKStore *) funcctx->user_fctx;
486
487 if (st->i < st->hs->size)
488 {
489 HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
490
491 if (ptr->valisnull)
492 {
493 ReturnSetInfo *rsi;
494
495 st->i++;
496 (funcctx)->call_cntr++;
497 rsi = (ReturnSetInfo *) fcinfo->resultinfo;
498 rsi->isDone = ExprMultipleResult;
499 PG_RETURN_NULL();
500 }
501 else
502 {
503 text *item;
504
505 item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos + ptr->keylen,
506 ptr->vallen);
507 st->i++;
508
509 SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
510 }
511 }
512
513 pfree(st->hs);
514 pfree(st);
515
516 SRF_RETURN_DONE(funcctx);
517 }
518
519 PG_FUNCTION_INFO_V1(hs_contains);
520 Datum hs_contains(PG_FUNCTION_ARGS);
521 Datum
522 hs_contains(PG_FUNCTION_ARGS)
523 {
524 HStore *val = PG_GETARG_HS(0);
525 HStore *tmpl = PG_GETARG_HS(1);
526 bool res = true;
527 HEntry *te = ARRPTR(tmpl);
528 char *vv = STRPTR(val);
529 char *tv = STRPTR(tmpl);
530
531 while (res && te - ARRPTR(tmpl) < tmpl->size)
532 {
533 HEntry *entry = findkey(val, tv + te->pos, te->keylen);
534
535 if (entry)
536 {
537 if (te->valisnull || entry->valisnull)
538 {
539 if (!(te->valisnull && entry->valisnull))
540 res = false;
541 }
542 else if (te->vallen != entry->vallen ||
543 strncmp(
544 vv + entry->pos + entry->keylen,
545 tv + te->pos + te->keylen,
546 te->vallen)
547 )
548 res = false;
549 }
550 else
551 res = false;
552 te++;
553 }
554
555 PG_FREE_IF_COPY(val, 0);
556 PG_FREE_IF_COPY(tmpl, 1);
557
558 PG_RETURN_BOOL(res);
559 }
560
561 PG_FUNCTION_INFO_V1(hs_contained);
562 Datum hs_contained(PG_FUNCTION_ARGS);
563 Datum
564 hs_contained(PG_FUNCTION_ARGS)
565 {
566 PG_RETURN_DATUM(DirectFunctionCall2(
567 hs_contains,
568 PG_GETARG_DATUM(1),
569 PG_GETARG_DATUM(0)
570 ));
571 }
572
573 PG_FUNCTION_INFO_V1(each);
574 Datum each(PG_FUNCTION_ARGS);
575 Datum
576 each(PG_FUNCTION_ARGS)
577 {
578 FuncCallContext *funcctx;
579 AKStore *st;
580
581 if (SRF_IS_FIRSTCALL())
582 {
583 TupleDesc tupdesc;
584 MemoryContext oldcontext;
585 HStore *hs = PG_GETARG_HS(0);
586
587 funcctx = SRF_FIRSTCALL_INIT();
588 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
589 st = (AKStore *) palloc(sizeof(AKStore));
590 st->i = 0;
591 st->hs = (HStore *) palloc(VARSIZE(hs));
592 memcpy(st->hs, hs, VARSIZE(hs));
593 funcctx->user_fctx = (void *) st;
594
595 /* Build a tuple descriptor for our result type */
596 if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
597 elog(ERROR, "return type must be a row type");
598
599 funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
600
601 MemoryContextSwitchTo(oldcontext);
602 PG_FREE_IF_COPY(hs, 0);
603 }
604
605 funcctx = SRF_PERCALL_SETUP();
606 st = (AKStore *) funcctx->user_fctx;
607
608 if (st->i < st->hs->size)
609 {
610 HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
611 Datum res,
612 dvalues[2];
613 char nulls[] = {' ', ' '};
614 text *item;
615 HeapTuple tuple;
616
617 item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos, ptr->keylen);
618 dvalues[0] = PointerGetDatum(item);
619
620 if (ptr->valisnull)
621 {
622 dvalues[1] = (Datum) 0;
623 nulls[1] = 'n';
624 }
625 else
626 {
627 item = cstring_to_text_with_len(STRPTR(st->hs) + ptr->pos + ptr->keylen,
628 ptr->vallen);
629 dvalues[1] = PointerGetDatum(item);
630 }
631 st->i++;
632
633 tuple = heap_formtuple(funcctx->attinmeta->tupdesc, dvalues, nulls);
634 res = HeapTupleGetDatum(tuple);
635
636 pfree(DatumGetPointer(dvalues[0]));
637 if (nulls[1] != 'n')
638 pfree(DatumGetPointer(dvalues[1]));
639
640 SRF_RETURN_NEXT(funcctx, PointerGetDatum(res));
641 }
642
643 pfree(st->hs);
644 pfree(st);
645
646 SRF_RETURN_DONE(funcctx);
647 }
PostgreSQL from CVS