?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More sensible character_octet_length
[PostgreSQL.git] / contrib / ltree / ltree_io.c
blobee6ee568e3e47cd38e06c91908945bba3aff16dd
1 /*
2 * in/out function for ltree and lquery
3 * Teodor Sigaev <teodor@stack.net>
4 * $PostgreSQL$
5 */
6 #include "postgres.h"
7
8 #include <ctype.h>
9
10 #include "ltree.h"
11 #include "crc32.h"
12
13 PG_FUNCTION_INFO_V1(ltree_in);
14 Datum ltree_in(PG_FUNCTION_ARGS);
15
16 PG_FUNCTION_INFO_V1(ltree_out);
17 Datum ltree_out(PG_FUNCTION_ARGS);
18
19 PG_FUNCTION_INFO_V1(lquery_in);
20 Datum lquery_in(PG_FUNCTION_ARGS);
21
22 PG_FUNCTION_INFO_V1(lquery_out);
23 Datum lquery_out(PG_FUNCTION_ARGS);
24
25
26 #define UNCHAR ereport(ERROR, \
27 (errcode(ERRCODE_SYNTAX_ERROR), \
28 errmsg("syntax error at position %d", \
29 pos)));
30
31
32 typedef struct
33 {
34 char *start;
35 int len; /* length in bytes */
36 int flag;
37 int wlen; /* length in characters */
38 } nodeitem;
39
40 #define LTPRS_WAITNAME 0
41 #define LTPRS_WAITDELIM 1
42
43 Datum
44 ltree_in(PG_FUNCTION_ARGS)
45 {
46 char *buf = (char *) PG_GETARG_POINTER(0);
47 char *ptr;
48 nodeitem *list,
49 *lptr;
50 int num = 0,
51 totallen = 0;
52 int state = LTPRS_WAITNAME;
53 ltree *result;
54 ltree_level *curlevel;
55 int charlen;
56 int pos = 0;
57
58 ptr = buf;
59 while (*ptr)
60 {
61 charlen = pg_mblen(ptr);
62 if (charlen == 1 && t_iseq(ptr, '.'))
63 num++;
64 ptr += charlen;
65 }
66
67 list = lptr = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
68 ptr = buf;
69 while (*ptr)
70 {
71 charlen = pg_mblen(ptr);
72
73 if (state == LTPRS_WAITNAME)
74 {
75 if (ISALNUM(ptr))
76 {
77 lptr->start = ptr;
78 lptr->wlen = 0;
79 state = LTPRS_WAITDELIM;
80 }
81 else
82 UNCHAR;
83 }
84 else if (state == LTPRS_WAITDELIM)
85 {
86 if (charlen == 1 && t_iseq(ptr, '.'))
87 {
88 lptr->len = ptr - lptr->start;
89 if (lptr->wlen > 255)
90 ereport(ERROR,
91 (errcode(ERRCODE_NAME_TOO_LONG),
92 errmsg("name of level is too long"),
93 errdetail("Name length is %d, must "
94 "be < 256, in position %d.",
95 lptr->wlen, pos)));
96
97 totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
98 lptr++;
99 state = LTPRS_WAITNAME;
100 }
101 else if (!ISALNUM(ptr))
102 UNCHAR;
103 }
104 else
105 /* internal error */
106 elog(ERROR, "internal error in parser");
107
108 ptr += charlen;
109 lptr->wlen++;
110 pos++;
111 }
112
113 if (state == LTPRS_WAITDELIM)
114 {
115 lptr->len = ptr - lptr->start;
116 if (lptr->wlen > 255)
117 ereport(ERROR,
118 (errcode(ERRCODE_NAME_TOO_LONG),
119 errmsg("name of level is too long"),
120 errdetail("Name length is %d, must "
121 "be < 256, in position %d.",
122 lptr->wlen, pos)));
123
124 totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
125 lptr++;
126 }
127 else if (!(state == LTPRS_WAITNAME && lptr == list))
128 ereport(ERROR,
129 (errcode(ERRCODE_SYNTAX_ERROR),
130 errmsg("syntax error"),
131 errdetail("Unexpected end of line.")));
132
133 result = (ltree *) palloc0(LTREE_HDRSIZE + totallen);
134 SET_VARSIZE(result, LTREE_HDRSIZE + totallen);
135 result->numlevel = lptr - list;
136 curlevel = LTREE_FIRST(result);
137 lptr = list;
138 while (lptr - list < result->numlevel)
139 {
140 curlevel->len = (uint16) lptr->len;
141 memcpy(curlevel->name, lptr->start, lptr->len);
142 curlevel = LEVEL_NEXT(curlevel);
143 lptr++;
144 }
145
146 pfree(list);
147 PG_RETURN_POINTER(result);
148 }
149
150 Datum
151 ltree_out(PG_FUNCTION_ARGS)
152 {
153 ltree *in = PG_GETARG_LTREE(0);
154 char *buf,
155 *ptr;
156 int i;
157 ltree_level *curlevel;
158
159 ptr = buf = (char *) palloc(VARSIZE(in));
160 curlevel = LTREE_FIRST(in);
161 for (i = 0; i < in->numlevel; i++)
162 {
163 if (i != 0)
164 {
165 *ptr = '.';
166 ptr++;
167 }
168 memcpy(ptr, curlevel->name, curlevel->len);
169 ptr += curlevel->len;
170 curlevel = LEVEL_NEXT(curlevel);
171 }
172
173 *ptr = '\0';
174 PG_FREE_IF_COPY(in, 0);
175
176 PG_RETURN_POINTER(buf);
177 }
178
179 #define LQPRS_WAITLEVEL 0
180 #define LQPRS_WAITDELIM 1
181 #define LQPRS_WAITOPEN 2
182 #define LQPRS_WAITFNUM 3
183 #define LQPRS_WAITSNUM 4
184 #define LQPRS_WAITND 5
185 #define LQPRS_WAITCLOSE 6
186 #define LQPRS_WAITEND 7
187 #define LQPRS_WAITVAR 8
188
189
190 #define GETVAR(x) ( *((nodeitem**)LQL_FIRST(x)) )
191 #define ITEMSIZE MAXALIGN(LQL_HDRSIZE+sizeof(nodeitem*))
192 #define NEXTLEV(x) ( (lquery_level*)( ((char*)(x)) + ITEMSIZE) )
193
194 Datum
195 lquery_in(PG_FUNCTION_ARGS)
196 {
197 char *buf = (char *) PG_GETARG_POINTER(0);
198 char *ptr;
199 int num = 0,
200 totallen = 0,
201 numOR = 0;
202 int state = LQPRS_WAITLEVEL;
203 lquery *result;
204 nodeitem *lptr = NULL;
205 lquery_level *cur,
206 *curqlevel,
207 *tmpql;
208 lquery_variant *lrptr = NULL;
209 bool hasnot = false;
210 bool wasbad = false;
211 int charlen;
212 int pos = 0;
213
214 ptr = buf;
215 while (*ptr)
216 {
217 charlen = pg_mblen(ptr);
218
219 if (charlen == 1)
220 {
221 if (t_iseq(ptr, '.'))
222 num++;
223 else if (t_iseq(ptr, '|'))
224 numOR++;
225 }
226
227 ptr += charlen;
228 }
229
230 num++;
231 curqlevel = tmpql = (lquery_level *) palloc0(ITEMSIZE * num);
232 ptr = buf;
233 while (*ptr)
234 {
235 charlen = pg_mblen(ptr);
236
237 if (state == LQPRS_WAITLEVEL)
238 {
239 if (ISALNUM(ptr))
240 {
241 GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
242 lptr->start = ptr;
243 state = LQPRS_WAITDELIM;
244 curqlevel->numvar = 1;
245 }
246 else if (charlen == 1 && t_iseq(ptr, '!'))
247 {
248 GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
249 lptr->start = ptr + 1;
250 state = LQPRS_WAITDELIM;
251 curqlevel->numvar = 1;
252 curqlevel->flag |= LQL_NOT;
253 hasnot = true;
254 }
255 else if (charlen == 1 && t_iseq(ptr, '*'))
256 state = LQPRS_WAITOPEN;
257 else
258 UNCHAR;
259 }
260 else if (state == LQPRS_WAITVAR)
261 {
262 if (ISALNUM(ptr))
263 {
264 lptr++;
265 lptr->start = ptr;
266 state = LQPRS_WAITDELIM;
267 curqlevel->numvar++;
268 }
269 else
270 UNCHAR;
271 }
272 else if (state == LQPRS_WAITDELIM)
273 {
274 if (charlen == 1 && t_iseq(ptr, '@'))
275 {
276 if (lptr->start == ptr)
277 UNCHAR;
278 lptr->flag |= LVAR_INCASE;
279 curqlevel->flag |= LVAR_INCASE;
280 }
281 else if (charlen == 1 && t_iseq(ptr, '*'))
282 {
283 if (lptr->start == ptr)
284 UNCHAR;
285 lptr->flag |= LVAR_ANYEND;
286 curqlevel->flag |= LVAR_ANYEND;
287 }
288 else if (charlen == 1 && t_iseq(ptr, '%'))
289 {
290 if (lptr->start == ptr)
291 UNCHAR;
292 lptr->flag |= LVAR_SUBLEXEME;
293 curqlevel->flag |= LVAR_SUBLEXEME;
294 }
295 else if (charlen == 1 && t_iseq(ptr, '|'))
296 {
297 lptr->len = ptr - lptr->start -
298 ((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
299 ((lptr->flag & LVAR_INCASE) ? 1 : 0) -
300 ((lptr->flag & LVAR_ANYEND) ? 1 : 0);
301 if (lptr->wlen > 255)
302 ereport(ERROR,
303 (errcode(ERRCODE_NAME_TOO_LONG),
304 errmsg("name of level is too long"),
305 errdetail("Name length is %d, must "
306 "be < 256, in position %d.",
307 lptr->wlen, pos)));
308
309 state = LQPRS_WAITVAR;
310 }
311 else if (charlen == 1 && t_iseq(ptr, '.'))
312 {
313 lptr->len = ptr - lptr->start -
314 ((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
315 ((lptr->flag & LVAR_INCASE) ? 1 : 0) -
316 ((lptr->flag & LVAR_ANYEND) ? 1 : 0);
317 if (lptr->wlen > 255)
318 ereport(ERROR,
319 (errcode(ERRCODE_NAME_TOO_LONG),
320 errmsg("name of level is too long"),
321 errdetail("Name length is %d, must "
322 "be < 256, in position %d.",
323 lptr->wlen, pos)));
324
325 state = LQPRS_WAITLEVEL;
326 curqlevel = NEXTLEV(curqlevel);
327 }
328 else if (ISALNUM(ptr))
329 {
330 if (lptr->flag)
331 UNCHAR;
332 }
333 else
334 UNCHAR;
335 }
336 else if (state == LQPRS_WAITOPEN)
337 {
338 if (charlen == 1 && t_iseq(ptr, '{'))
339 state = LQPRS_WAITFNUM;
340 else if (charlen == 1 && t_iseq(ptr, '.'))
341 {
342 curqlevel->low = 0;
343 curqlevel->high = 0xffff;
344 curqlevel = NEXTLEV(curqlevel);
345 state = LQPRS_WAITLEVEL;
346 }
347 else
348 UNCHAR;
349 }
350 else if (state == LQPRS_WAITFNUM)
351 {
352 if (charlen == 1 && t_iseq(ptr, ','))
353 state = LQPRS_WAITSNUM;
354 else if (t_isdigit(ptr))
355 {
356 curqlevel->low = atoi(ptr);
357 state = LQPRS_WAITND;
358 }
359 else
360 UNCHAR;
361 }
362 else if (state == LQPRS_WAITSNUM)
363 {
364 if (t_isdigit(ptr))
365 {
366 curqlevel->high = atoi(ptr);
367 state = LQPRS_WAITCLOSE;
368 }
369 else if (charlen == 1 && t_iseq(ptr, '}'))
370 {
371 curqlevel->high = 0xffff;
372 state = LQPRS_WAITEND;
373 }
374 else
375 UNCHAR;
376 }
377 else if (state == LQPRS_WAITCLOSE)
378 {
379 if (charlen == 1 && t_iseq(ptr, '}'))
380 state = LQPRS_WAITEND;
381 else if (!t_isdigit(ptr))
382 UNCHAR;
383 }
384 else if (state == LQPRS_WAITND)
385 {
386 if (charlen == 1 && t_iseq(ptr, '}'))
387 {
388 curqlevel->high = curqlevel->low;
389 state = LQPRS_WAITEND;
390 }
391 else if (charlen == 1 && t_iseq(ptr, ','))
392 state = LQPRS_WAITSNUM;
393 else if (!t_isdigit(ptr))
394 UNCHAR;
395 }
396 else if (state == LQPRS_WAITEND)
397 {
398 if (charlen == 1 && t_iseq(ptr, '.'))
399 {
400 state = LQPRS_WAITLEVEL;
401 curqlevel = NEXTLEV(curqlevel);
402 }
403 else
404 UNCHAR;
405 }
406 else
407 /* internal error */
408 elog(ERROR, "internal error in parser");
409
410 ptr += charlen;
411 if (state == LQPRS_WAITDELIM)
412 lptr->wlen++;
413 pos++;
414 }
415
416 if (state == LQPRS_WAITDELIM)
417 {
418 if (lptr->start == ptr)
419 ereport(ERROR,
420 (errcode(ERRCODE_SYNTAX_ERROR),
421 errmsg("syntax error"),
422 errdetail("Unexpected end of line.")));
423
424 lptr->len = ptr - lptr->start -
425 ((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
426 ((lptr->flag & LVAR_INCASE) ? 1 : 0) -
427 ((lptr->flag & LVAR_ANYEND) ? 1 : 0);
428 if (lptr->len == 0)
429 ereport(ERROR,
430 (errcode(ERRCODE_SYNTAX_ERROR),
431 errmsg("syntax error"),
432 errdetail("Unexpected end of line.")));
433
434 if (lptr->wlen > 255)
435 ereport(ERROR,
436 (errcode(ERRCODE_NAME_TOO_LONG),
437 errmsg("name of level is too long"),
438 errdetail("Name length is %d, must "
439 "be < 256, in position %d.",
440 lptr->wlen, pos)));
441 }
442 else if (state == LQPRS_WAITOPEN)
443 curqlevel->high = 0xffff;
444 else if (state != LQPRS_WAITEND)
445 ereport(ERROR,
446 (errcode(ERRCODE_SYNTAX_ERROR),
447 errmsg("syntax error"),
448 errdetail("Unexpected end of line.")));
449
450 curqlevel = tmpql;
451 totallen = LQUERY_HDRSIZE;
452 while ((char *) curqlevel - (char *) tmpql < num * ITEMSIZE)
453 {
454 totallen += LQL_HDRSIZE;
455 if (curqlevel->numvar)
456 {
457 lptr = GETVAR(curqlevel);
458 while (lptr - GETVAR(curqlevel) < curqlevel->numvar)
459 {
460 totallen += MAXALIGN(LVAR_HDRSIZE + lptr->len);
461 lptr++;
462 }
463 }
464 else if (curqlevel->low > curqlevel->high)
465 ereport(ERROR,
466 (errcode(ERRCODE_SYNTAX_ERROR),
467 errmsg("syntax error"),
468 errdetail("Low limit(%d) is greater than upper(%d).",
469 curqlevel->low, curqlevel->high)));
470
471 curqlevel = NEXTLEV(curqlevel);
472 }
473
474 result = (lquery *) palloc0(totallen);
475 SET_VARSIZE(result, totallen);
476 result->numlevel = num;
477 result->firstgood = 0;
478 result->flag = 0;
479 if (hasnot)
480 result->flag |= LQUERY_HASNOT;
481 cur = LQUERY_FIRST(result);
482 curqlevel = tmpql;
483 while ((char *) curqlevel - (char *) tmpql < num * ITEMSIZE)
484 {
485 memcpy(cur, curqlevel, LQL_HDRSIZE);
486 cur->totallen = LQL_HDRSIZE;
487 if (curqlevel->numvar)
488 {
489 lrptr = LQL_FIRST(cur);
490 lptr = GETVAR(curqlevel);
491 while (lptr - GETVAR(curqlevel) < curqlevel->numvar)
492 {
493 cur->totallen += MAXALIGN(LVAR_HDRSIZE + lptr->len);
494 lrptr->len = lptr->len;
495 lrptr->flag = lptr->flag;
496 lrptr->val = ltree_crc32_sz(lptr->start, lptr->len);
497 memcpy(lrptr->name, lptr->start, lptr->len);
498 lptr++;
499 lrptr = LVAR_NEXT(lrptr);
500 }
501 pfree(GETVAR(curqlevel));
502 if (cur->numvar > 1 || cur->flag != 0)
503 wasbad = true;
504 else if (wasbad == false)
505 (result->firstgood)++;
506 }
507 else
508 wasbad = true;
509 curqlevel = NEXTLEV(curqlevel);
510 cur = LQL_NEXT(cur);
511 }
512
513 pfree(tmpql);
514 PG_RETURN_POINTER(result);
515 }
516
517 Datum
518 lquery_out(PG_FUNCTION_ARGS)
519 {
520 lquery *in = PG_GETARG_LQUERY(0);
521 char *buf,
522 *ptr;
523 int i,
524 j,
525 totallen = 1;
526 lquery_level *curqlevel;
527 lquery_variant *curtlevel;
528
529 curqlevel = LQUERY_FIRST(in);
530 for (i = 0; i < in->numlevel; i++)
531 {
532 totallen++;
533 if (curqlevel->numvar)
534 totallen += 1 + (curqlevel->numvar * 4) + curqlevel->totallen;
535 else
536 totallen += 2 * 11 + 4;
537 curqlevel = LQL_NEXT(curqlevel);
538 }
539
540 ptr = buf = (char *) palloc(totallen);
541 curqlevel = LQUERY_FIRST(in);
542 for (i = 0; i < in->numlevel; i++)
543 {
544 if (i != 0)
545 {
546 *ptr = '.';
547 ptr++;
548 }
549 if (curqlevel->numvar)
550 {
551 if (curqlevel->flag & LQL_NOT)
552 {
553 *ptr = '!';
554 ptr++;
555 }
556 curtlevel = LQL_FIRST(curqlevel);
557 for (j = 0; j < curqlevel->numvar; j++)
558 {
559 if (j != 0)
560 {
561 *ptr = '|';
562 ptr++;
563 }
564 memcpy(ptr, curtlevel->name, curtlevel->len);
565 ptr += curtlevel->len;
566 if ((curtlevel->flag & LVAR_SUBLEXEME))
567 {
568 *ptr = '%';
569 ptr++;
570 }
571 if ((curtlevel->flag & LVAR_INCASE))
572 {
573 *ptr = '@';
574 ptr++;
575 }
576 if ((curtlevel->flag & LVAR_ANYEND))
577 {
578 *ptr = '*';
579 ptr++;
580 }
581 curtlevel = LVAR_NEXT(curtlevel);
582 }
583 }
584 else
585 {
586 if (curqlevel->low == curqlevel->high)
587 {
588 sprintf(ptr, "*{%d}", curqlevel->low);
589 }
590 else if (curqlevel->low == 0)
591 {
592 if (curqlevel->high == 0xffff)
593 {
594 *ptr = '*';
595 *(ptr + 1) = '\0';
596 }
597 else
598 sprintf(ptr, "*{,%d}", curqlevel->high);
599 }
600 else if (curqlevel->high == 0xffff)
601 {
602 sprintf(ptr, "*{%d,}", curqlevel->low);
603 }
604 else
605 sprintf(ptr, "*{%d,%d}", curqlevel->low, curqlevel->high);
606 ptr = strchr(ptr, '\0');
607 }
608
609 curqlevel = LQL_NEXT(curqlevel);
610 }
611
612 *ptr = '\0';
613 PG_FREE_IF_COPY(in, 0);
614
615 PG_RETURN_POINTER(buf);
616 }
PostgreSQL from CVS