Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * pg_dependencies.c
4 : * pg_dependencies data type support.
5 : *
6 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : * IDENTIFICATION
10 : * src/backend/utils/adt/pg_dependencies.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 :
15 : #include "postgres.h"
16 :
17 : #include "common/int.h"
18 : #include "common/jsonapi.h"
19 : #include "lib/stringinfo.h"
20 : #include "mb/pg_wchar.h"
21 : #include "nodes/miscnodes.h"
22 : #include "statistics/extended_stats_internal.h"
23 : #include "statistics/statistics_format.h"
24 : #include "utils/builtins.h"
25 : #include "utils/float.h"
26 : #include "utils/fmgrprotos.h"
27 :
28 : typedef enum
29 : {
30 : DEPS_EXPECT_START = 0,
31 : DEPS_EXPECT_ITEM,
32 : DEPS_EXPECT_KEY,
33 : DEPS_EXPECT_ATTNUM_LIST,
34 : DEPS_EXPECT_ATTNUM,
35 : DEPS_EXPECT_DEPENDENCY,
36 : DEPS_EXPECT_DEGREE,
37 : DEPS_PARSE_COMPLETE,
38 : } DependenciesSemanticState;
39 :
40 : typedef struct
41 : {
42 : const char *str;
43 : DependenciesSemanticState state;
44 :
45 : List *dependency_list;
46 : Node *escontext;
47 :
48 : bool found_attributes; /* Item has an attributes key */
49 : bool found_dependency; /* Item has an dependency key */
50 : bool found_degree; /* Item has degree key */
51 : List *attnum_list; /* Accumulated attribute numbers */
52 : AttrNumber dependency;
53 : double degree;
54 : } DependenciesParseState;
55 :
56 : /*
57 : * Invoked at the start of each MVDependency object.
58 : *
59 : * The entire JSON document should be one array of MVDependency objects.
60 : *
61 : * If we are anywhere else in the document, it's an error.
62 : */
63 : static JsonParseErrorType
64 501 : dependencies_object_start(void *state)
65 : {
66 501 : DependenciesParseState *parse = state;
67 :
68 501 : switch (parse->state)
69 : {
70 453 : case DEPS_EXPECT_ITEM:
71 : /* Now we expect to see attributes/dependency/degree keys */
72 453 : parse->state = DEPS_EXPECT_KEY;
73 453 : return JSON_SUCCESS;
74 :
75 16 : case DEPS_EXPECT_START:
76 : /* pg_dependencies must begin with a '[' */
77 16 : errsave(parse->escontext,
78 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
79 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
80 : errdetail("Initial element must be an array."));
81 8 : break;
82 :
83 0 : case DEPS_EXPECT_KEY:
84 : /* In an object, expecting key */
85 0 : errsave(parse->escontext,
86 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
87 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
88 : errdetail("A key was expected."));
89 0 : break;
90 :
91 8 : case DEPS_EXPECT_ATTNUM_LIST:
92 : /* Just followed an "attributes": key */
93 8 : errsave(parse->escontext,
94 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
95 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
96 : errdetail("Value of \"%s\" must be an array of attribute numbers.",
97 : PG_DEPENDENCIES_KEY_ATTRIBUTES));
98 4 : break;
99 :
100 8 : case DEPS_EXPECT_ATTNUM:
101 : /* In an attribute number list, expect only scalar integers */
102 8 : errsave(parse->escontext,
103 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
104 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
105 : errdetail("Attribute lists can only contain attribute numbers."));
106 4 : break;
107 :
108 8 : case DEPS_EXPECT_DEPENDENCY:
109 : /* Just followed a "dependency" key */
110 8 : errsave(parse->escontext,
111 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
112 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
113 : errdetail("Value of \"%s\" must be an integer.",
114 : PG_DEPENDENCIES_KEY_DEPENDENCY));
115 4 : break;
116 :
117 8 : case DEPS_EXPECT_DEGREE:
118 : /* Just followed a "degree" key */
119 8 : errsave(parse->escontext,
120 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
121 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
122 : errdetail("Value of \"%s\" must be an integer.",
123 : PG_DEPENDENCIES_KEY_DEGREE));
124 4 : break;
125 :
126 0 : default:
127 0 : elog(ERROR,
128 : "object start of \"%s\" found in unexpected parse state: %d.",
129 : "pg_dependencies", (int) parse->state);
130 : break;
131 : }
132 :
133 24 : return JSON_SEM_ACTION_FAILED;
134 : }
135 :
136 : /*
137 : * Invoked at the end of an object.
138 : *
139 : * Handle the end of an MVDependency object's JSON representation.
140 : */
141 : static JsonParseErrorType
142 201 : dependencies_object_end(void *state)
143 : {
144 201 : DependenciesParseState *parse = state;
145 :
146 : MVDependency *dep;
147 :
148 201 : int natts = 0;
149 :
150 201 : if (parse->state != DEPS_EXPECT_KEY)
151 0 : elog(ERROR,
152 : "object end of \"%s\" found in unexpected parse state: %d.",
153 : "pg_dependencies", (int) parse->state);
154 :
155 201 : if (!parse->found_attributes)
156 : {
157 8 : errsave(parse->escontext,
158 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
159 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
160 : errdetail("Item must contain \"%s\" key.",
161 : PG_DEPENDENCIES_KEY_ATTRIBUTES));
162 4 : return JSON_SEM_ACTION_FAILED;
163 : }
164 :
165 193 : if (!parse->found_dependency)
166 : {
167 8 : errsave(parse->escontext,
168 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
169 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
170 : errdetail("Item must contain \"%s\" key.",
171 : PG_DEPENDENCIES_KEY_DEPENDENCY));
172 4 : return JSON_SEM_ACTION_FAILED;
173 : }
174 :
175 185 : if (!parse->found_degree)
176 : {
177 16 : errsave(parse->escontext,
178 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
179 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
180 : errdetail("Item must contain \"%s\" key.",
181 : PG_DEPENDENCIES_KEY_DEGREE));
182 8 : return JSON_SEM_ACTION_FAILED;
183 : }
184 :
185 : /*
186 : * We need at least one attribute number in a dependencies item, anything
187 : * less is malformed.
188 : */
189 169 : natts = list_length(parse->attnum_list);
190 169 : if ((natts < 1) || (natts > (STATS_MAX_DIMENSIONS - 1)))
191 : {
192 8 : errsave(parse->escontext,
193 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
194 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
195 : errdetail("The \"%s\" key must contain an array of at least %d and no more than %d elements.",
196 : PG_DEPENDENCIES_KEY_ATTRIBUTES, 1,
197 : STATS_MAX_DIMENSIONS - 1));
198 4 : return JSON_SEM_ACTION_FAILED;
199 : }
200 :
201 : /*
202 : * Allocate enough space for the dependency, the attribute numbers in the
203 : * list and the final attribute number for the dependency.
204 : */
205 161 : dep = palloc0(offsetof(MVDependency, attributes) + ((natts + 1) * sizeof(AttrNumber)));
206 161 : dep->nattributes = natts + 1;
207 :
208 161 : dep->attributes[natts] = parse->dependency;
209 161 : dep->degree = parse->degree;
210 :
211 : /*
212 : * Assign attribute numbers to the attributes array, comparing each one
213 : * against the dependency attribute to ensure that there are no matches.
214 : */
215 436 : for (int i = 0; i < natts; i++)
216 : {
217 283 : dep->attributes[i] = (AttrNumber) list_nth_int(parse->attnum_list, i);
218 283 : if (dep->attributes[i] == parse->dependency)
219 : {
220 8 : errsave(parse->escontext,
221 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
222 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
223 : errdetail("Item \"%s\" with value %d has been found in the \"%s\" list.",
224 : PG_DEPENDENCIES_KEY_DEPENDENCY, parse->dependency,
225 : PG_DEPENDENCIES_KEY_ATTRIBUTES));
226 4 : return JSON_SEM_ACTION_FAILED;
227 : }
228 : }
229 :
230 153 : parse->dependency_list = lappend(parse->dependency_list, (void *) dep);
231 :
232 : /*
233 : * Reset dependency item state variables to look for the next
234 : * MVDependency.
235 : */
236 153 : list_free(parse->attnum_list);
237 153 : parse->attnum_list = NIL;
238 153 : parse->dependency = 0;
239 153 : parse->degree = 0.0;
240 153 : parse->found_attributes = false;
241 153 : parse->found_dependency = false;
242 153 : parse->found_degree = false;
243 153 : parse->state = DEPS_EXPECT_ITEM;
244 :
245 153 : return JSON_SUCCESS;
246 : }
247 :
248 : /*
249 : * Invoked at the start of an array.
250 : *
251 : * Dependency input format does not have arrays, so any array elements
252 : * encountered are an error.
253 : */
254 : static JsonParseErrorType
255 798 : dependencies_array_start(void *state)
256 : {
257 798 : DependenciesParseState *parse = state;
258 :
259 798 : switch (parse->state)
260 : {
261 397 : case DEPS_EXPECT_ATTNUM_LIST:
262 397 : parse->state = DEPS_EXPECT_ATTNUM;
263 397 : break;
264 377 : case DEPS_EXPECT_START:
265 377 : parse->state = DEPS_EXPECT_ITEM;
266 377 : break;
267 24 : default:
268 24 : errsave(parse->escontext,
269 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
270 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
271 : errdetail("Array has been found at an unexpected location."));
272 12 : return JSON_SEM_ACTION_FAILED;
273 : }
274 :
275 774 : return JSON_SUCCESS;
276 : }
277 :
278 : /*
279 : * Invoked at the end of an array.
280 : *
281 : * Either the end of an attribute number list or the whole object.
282 : */
283 : static JsonParseErrorType
284 410 : dependencies_array_end(void *state)
285 : {
286 410 : DependenciesParseState *parse = state;
287 :
288 410 : switch (parse->state)
289 : {
290 341 : case DEPS_EXPECT_ATTNUM:
291 341 : if (list_length(parse->attnum_list) > 0)
292 : {
293 333 : parse->state = DEPS_EXPECT_KEY;
294 333 : return JSON_SUCCESS;
295 : }
296 :
297 8 : errsave(parse->escontext,
298 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
299 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
300 : errdetail("The \"%s\" key must be a non-empty array.",
301 : PG_DEPENDENCIES_KEY_ATTRIBUTES));
302 4 : break;
303 :
304 69 : case DEPS_EXPECT_ITEM:
305 69 : if (list_length(parse->dependency_list) > 0)
306 : {
307 61 : parse->state = DEPS_PARSE_COMPLETE;
308 61 : return JSON_SUCCESS;
309 : }
310 :
311 8 : errsave(parse->escontext,
312 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
313 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
314 : errdetail("Item array cannot be empty."));
315 4 : break;
316 :
317 0 : default:
318 :
319 : /*
320 : * This can only happen if a case was missed in
321 : * dependencies_array_start().
322 : */
323 0 : elog(ERROR,
324 : "array end of \"%s\" found in unexpected parse state: %d.",
325 : "pg_dependencies", (int) parse->state);
326 : break;
327 : }
328 8 : return JSON_SEM_ACTION_FAILED;
329 : }
330 :
331 : /*
332 : * Invoked at the start of a key/value field.
333 : *
334 : * The valid keys for the MVDependency object are:
335 : * - attributes
336 : * - dependency
337 : * - degree
338 : */
339 : static JsonParseErrorType
340 987 : dependencies_object_field_start(void *state, char *fname, bool isnull)
341 : {
342 987 : DependenciesParseState *parse = state;
343 :
344 987 : if (strcmp(fname, PG_DEPENDENCIES_KEY_ATTRIBUTES) == 0)
345 : {
346 437 : if (parse->found_attributes)
347 : {
348 8 : errsave(parse->escontext,
349 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
350 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
351 : errdetail("Multiple \"%s\" keys are not allowed.",
352 : PG_DEPENDENCIES_KEY_ATTRIBUTES));
353 4 : return JSON_SEM_ACTION_FAILED;
354 : }
355 :
356 429 : parse->found_attributes = true;
357 429 : parse->state = DEPS_EXPECT_ATTNUM_LIST;
358 429 : return JSON_SUCCESS;
359 : }
360 :
361 550 : if (strcmp(fname, PG_DEPENDENCIES_KEY_DEPENDENCY) == 0)
362 : {
363 317 : if (parse->found_dependency)
364 : {
365 8 : errsave(parse->escontext,
366 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
367 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
368 : errdetail("Multiple \"%s\" keys are not allowed.",
369 : PG_DEPENDENCIES_KEY_DEPENDENCY));
370 4 : return JSON_SEM_ACTION_FAILED;
371 : }
372 :
373 309 : parse->found_dependency = true;
374 309 : parse->state = DEPS_EXPECT_DEPENDENCY;
375 309 : return JSON_SUCCESS;
376 : }
377 :
378 233 : if (strcmp(fname, PG_DEPENDENCIES_KEY_DEGREE) == 0)
379 : {
380 217 : if (parse->found_degree)
381 : {
382 8 : errsave(parse->escontext,
383 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
384 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
385 : errdetail("Multiple \"%s\" keys are not allowed.",
386 : PG_DEPENDENCIES_KEY_DEGREE));
387 4 : return JSON_SEM_ACTION_FAILED;
388 : }
389 :
390 209 : parse->found_degree = true;
391 209 : parse->state = DEPS_EXPECT_DEGREE;
392 209 : return JSON_SUCCESS;
393 : }
394 :
395 16 : errsave(parse->escontext,
396 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
397 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
398 : errdetail("Only allowed keys are \"%s\", \"%s\", and \"%s\".",
399 : PG_DEPENDENCIES_KEY_ATTRIBUTES,
400 : PG_DEPENDENCIES_KEY_DEPENDENCY,
401 : PG_DEPENDENCIES_KEY_DEGREE));
402 8 : return JSON_SEM_ACTION_FAILED;
403 : }
404 :
405 : /*
406 : * Invoked at the start of an array element.
407 : *
408 : * pg_dependencies input format does not have arrays, so any array elements
409 : * encountered are an error.
410 : */
411 : static JsonParseErrorType
412 1300 : dependencies_array_element_start(void *state, bool isnull)
413 : {
414 1300 : DependenciesParseState *parse = state;
415 :
416 1300 : switch (parse->state)
417 : {
418 839 : case DEPS_EXPECT_ATTNUM:
419 839 : if (!isnull)
420 831 : return JSON_SUCCESS;
421 :
422 8 : errsave(parse->escontext,
423 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
424 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
425 : errdetail("Attribute number array cannot be null."));
426 4 : break;
427 :
428 461 : case DEPS_EXPECT_ITEM:
429 461 : if (!isnull)
430 453 : return JSON_SUCCESS;
431 :
432 8 : errsave(parse->escontext,
433 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
434 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
435 : errdetail("Item list elements cannot be null."));
436 4 : break;
437 :
438 0 : default:
439 0 : elog(ERROR,
440 : "array element start of \"%s\" found in unexpected parse state: %d.",
441 : "pg_dependencies", (int) parse->state);
442 : break;
443 : }
444 :
445 8 : return JSON_SEM_ACTION_FAILED;
446 : }
447 :
448 : /*
449 : * Test for valid subsequent attribute number.
450 : *
451 : * If the previous value is positive, then current value must either be
452 : * greater than the previous value, or negative.
453 : *
454 : * If the previous value is negative, then the value must be less than
455 : * the previous value.
456 : *
457 : * Duplicate values are not allowed; that is already covered by the rules
458 : * described above.
459 : */
460 : static bool
461 426 : valid_subsequent_attnum(const AttrNumber prev, const AttrNumber cur)
462 : {
463 : Assert(prev != 0);
464 :
465 426 : if (prev > 0)
466 412 : return ((cur > prev) || (cur < 0));
467 :
468 14 : return (cur < prev);
469 : }
470 :
471 : /*
472 : * Handle scalar events from the dependencies input parser.
473 : *
474 : * There is only one case where we will encounter a scalar, and that is the
475 : * dependency degree for the previous object key.
476 : */
477 : static JsonParseErrorType
478 1333 : dependencies_scalar(void *state, char *token, JsonTokenType tokentype)
479 : {
480 1333 : DependenciesParseState *parse = state;
481 : AttrNumber attnum;
482 1333 : ErrorSaveContext escontext = {T_ErrorSaveContext};
483 :
484 1333 : switch (parse->state)
485 : {
486 823 : case DEPS_EXPECT_ATTNUM:
487 823 : attnum = pg_strtoint16_safe(token, (Node *) &escontext);
488 :
489 823 : if (escontext.error_occurred)
490 : {
491 8 : errsave(parse->escontext,
492 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
493 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
494 : errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_ATTRIBUTES));
495 4 : return JSON_SEM_ACTION_FAILED;
496 : }
497 :
498 : /*
499 : * An attribute number cannot be zero or a negative number beyond
500 : * the number of the possible expressions.
501 : */
502 815 : if (attnum == 0 || attnum < (0 - STATS_MAX_DIMENSIONS))
503 : {
504 16 : errsave(parse->escontext,
505 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
506 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
507 : errdetail("Invalid \"%s\" element has been found: %d.",
508 : PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum));
509 8 : return JSON_SEM_ACTION_FAILED;
510 : }
511 :
512 799 : if (parse->attnum_list != NIL)
513 : {
514 426 : const AttrNumber prev = llast_int(parse->attnum_list);
515 :
516 426 : if (!valid_subsequent_attnum(prev, attnum))
517 : {
518 8 : errsave(parse->escontext,
519 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
520 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
521 : errdetail("Invalid \"%s\" element has been found: %d cannot follow %d.",
522 : PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum, prev));
523 4 : return JSON_SEM_ACTION_FAILED;
524 : }
525 : }
526 :
527 791 : parse->attnum_list = lappend_int(parse->attnum_list, (int) attnum);
528 791 : return JSON_SUCCESS;
529 :
530 277 : case DEPS_EXPECT_DEPENDENCY:
531 277 : parse->dependency = (AttrNumber)
532 277 : pg_strtoint16_safe(token, (Node *) &escontext);
533 :
534 277 : if (escontext.error_occurred)
535 : {
536 16 : errsave(parse->escontext,
537 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
538 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
539 : errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_DEPENDENCY));
540 8 : return JSON_SEM_ACTION_FAILED;
541 : }
542 :
543 : /*
544 : * The dependency attribute number cannot be zero or a negative
545 : * number beyond the number of the possible expressions.
546 : */
547 261 : if (parse->dependency == 0 || parse->dependency < (0 - STATS_MAX_DIMENSIONS))
548 : {
549 16 : errsave(parse->escontext,
550 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
551 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
552 : errdetail("Key \"%s\" has an incorrect value: %d.",
553 : PG_DEPENDENCIES_KEY_DEPENDENCY, parse->dependency));
554 8 : return JSON_SEM_ACTION_FAILED;
555 : }
556 :
557 245 : parse->state = DEPS_EXPECT_KEY;
558 245 : return JSON_SUCCESS;
559 :
560 201 : case DEPS_EXPECT_DEGREE:
561 201 : parse->degree = float8in_internal(token, NULL, "double",
562 : token, (Node *) &escontext);
563 :
564 201 : if (escontext.error_occurred)
565 : {
566 8 : errsave(parse->escontext,
567 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
568 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
569 : errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_DEGREE));
570 4 : return JSON_SEM_ACTION_FAILED;
571 : }
572 :
573 193 : parse->state = DEPS_EXPECT_KEY;
574 193 : return JSON_SUCCESS;
575 :
576 32 : default:
577 32 : errsave(parse->escontext,
578 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
579 : errmsg("malformed pg_dependencies: \"%s\"", parse->str),
580 : errdetail("Unexpected scalar has been found."));
581 16 : break;
582 : }
583 :
584 16 : return JSON_SEM_ACTION_FAILED;
585 : }
586 :
587 : /*
588 : * Compare the attribute arrays of two MVDependency values,
589 : * looking for duplicated sets.
590 : */
591 : static bool
592 194 : dep_attributes_eq(const MVDependency *a, const MVDependency *b)
593 : {
594 : int i;
595 :
596 194 : if (a->nattributes != b->nattributes)
597 114 : return false;
598 :
599 126 : for (i = 0; i < a->nattributes; i++)
600 : {
601 118 : if (a->attributes[i] != b->attributes[i])
602 72 : return false;
603 : }
604 :
605 8 : return true;
606 : }
607 :
608 : /*
609 : * Generate a string representing an array of attribute numbers.
610 : * Internally, the dependency attribute is the last element, so we
611 : * leave that off.
612 : *
613 : * Freeing the allocated string is the responsibility of the caller.
614 : */
615 : static char *
616 8 : dep_attnum_list(const MVDependency *item)
617 : {
618 : StringInfoData str;
619 :
620 8 : initStringInfo(&str);
621 :
622 8 : appendStringInfo(&str, "%d", item->attributes[0]);
623 :
624 16 : for (int i = 1; i < item->nattributes - 1; i++)
625 8 : appendStringInfo(&str, ", %d", item->attributes[i]);
626 :
627 8 : return str.data;
628 : }
629 :
630 : /*
631 : * Return the dependency, which is the last attribute element.
632 : */
633 : static AttrNumber
634 8 : dep_attnum_dependency(const MVDependency *item)
635 : {
636 8 : return item->attributes[item->nattributes - 1];
637 : }
638 :
639 : /*
640 : * Attempt to build and serialize the MVDependencies object.
641 : *
642 : * This can only be executed after the completion of the JSON parsing.
643 : *
644 : * In the event of an error, set the error context and return NULL.
645 : */
646 : static bytea *
647 61 : build_mvdependencies(DependenciesParseState *parse, char *str)
648 : {
649 61 : int ndeps = list_length(parse->dependency_list);
650 :
651 : MVDependencies *mvdeps;
652 : bytea *bytes;
653 :
654 61 : switch (parse->state)
655 : {
656 61 : case DEPS_PARSE_COMPLETE:
657 :
658 : /*
659 : * Parse ended in the expected place. We should have a list of
660 : * items, but if we do not there is an issue with one of the
661 : * earlier parse steps.
662 : */
663 61 : if (ndeps == 0)
664 0 : elog(ERROR,
665 : "pg_dependencies parsing claims success with an empty item list.");
666 61 : break;
667 :
668 0 : case DEPS_EXPECT_START:
669 : /* blank */
670 0 : errsave(parse->escontext,
671 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
672 : errmsg("malformed pg_dependencies: \"%s\"", str),
673 : errdetail("Value cannot be empty."));
674 0 : return NULL;
675 :
676 0 : default:
677 : /* Unexpected end-state. */
678 0 : errsave(parse->escontext,
679 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
680 : errmsg("malformed pg_dependencies: \"%s\"", str),
681 : errdetail("Unexpected end state has been found: %d.", parse->state));
682 0 : return NULL;
683 : }
684 :
685 61 : mvdeps = palloc0(offsetof(MVDependencies, deps)
686 61 : + (ndeps * sizeof(MVDependency *)));
687 61 : mvdeps->magic = STATS_DEPS_MAGIC;
688 61 : mvdeps->type = STATS_DEPS_TYPE_BASIC;
689 61 : mvdeps->ndeps = ndeps;
690 :
691 206 : for (int i = 0; i < ndeps; i++)
692 : {
693 : /*
694 : * Use the MVDependency objects in the dependency_list.
695 : *
696 : * Because we free the dependency_list after parsing is done, we
697 : * cannot free it here.
698 : */
699 153 : mvdeps->deps[i] = list_nth(parse->dependency_list, i);
700 :
701 : /*
702 : * Ensure that this item does not duplicate the attributes of any
703 : * pre-existing item.
704 : */
705 339 : for (int j = 0; j < i; j++)
706 : {
707 194 : if (dep_attributes_eq(mvdeps->deps[i], mvdeps->deps[j]))
708 : {
709 8 : MVDependency *dep = mvdeps->deps[i];
710 8 : char *attnum_list = dep_attnum_list(dep);
711 8 : AttrNumber attnum_dep = dep_attnum_dependency(dep);
712 :
713 8 : errsave(parse->escontext,
714 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
715 : errmsg("malformed pg_dependencies: \"%s\"", str),
716 : errdetail("Duplicated \"%s\" array has been found: [%s] for key \"%s\" and value %d.",
717 : PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum_list,
718 : PG_DEPENDENCIES_KEY_DEPENDENCY, attnum_dep));
719 4 : pfree(mvdeps);
720 4 : return NULL;
721 : }
722 : }
723 : }
724 :
725 53 : bytes = statext_dependencies_serialize(mvdeps);
726 :
727 : /*
728 : * No need to free the individual MVDependency objects, because they are
729 : * still in the dependency_list, and will be freed with that.
730 : */
731 53 : pfree(mvdeps);
732 :
733 53 : return bytes;
734 : }
735 :
736 :
737 : /*
738 : * pg_dependencies_in - input routine for type pg_dependencies.
739 : *
740 : * This format is valid JSON, with the expected format:
741 : * [{"attributes": [1,2], "dependency": -1, "degree": 1.0000},
742 : * {"attributes": [1,-1], "dependency": 2, "degree": 0.0000},
743 : * {"attributes": [2,-1], "dependency": 1, "degree": 1.0000}]
744 : *
745 : */
746 : Datum
747 401 : pg_dependencies_in(PG_FUNCTION_ARGS)
748 : {
749 401 : char *str = PG_GETARG_CSTRING(0);
750 401 : bytea *bytes = NULL;
751 :
752 : DependenciesParseState parse_state;
753 : JsonParseErrorType result;
754 : JsonLexContext *lex;
755 : JsonSemAction sem_action;
756 :
757 : /* initialize the semantic state */
758 401 : parse_state.str = str;
759 401 : parse_state.state = DEPS_EXPECT_START;
760 401 : parse_state.dependency_list = NIL;
761 401 : parse_state.attnum_list = NIL;
762 401 : parse_state.dependency = 0;
763 401 : parse_state.degree = 0.0;
764 401 : parse_state.found_attributes = false;
765 401 : parse_state.found_dependency = false;
766 401 : parse_state.found_degree = false;
767 401 : parse_state.escontext = fcinfo->context;
768 :
769 : /* set callbacks */
770 401 : sem_action.semstate = (void *) &parse_state;
771 401 : sem_action.object_start = dependencies_object_start;
772 401 : sem_action.object_end = dependencies_object_end;
773 401 : sem_action.array_start = dependencies_array_start;
774 401 : sem_action.array_end = dependencies_array_end;
775 401 : sem_action.array_element_start = dependencies_array_element_start;
776 401 : sem_action.array_element_end = NULL;
777 401 : sem_action.object_field_start = dependencies_object_field_start;
778 401 : sem_action.object_field_end = NULL;
779 401 : sem_action.scalar = dependencies_scalar;
780 :
781 401 : lex = makeJsonLexContextCstringLen(NULL, str, strlen(str), PG_UTF8, true);
782 :
783 401 : result = pg_parse_json(lex, &sem_action);
784 253 : freeJsonLexContext(lex);
785 :
786 253 : if (result == JSON_SUCCESS)
787 61 : bytes = build_mvdependencies(&parse_state, str);
788 :
789 249 : list_free_deep(parse_state.dependency_list);
790 249 : list_free(parse_state.attnum_list);
791 :
792 249 : if (bytes)
793 53 : PG_RETURN_BYTEA_P(bytes);
794 :
795 : /*
796 : * If escontext already set, just use that. Anything else is a generic
797 : * JSON parse error.
798 : */
799 196 : if (!SOFT_ERROR_OCCURRED(parse_state.escontext))
800 44 : errsave(parse_state.escontext,
801 : errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
802 : errmsg("malformed pg_dependencies: \"%s\"", str),
803 : errdetail("Input data must be valid JSON."));
804 :
805 172 : PG_RETURN_NULL();
806 : }
807 :
808 :
809 : /*
810 : * pg_dependencies_out - output routine for type pg_dependencies.
811 : */
812 : Datum
813 83 : pg_dependencies_out(PG_FUNCTION_ARGS)
814 : {
815 83 : bytea *data = PG_GETARG_BYTEA_PP(0);
816 83 : MVDependencies *dependencies = statext_dependencies_deserialize(data);
817 : StringInfoData str;
818 :
819 83 : initStringInfo(&str);
820 83 : appendStringInfoChar(&str, '[');
821 :
822 266 : for (int i = 0; i < dependencies->ndeps; i++)
823 : {
824 183 : MVDependency *dependency = dependencies->deps[i];
825 :
826 183 : if (i > 0)
827 100 : appendStringInfoString(&str, ", ");
828 :
829 183 : if (dependency->nattributes <= 1)
830 0 : elog(ERROR, "invalid zero-length nattributes array in MVDependencies");
831 :
832 183 : appendStringInfo(&str, "{\"" PG_DEPENDENCIES_KEY_ATTRIBUTES "\": [%d",
833 183 : dependency->attributes[0]);
834 :
835 273 : for (int j = 1; j < dependency->nattributes - 1; j++)
836 90 : appendStringInfo(&str, ", %d", dependency->attributes[j]);
837 :
838 183 : appendStringInfo(&str, "], \"" PG_DEPENDENCIES_KEY_DEPENDENCY "\": %d, "
839 : "\"" PG_DEPENDENCIES_KEY_DEGREE "\": %f}",
840 183 : dependency->attributes[dependency->nattributes - 1],
841 : dependency->degree);
842 : }
843 :
844 83 : appendStringInfoChar(&str, ']');
845 :
846 83 : PG_RETURN_CSTRING(str.data);
847 : }
848 :
849 : /*
850 : * pg_dependencies_recv - binary input routine for type pg_dependencies.
851 : */
852 : Datum
853 0 : pg_dependencies_recv(PG_FUNCTION_ARGS)
854 : {
855 0 : ereport(ERROR,
856 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
857 : errmsg("cannot accept a value of type %s", "pg_dependencies")));
858 :
859 : PG_RETURN_VOID(); /* keep compiler quiet */
860 : }
861 :
862 : /*
863 : * pg_dependencies_send - binary output routine for type pg_dependencies.
864 : *
865 : * Functional dependencies are serialized in a bytea value (although the type
866 : * is named differently), so let's just send that.
867 : */
868 : Datum
869 0 : pg_dependencies_send(PG_FUNCTION_ARGS)
870 : {
871 0 : return byteasend(fcinfo);
872 : }
|
