Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * xml.c
4 : * XML data type support.
5 : *
6 : *
7 : * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
8 : * Portions Copyright (c) 1994, Regents of the University of California
9 : *
10 : * src/backend/utils/adt/xml.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 :
15 : /*
16 : * Generally, XML type support is only available when libxml use was
17 : * configured during the build. But even if that is not done, the
18 : * type and all the functions are available, but most of them will
19 : * fail. For one thing, this avoids having to manage variant catalog
20 : * installations. But it also has nice effects such as that you can
21 : * dump a database containing XML type data even if the server is not
22 : * linked with libxml. Thus, make sure xml_out() works even if nothing
23 : * else does.
24 : */
25 :
26 : /*
27 : * Notes on memory management:
28 : *
29 : * Sometimes libxml allocates global structures in the hope that it can reuse
30 : * them later on. This makes it impractical to change the xmlMemSetup
31 : * functions on-the-fly; that is likely to lead to trying to pfree() chunks
32 : * allocated with malloc() or vice versa. Since libxml might be used by
33 : * loadable modules, eg libperl, our only safe choices are to change the
34 : * functions at postmaster/backend launch or not at all. Since we'd rather
35 : * not activate libxml in sessions that might never use it, the latter choice
36 : * is the preferred one. However, for debugging purposes it can be awfully
37 : * handy to constrain libxml's allocations to be done in a specific palloc
38 : * context, where they're easy to track. Therefore there is code here that
39 : * can be enabled in debug builds to redirect libxml's allocations into a
40 : * special context LibxmlContext. It's not recommended to turn this on in
41 : * a production build because of the possibility of bad interactions with
42 : * external modules.
43 : */
44 : /* #define USE_LIBXMLCONTEXT */
45 :
46 : #include "postgres.h"
47 :
48 : #ifdef USE_LIBXML
49 : #include <libxml/chvalid.h>
50 : #include <libxml/parser.h>
51 : #include <libxml/parserInternals.h>
52 : #include <libxml/tree.h>
53 : #include <libxml/uri.h>
54 : #include <libxml/xmlerror.h>
55 : #include <libxml/xmlversion.h>
56 : #include <libxml/xmlwriter.h>
57 : #include <libxml/xpath.h>
58 : #include <libxml/xpathInternals.h>
59 :
60 : /*
61 : * We used to check for xmlStructuredErrorContext via a configure test; but
62 : * that doesn't work on Windows, so instead use this grottier method of
63 : * testing the library version number.
64 : */
65 : #if LIBXML_VERSION >= 20704
66 : #define HAVE_XMLSTRUCTUREDERRORCONTEXT 1
67 : #endif
68 : #endif /* USE_LIBXML */
69 :
70 : #include "access/htup_details.h"
71 : #include "access/table.h"
72 : #include "catalog/namespace.h"
73 : #include "catalog/pg_class.h"
74 : #include "catalog/pg_type.h"
75 : #include "commands/dbcommands.h"
76 : #include "executor/spi.h"
77 : #include "executor/tablefunc.h"
78 : #include "fmgr.h"
79 : #include "lib/stringinfo.h"
80 : #include "libpq/pqformat.h"
81 : #include "mb/pg_wchar.h"
82 : #include "miscadmin.h"
83 : #include "nodes/execnodes.h"
84 : #include "nodes/nodeFuncs.h"
85 : #include "utils/array.h"
86 : #include "utils/builtins.h"
87 : #include "utils/date.h"
88 : #include "utils/datetime.h"
89 : #include "utils/lsyscache.h"
90 : #include "utils/memutils.h"
91 : #include "utils/rel.h"
92 : #include "utils/syscache.h"
93 : #include "utils/xml.h"
94 :
95 :
96 : /* GUC variables */
97 : int xmlbinary;
98 : int xmloption;
99 :
100 : #ifdef USE_LIBXML
101 :
102 : /* random number to identify PgXmlErrorContext */
103 : #define ERRCXT_MAGIC 68275028
104 :
105 : struct PgXmlErrorContext
106 : {
107 : int magic;
108 : /* strictness argument passed to pg_xml_init */
109 : PgXmlStrictness strictness;
110 : /* current error status and accumulated message, if any */
111 : bool err_occurred;
112 : StringInfoData err_buf;
113 : /* previous libxml error handling state (saved by pg_xml_init) */
114 : xmlStructuredErrorFunc saved_errfunc;
115 : void *saved_errcxt;
116 : /* previous libxml entity handler (saved by pg_xml_init) */
117 : xmlExternalEntityLoader saved_entityfunc;
118 : };
119 :
120 : static xmlParserInputPtr xmlPgEntityLoader(const char *URL, const char *ID,
121 : xmlParserCtxtPtr ctxt);
122 : static void xml_errorHandler(void *data, xmlErrorPtr error);
123 : static void xml_ereport_by_code(int level, int sqlcode,
124 : const char *msg, int errcode);
125 : static void chopStringInfoNewlines(StringInfo str);
126 : static void appendStringInfoLineSeparator(StringInfo str);
127 :
128 : #ifdef USE_LIBXMLCONTEXT
129 :
130 : static MemoryContext LibxmlContext = NULL;
131 :
132 : static void xml_memory_init(void);
133 : static void *xml_palloc(size_t size);
134 : static void *xml_repalloc(void *ptr, size_t size);
135 : static void xml_pfree(void *ptr);
136 : static char *xml_pstrdup(const char *string);
137 : #endif /* USE_LIBXMLCONTEXT */
138 :
139 : static xmlChar *xml_text2xmlChar(text *in);
140 : static int parse_xml_decl(const xmlChar *str, size_t *lenp,
141 : xmlChar **version, xmlChar **encoding, int *standalone);
142 : static bool print_xml_decl(StringInfo buf, const xmlChar *version,
143 : pg_enc encoding, int standalone);
144 : static bool xml_doctype_in_content(const xmlChar *str);
145 : static xmlDocPtr xml_parse(text *data, XmlOptionType xmloption_arg,
146 : bool preserve_whitespace, int encoding);
147 : static text *xml_xmlnodetoxmltype(xmlNodePtr cur, PgXmlErrorContext *xmlerrcxt);
148 : static int xml_xpathobjtoxmlarray(xmlXPathObjectPtr xpathobj,
149 : ArrayBuildState *astate,
150 : PgXmlErrorContext *xmlerrcxt);
151 : static xmlChar *pg_xmlCharStrndup(const char *str, size_t len);
152 : #endif /* USE_LIBXML */
153 :
154 : static void xmldata_root_element_start(StringInfo result, const char *eltname,
155 : const char *xmlschema, const char *targetns,
156 : bool top_level);
157 : static void xmldata_root_element_end(StringInfo result, const char *eltname);
158 : static StringInfo query_to_xml_internal(const char *query, char *tablename,
159 : const char *xmlschema, bool nulls, bool tableforest,
160 : const char *targetns, bool top_level);
161 : static const char *map_sql_table_to_xmlschema(TupleDesc tupdesc, Oid relid,
162 : bool nulls, bool tableforest, const char *targetns);
163 : static const char *map_sql_schema_to_xmlschema_types(Oid nspid,
164 : List *relid_list, bool nulls,
165 : bool tableforest, const char *targetns);
166 : static const char *map_sql_catalog_to_xmlschema_types(List *nspid_list,
167 : bool nulls, bool tableforest,
168 : const char *targetns);
169 : static const char *map_sql_type_to_xml_name(Oid typeoid, int typmod);
170 : static const char *map_sql_typecoll_to_xmlschema_types(List *tupdesc_list);
171 : static const char *map_sql_type_to_xmlschema_type(Oid typeoid, int typmod);
172 : static void SPI_sql_row_to_xmlelement(uint64 rownum, StringInfo result,
173 : char *tablename, bool nulls, bool tableforest,
174 : const char *targetns, bool top_level);
175 :
176 : /* XMLTABLE support */
177 : #ifdef USE_LIBXML
178 : /* random number to identify XmlTableContext */
179 : #define XMLTABLE_CONTEXT_MAGIC 46922182
180 : typedef struct XmlTableBuilderData
181 : {
182 : int magic;
183 : int natts;
184 : long int row_count;
185 : PgXmlErrorContext *xmlerrcxt;
186 : xmlParserCtxtPtr ctxt;
187 : xmlDocPtr doc;
188 : xmlXPathContextPtr xpathcxt;
189 : xmlXPathCompExprPtr xpathcomp;
190 : xmlXPathObjectPtr xpathobj;
191 : xmlXPathCompExprPtr *xpathscomp;
192 : } XmlTableBuilderData;
193 : #endif
194 :
195 : static void XmlTableInitOpaque(struct TableFuncScanState *state, int natts);
196 : static void XmlTableSetDocument(struct TableFuncScanState *state, Datum value);
197 : static void XmlTableSetNamespace(struct TableFuncScanState *state, const char *name,
198 : const char *uri);
199 : static void XmlTableSetRowFilter(struct TableFuncScanState *state, const char *path);
200 : static void XmlTableSetColumnFilter(struct TableFuncScanState *state,
201 : const char *path, int colnum);
202 : static bool XmlTableFetchRow(struct TableFuncScanState *state);
203 : static Datum XmlTableGetValue(struct TableFuncScanState *state, int colnum,
204 : Oid typid, int32 typmod, bool *isnull);
205 : static void XmlTableDestroyOpaque(struct TableFuncScanState *state);
206 :
207 : const TableFuncRoutine XmlTableRoutine =
208 : {
209 : XmlTableInitOpaque,
210 : XmlTableSetDocument,
211 : XmlTableSetNamespace,
212 : XmlTableSetRowFilter,
213 : XmlTableSetColumnFilter,
214 : XmlTableFetchRow,
215 : XmlTableGetValue,
216 : XmlTableDestroyOpaque
217 : };
218 :
219 : #define NO_XML_SUPPORT() \
220 : ereport(ERROR, \
221 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), \
222 : errmsg("unsupported XML feature"), \
223 : errdetail("This functionality requires the server to be built with libxml support."), \
224 : errhint("You need to rebuild PostgreSQL using --with-libxml.")))
225 :
226 :
227 : /* from SQL/XML:2008 section 4.9 */
228 : #define NAMESPACE_XSD "http://www.w3.org/2001/XMLSchema"
229 : #define NAMESPACE_XSI "http://www.w3.org/2001/XMLSchema-instance"
230 : #define NAMESPACE_SQLXML "http://standards.iso.org/iso/9075/2003/sqlxml"
231 :
232 :
233 : #ifdef USE_LIBXML
234 :
235 : static int
236 0 : xmlChar_to_encoding(const xmlChar *encoding_name)
237 : {
238 0 : int encoding = pg_char_to_encoding((const char *) encoding_name);
239 :
240 0 : if (encoding < 0)
241 0 : ereport(ERROR,
242 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
243 : errmsg("invalid encoding name \"%s\"",
244 : (const char *) encoding_name)));
245 0 : return encoding;
246 : }
247 : #endif
248 :
249 :
250 : /*
251 : * xml_in uses a plain C string to VARDATA conversion, so for the time being
252 : * we use the conversion function for the text datatype.
253 : *
254 : * This is only acceptable so long as xmltype and text use the same
255 : * representation.
256 : */
257 : Datum
258 434 : xml_in(PG_FUNCTION_ARGS)
259 : {
260 : #ifdef USE_LIBXML
261 434 : char *s = PG_GETARG_CSTRING(0);
262 : xmltype *vardata;
263 : xmlDocPtr doc;
264 :
265 434 : vardata = (xmltype *) cstring_to_text(s);
266 :
267 : /*
268 : * Parse the data to check if it is well-formed XML data. Assume that
269 : * ERROR occurred if parsing failed.
270 : */
271 434 : doc = xml_parse(vardata, xmloption, true, GetDatabaseEncoding());
272 402 : xmlFreeDoc(doc);
273 :
274 402 : PG_RETURN_XML_P(vardata);
275 : #else
276 : NO_XML_SUPPORT();
277 : return 0;
278 : #endif
279 : }
280 :
281 :
282 : #define PG_XML_DEFAULT_VERSION "1.0"
283 :
284 :
285 : /*
286 : * xml_out_internal uses a plain VARDATA to C string conversion, so for the
287 : * time being we use the conversion function for the text datatype.
288 : *
289 : * This is only acceptable so long as xmltype and text use the same
290 : * representation.
291 : */
292 : static char *
293 13640 : xml_out_internal(xmltype *x, pg_enc target_encoding)
294 : {
295 13640 : char *str = text_to_cstring((text *) x);
296 :
297 : #ifdef USE_LIBXML
298 13640 : size_t len = strlen(str);
299 : xmlChar *version;
300 : int standalone;
301 : int res_code;
302 :
303 13640 : if ((res_code = parse_xml_decl((xmlChar *) str,
304 : &len, &version, NULL, &standalone)) == 0)
305 : {
306 : StringInfoData buf;
307 :
308 13640 : initStringInfo(&buf);
309 :
310 13640 : if (!print_xml_decl(&buf, version, target_encoding, standalone))
311 : {
312 : /*
313 : * If we are not going to produce an XML declaration, eat a single
314 : * newline in the original string to prevent empty first lines in
315 : * the output.
316 : */
317 13608 : if (*(str + len) == '\n')
318 4 : len += 1;
319 : }
320 13640 : appendStringInfoString(&buf, str + len);
321 :
322 13640 : pfree(str);
323 :
324 13640 : return buf.data;
325 : }
326 :
327 0 : xml_ereport_by_code(WARNING, ERRCODE_INTERNAL_ERROR,
328 : "could not parse XML declaration in stored value",
329 : res_code);
330 : #endif
331 0 : return str;
332 : }
333 :
334 :
335 : Datum
336 13468 : xml_out(PG_FUNCTION_ARGS)
337 : {
338 13468 : xmltype *x = PG_GETARG_XML_P(0);
339 :
340 : /*
341 : * xml_out removes the encoding property in all cases. This is because we
342 : * cannot control from here whether the datum will be converted to a
343 : * different client encoding, so we'd do more harm than good by including
344 : * it.
345 : */
346 13468 : PG_RETURN_CSTRING(xml_out_internal(x, 0));
347 : }
348 :
349 :
350 : Datum
351 0 : xml_recv(PG_FUNCTION_ARGS)
352 : {
353 : #ifdef USE_LIBXML
354 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
355 : xmltype *result;
356 : char *str;
357 : char *newstr;
358 : int nbytes;
359 : xmlDocPtr doc;
360 0 : xmlChar *encodingStr = NULL;
361 : int encoding;
362 :
363 : /*
364 : * Read the data in raw format. We don't know yet what the encoding is, as
365 : * that information is embedded in the xml declaration; so we have to
366 : * parse that before converting to server encoding.
367 : */
368 0 : nbytes = buf->len - buf->cursor;
369 0 : str = (char *) pq_getmsgbytes(buf, nbytes);
370 :
371 : /*
372 : * We need a null-terminated string to pass to parse_xml_decl(). Rather
373 : * than make a separate copy, make the temporary result one byte bigger
374 : * than it needs to be.
375 : */
376 0 : result = palloc(nbytes + 1 + VARHDRSZ);
377 0 : SET_VARSIZE(result, nbytes + VARHDRSZ);
378 0 : memcpy(VARDATA(result), str, nbytes);
379 0 : str = VARDATA(result);
380 0 : str[nbytes] = '\0';
381 :
382 0 : parse_xml_decl((const xmlChar *) str, NULL, NULL, &encodingStr, NULL);
383 :
384 : /*
385 : * If encoding wasn't explicitly specified in the XML header, treat it as
386 : * UTF-8, as that's the default in XML. This is different from xml_in(),
387 : * where the input has to go through the normal client to server encoding
388 : * conversion.
389 : */
390 0 : encoding = encodingStr ? xmlChar_to_encoding(encodingStr) : PG_UTF8;
391 :
392 : /*
393 : * Parse the data to check if it is well-formed XML data. Assume that
394 : * xml_parse will throw ERROR if not.
395 : */
396 0 : doc = xml_parse(result, xmloption, true, encoding);
397 0 : xmlFreeDoc(doc);
398 :
399 : /* Now that we know what we're dealing with, convert to server encoding */
400 0 : newstr = pg_any_to_server(str, nbytes, encoding);
401 :
402 0 : if (newstr != str)
403 : {
404 0 : pfree(result);
405 0 : result = (xmltype *) cstring_to_text(newstr);
406 0 : pfree(newstr);
407 : }
408 :
409 0 : PG_RETURN_XML_P(result);
410 : #else
411 : NO_XML_SUPPORT();
412 : return 0;
413 : #endif
414 : }
415 :
416 :
417 : Datum
418 0 : xml_send(PG_FUNCTION_ARGS)
419 : {
420 0 : xmltype *x = PG_GETARG_XML_P(0);
421 : char *outval;
422 : StringInfoData buf;
423 :
424 : /*
425 : * xml_out_internal doesn't convert the encoding, it just prints the right
426 : * declaration. pq_sendtext will do the conversion.
427 : */
428 0 : outval = xml_out_internal(x, pg_get_client_encoding());
429 :
430 0 : pq_begintypsend(&buf);
431 0 : pq_sendtext(&buf, outval, strlen(outval));
432 0 : pfree(outval);
433 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
434 : }
435 :
436 :
437 : #ifdef USE_LIBXML
438 : static void
439 108 : appendStringInfoText(StringInfo str, const text *t)
440 : {
441 108 : appendBinaryStringInfo(str, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
442 108 : }
443 : #endif
444 :
445 :
446 : static xmltype *
447 13004 : stringinfo_to_xmltype(StringInfo buf)
448 : {
449 13004 : return (xmltype *) cstring_to_text_with_len(buf->data, buf->len);
450 : }
451 :
452 :
453 : static xmltype *
454 52 : cstring_to_xmltype(const char *string)
455 : {
456 52 : return (xmltype *) cstring_to_text(string);
457 : }
458 :
459 :
460 : #ifdef USE_LIBXML
461 : static xmltype *
462 13040 : xmlBuffer_to_xmltype(xmlBufferPtr buf)
463 : {
464 13040 : return (xmltype *) cstring_to_text_with_len((const char *) xmlBufferContent(buf),
465 : xmlBufferLength(buf));
466 : }
467 : #endif
468 :
469 :
470 : Datum
471 28 : xmlcomment(PG_FUNCTION_ARGS)
472 : {
473 : #ifdef USE_LIBXML
474 28 : text *arg = PG_GETARG_TEXT_PP(0);
475 28 : char *argdata = VARDATA_ANY(arg);
476 28 : int len = VARSIZE_ANY_EXHDR(arg);
477 : StringInfoData buf;
478 : int i;
479 :
480 : /* check for "--" in string or "-" at the end */
481 120 : for (i = 1; i < len; i++)
482 : {
483 96 : if (argdata[i] == '-' && argdata[i - 1] == '-')
484 4 : ereport(ERROR,
485 : (errcode(ERRCODE_INVALID_XML_COMMENT),
486 : errmsg("invalid XML comment")));
487 : }
488 24 : if (len > 0 && argdata[len - 1] == '-')
489 4 : ereport(ERROR,
490 : (errcode(ERRCODE_INVALID_XML_COMMENT),
491 : errmsg("invalid XML comment")));
492 :
493 20 : initStringInfo(&buf);
494 20 : appendStringInfoString(&buf, "<!--");
495 20 : appendStringInfoText(&buf, arg);
496 20 : appendStringInfoString(&buf, "-->");
497 :
498 20 : PG_RETURN_XML_P(stringinfo_to_xmltype(&buf));
499 : #else
500 : NO_XML_SUPPORT();
501 : return 0;
502 : #endif
503 : }
504 :
505 :
506 :
507 : /*
508 : * TODO: xmlconcat needs to merge the notations and unparsed entities
509 : * of the argument values. Not very important in practice, though.
510 : */
511 : xmltype *
512 12836 : xmlconcat(List *args)
513 : {
514 : #ifdef USE_LIBXML
515 12836 : int global_standalone = 1;
516 12836 : xmlChar *global_version = NULL;
517 12836 : bool global_version_no_value = false;
518 : StringInfoData buf;
519 : ListCell *v;
520 :
521 12836 : initStringInfo(&buf);
522 38512 : foreach(v, args)
523 : {
524 25676 : xmltype *x = DatumGetXmlP(PointerGetDatum(lfirst(v)));
525 : size_t len;
526 : xmlChar *version;
527 : int standalone;
528 : char *str;
529 :
530 25676 : len = VARSIZE(x) - VARHDRSZ;
531 25676 : str = text_to_cstring((text *) x);
532 :
533 25676 : parse_xml_decl((xmlChar *) str, &len, &version, NULL, &standalone);
534 :
535 25676 : if (standalone == 0 && global_standalone == 1)
536 0 : global_standalone = 0;
537 25676 : if (standalone < 0)
538 25668 : global_standalone = -1;
539 :
540 25676 : if (!version)
541 25664 : global_version_no_value = true;
542 12 : else if (!global_version)
543 8 : global_version = version;
544 4 : else if (xmlStrcmp(version, global_version) != 0)
545 0 : global_version_no_value = true;
546 :
547 25676 : appendStringInfoString(&buf, str + len);
548 25676 : pfree(str);
549 : }
550 :
551 12836 : if (!global_version_no_value || global_standalone >= 0)
552 : {
553 : StringInfoData buf2;
554 :
555 4 : initStringInfo(&buf2);
556 :
557 4 : print_xml_decl(&buf2,
558 4 : (!global_version_no_value) ? global_version : NULL,
559 : 0,
560 : global_standalone);
561 :
562 4 : appendStringInfoString(&buf2, buf.data);
563 4 : buf = buf2;
564 : }
565 :
566 12836 : return stringinfo_to_xmltype(&buf);
567 : #else
568 : NO_XML_SUPPORT();
569 : return NULL;
570 : #endif
571 : }
572 :
573 :
574 : /*
575 : * XMLAGG support
576 : */
577 : Datum
578 12820 : xmlconcat2(PG_FUNCTION_ARGS)
579 : {
580 12820 : if (PG_ARGISNULL(0))
581 : {
582 12 : if (PG_ARGISNULL(1))
583 0 : PG_RETURN_NULL();
584 : else
585 12 : PG_RETURN_XML_P(PG_GETARG_XML_P(1));
586 : }
587 12808 : else if (PG_ARGISNULL(1))
588 0 : PG_RETURN_XML_P(PG_GETARG_XML_P(0));
589 : else
590 12808 : PG_RETURN_XML_P(xmlconcat(list_make2(PG_GETARG_XML_P(0),
591 : PG_GETARG_XML_P(1))));
592 : }
593 :
594 :
595 : Datum
596 4 : texttoxml(PG_FUNCTION_ARGS)
597 : {
598 4 : text *data = PG_GETARG_TEXT_PP(0);
599 :
600 4 : PG_RETURN_XML_P(xmlparse(data, xmloption, true));
601 : }
602 :
603 :
604 : Datum
605 0 : xmltotext(PG_FUNCTION_ARGS)
606 : {
607 0 : xmltype *data = PG_GETARG_XML_P(0);
608 :
609 : /* It's actually binary compatible. */
610 0 : PG_RETURN_TEXT_P((text *) data);
611 : }
612 :
613 :
614 : text *
615 16 : xmltotext_with_xmloption(xmltype *data, XmlOptionType xmloption_arg)
616 : {
617 16 : if (xmloption_arg == XMLOPTION_DOCUMENT && !xml_is_document(data))
618 4 : ereport(ERROR,
619 : (errcode(ERRCODE_NOT_AN_XML_DOCUMENT),
620 : errmsg("not an XML document")));
621 :
622 : /* It's actually binary compatible, save for the above check. */
623 12 : return (text *) data;
624 : }
625 :
626 :
627 : xmltype *
628 12924 : xmlelement(XmlExpr *xexpr,
629 : Datum *named_argvalue, bool *named_argnull,
630 : Datum *argvalue, bool *argnull)
631 : {
632 : #ifdef USE_LIBXML
633 : xmltype *result;
634 : List *named_arg_strings;
635 : List *arg_strings;
636 : int i;
637 : ListCell *arg;
638 : ListCell *narg;
639 : PgXmlErrorContext *xmlerrcxt;
640 12924 : volatile xmlBufferPtr buf = NULL;
641 12924 : volatile xmlTextWriterPtr writer = NULL;
642 :
643 : /*
644 : * All arguments are already evaluated, and their values are passed in the
645 : * named_argvalue/named_argnull or argvalue/argnull arrays. This avoids
646 : * issues if one of the arguments involves a call to some other function
647 : * or subsystem that wants to use libxml on its own terms. We examine the
648 : * original XmlExpr to identify the numbers and types of the arguments.
649 : */
650 12924 : named_arg_strings = NIL;
651 12924 : i = 0;
652 12956 : foreach(arg, xexpr->named_args)
653 : {
654 36 : Expr *e = (Expr *) lfirst(arg);
655 : char *str;
656 :
657 36 : if (named_argnull[i])
658 0 : str = NULL;
659 : else
660 36 : str = map_sql_value_to_xml_value(named_argvalue[i],
661 : exprType((Node *) e),
662 : false);
663 32 : named_arg_strings = lappend(named_arg_strings, str);
664 32 : i++;
665 : }
666 :
667 12920 : arg_strings = NIL;
668 12920 : i = 0;
669 25824 : foreach(arg, xexpr->args)
670 : {
671 12904 : Expr *e = (Expr *) lfirst(arg);
672 : char *str;
673 :
674 : /* here we can just forget NULL elements immediately */
675 12904 : if (!argnull[i])
676 : {
677 12904 : str = map_sql_value_to_xml_value(argvalue[i],
678 : exprType((Node *) e),
679 : true);
680 12904 : arg_strings = lappend(arg_strings, str);
681 : }
682 12904 : i++;
683 : }
684 :
685 12920 : xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
686 :
687 12920 : PG_TRY();
688 : {
689 12920 : buf = xmlBufferCreate();
690 12920 : if (buf == NULL || xmlerrcxt->err_occurred)
691 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
692 : "could not allocate xmlBuffer");
693 12920 : writer = xmlNewTextWriterMemory(buf, 0);
694 12920 : if (writer == NULL || xmlerrcxt->err_occurred)
695 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
696 : "could not allocate xmlTextWriter");
697 :
698 12920 : xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name);
699 :
700 12952 : forboth(arg, named_arg_strings, narg, xexpr->arg_names)
701 : {
702 32 : char *str = (char *) lfirst(arg);
703 32 : char *argname = strVal(lfirst(narg));
704 :
705 32 : if (str)
706 32 : xmlTextWriterWriteAttribute(writer,
707 : (xmlChar *) argname,
708 : (xmlChar *) str);
709 : }
710 :
711 25824 : foreach(arg, arg_strings)
712 : {
713 12904 : char *str = (char *) lfirst(arg);
714 :
715 12904 : xmlTextWriterWriteRaw(writer, (xmlChar *) str);
716 : }
717 :
718 12920 : xmlTextWriterEndElement(writer);
719 :
720 : /* we MUST do this now to flush data out to the buffer ... */
721 12920 : xmlFreeTextWriter(writer);
722 12920 : writer = NULL;
723 :
724 12920 : result = xmlBuffer_to_xmltype(buf);
725 : }
726 0 : PG_CATCH();
727 : {
728 0 : if (writer)
729 0 : xmlFreeTextWriter(writer);
730 0 : if (buf)
731 0 : xmlBufferFree(buf);
732 :
733 0 : pg_xml_done(xmlerrcxt, true);
734 :
735 0 : PG_RE_THROW();
736 : }
737 12920 : PG_END_TRY();
738 :
739 12920 : xmlBufferFree(buf);
740 :
741 12920 : pg_xml_done(xmlerrcxt, false);
742 :
743 12920 : return result;
744 : #else
745 : NO_XML_SUPPORT();
746 : return NULL;
747 : #endif
748 : }
749 :
750 :
751 : xmltype *
752 92 : xmlparse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace)
753 : {
754 : #ifdef USE_LIBXML
755 : xmlDocPtr doc;
756 :
757 92 : doc = xml_parse(data, xmloption_arg, preserve_whitespace,
758 : GetDatabaseEncoding());
759 60 : xmlFreeDoc(doc);
760 :
761 60 : return (xmltype *) data;
762 : #else
763 : NO_XML_SUPPORT();
764 : return NULL;
765 : #endif
766 : }
767 :
768 :
769 : xmltype *
770 48 : xmlpi(const char *target, text *arg, bool arg_is_null, bool *result_is_null)
771 : {
772 : #ifdef USE_LIBXML
773 : xmltype *result;
774 : StringInfoData buf;
775 :
776 48 : if (pg_strcasecmp(target, "xml") == 0)
777 8 : ereport(ERROR,
778 : (errcode(ERRCODE_SYNTAX_ERROR), /* really */
779 : errmsg("invalid XML processing instruction"),
780 : errdetail("XML processing instruction target name cannot be \"%s\".", target)));
781 :
782 : /*
783 : * Following the SQL standard, the null check comes after the syntax check
784 : * above.
785 : */
786 40 : *result_is_null = arg_is_null;
787 40 : if (*result_is_null)
788 8 : return NULL;
789 :
790 32 : initStringInfo(&buf);
791 :
792 32 : appendStringInfo(&buf, "<?%s", target);
793 :
794 32 : if (arg != NULL)
795 : {
796 : char *string;
797 :
798 16 : string = text_to_cstring(arg);
799 16 : if (strstr(string, "?>") != NULL)
800 4 : ereport(ERROR,
801 : (errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION),
802 : errmsg("invalid XML processing instruction"),
803 : errdetail("XML processing instruction cannot contain \"?>\".")));
804 :
805 12 : appendStringInfoChar(&buf, ' ');
806 12 : appendStringInfoString(&buf, string + strspn(string, " "));
807 12 : pfree(string);
808 : }
809 28 : appendStringInfoString(&buf, "?>");
810 :
811 28 : result = stringinfo_to_xmltype(&buf);
812 28 : pfree(buf.data);
813 28 : return result;
814 : #else
815 : NO_XML_SUPPORT();
816 : return NULL;
817 : #endif
818 : }
819 :
820 :
821 : xmltype *
822 40 : xmlroot(xmltype *data, text *version, int standalone)
823 : {
824 : #ifdef USE_LIBXML
825 : char *str;
826 : size_t len;
827 : xmlChar *orig_version;
828 : int orig_standalone;
829 : StringInfoData buf;
830 :
831 40 : len = VARSIZE(data) - VARHDRSZ;
832 40 : str = text_to_cstring((text *) data);
833 :
834 40 : parse_xml_decl((xmlChar *) str, &len, &orig_version, NULL, &orig_standalone);
835 :
836 40 : if (version)
837 16 : orig_version = xml_text2xmlChar(version);
838 : else
839 24 : orig_version = NULL;
840 :
841 40 : switch (standalone)
842 : {
843 : case XML_STANDALONE_YES:
844 12 : orig_standalone = 1;
845 12 : break;
846 : case XML_STANDALONE_NO:
847 8 : orig_standalone = 0;
848 8 : break;
849 : case XML_STANDALONE_NO_VALUE:
850 8 : orig_standalone = -1;
851 8 : break;
852 : case XML_STANDALONE_OMITTED:
853 : /* leave original value */
854 12 : break;
855 : }
856 :
857 40 : initStringInfo(&buf);
858 40 : print_xml_decl(&buf, orig_version, 0, orig_standalone);
859 40 : appendStringInfoString(&buf, str + len);
860 :
861 40 : return stringinfo_to_xmltype(&buf);
862 : #else
863 : NO_XML_SUPPORT();
864 : return NULL;
865 : #endif
866 : }
867 :
868 :
869 : /*
870 : * Validate document (given as string) against DTD (given as external link)
871 : *
872 : * This has been removed because it is a security hole: unprivileged users
873 : * should not be able to use Postgres to fetch arbitrary external files,
874 : * which unfortunately is exactly what libxml is willing to do with the DTD
875 : * parameter.
876 : */
877 : Datum
878 0 : xmlvalidate(PG_FUNCTION_ARGS)
879 : {
880 0 : ereport(ERROR,
881 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
882 : errmsg("xmlvalidate is not implemented")));
883 : return 0;
884 : }
885 :
886 :
887 : bool
888 20 : xml_is_document(xmltype *arg)
889 : {
890 : #ifdef USE_LIBXML
891 : bool result;
892 20 : volatile xmlDocPtr doc = NULL;
893 20 : MemoryContext ccxt = CurrentMemoryContext;
894 :
895 : /* We want to catch ereport(INVALID_XML_DOCUMENT) and return false */
896 20 : PG_TRY();
897 : {
898 20 : doc = xml_parse((text *) arg, XMLOPTION_DOCUMENT, true,
899 : GetDatabaseEncoding());
900 8 : result = true;
901 : }
902 12 : PG_CATCH();
903 : {
904 : ErrorData *errdata;
905 : MemoryContext ecxt;
906 :
907 12 : ecxt = MemoryContextSwitchTo(ccxt);
908 12 : errdata = CopyErrorData();
909 12 : if (errdata->sqlerrcode == ERRCODE_INVALID_XML_DOCUMENT)
910 : {
911 12 : FlushErrorState();
912 12 : result = false;
913 : }
914 : else
915 : {
916 0 : MemoryContextSwitchTo(ecxt);
917 0 : PG_RE_THROW();
918 : }
919 : }
920 20 : PG_END_TRY();
921 :
922 20 : if (doc)
923 8 : xmlFreeDoc(doc);
924 :
925 20 : return result;
926 : #else /* not USE_LIBXML */
927 : NO_XML_SUPPORT();
928 : return false;
929 : #endif /* not USE_LIBXML */
930 : }
931 :
932 :
933 : #ifdef USE_LIBXML
934 :
935 : /*
936 : * pg_xml_init_library --- set up for use of libxml
937 : *
938 : * This should be called by each function that is about to use libxml
939 : * facilities but doesn't require error handling. It initializes libxml
940 : * and verifies compatibility with the loaded libxml version. These are
941 : * once-per-session activities.
942 : *
943 : * TODO: xmlChar is utf8-char, make proper tuning (initdb with enc!=utf8 and
944 : * check)
945 : */
946 : void
947 54320 : pg_xml_init_library(void)
948 : {
949 : static bool first_time = true;
950 :
951 54320 : if (first_time)
952 : {
953 : /* Stuff we need do only once per session */
954 :
955 : /*
956 : * Currently, we have no pure UTF-8 support for internals -- check if
957 : * we can work.
958 : */
959 : if (sizeof(char) != sizeof(xmlChar))
960 : ereport(ERROR,
961 : (errmsg("could not initialize XML library"),
962 : errdetail("libxml2 has incompatible char type: sizeof(char)=%u, sizeof(xmlChar)=%u.",
963 : (int) sizeof(char), (int) sizeof(xmlChar))));
964 :
965 : #ifdef USE_LIBXMLCONTEXT
966 : /* Set up libxml's memory allocation our way */
967 : xml_memory_init();
968 : #endif
969 :
970 : /* Check library compatibility */
971 18 : LIBXML_TEST_VERSION;
972 :
973 18 : first_time = false;
974 : }
975 54320 : }
976 :
977 : /*
978 : * pg_xml_init --- set up for use of libxml and register an error handler
979 : *
980 : * This should be called by each function that is about to use libxml
981 : * facilities and requires error handling. It initializes libxml with
982 : * pg_xml_init_library() and establishes our libxml error handler.
983 : *
984 : * strictness determines which errors are reported and which are ignored.
985 : *
986 : * Calls to this function MUST be followed by a PG_TRY block that guarantees
987 : * that pg_xml_done() is called during either normal or error exit.
988 : *
989 : * This is exported for use by contrib/xml2, as well as other code that might
990 : * wish to share use of this module's libxml error handler.
991 : */
992 : PgXmlErrorContext *
993 14118 : pg_xml_init(PgXmlStrictness strictness)
994 : {
995 : PgXmlErrorContext *errcxt;
996 : void *new_errcxt;
997 :
998 : /* Do one-time setup if needed */
999 14118 : pg_xml_init_library();
1000 :
1001 : /* Create error handling context structure */
1002 14118 : errcxt = (PgXmlErrorContext *) palloc(sizeof(PgXmlErrorContext));
1003 14118 : errcxt->magic = ERRCXT_MAGIC;
1004 14118 : errcxt->strictness = strictness;
1005 14118 : errcxt->err_occurred = false;
1006 14118 : initStringInfo(&errcxt->err_buf);
1007 :
1008 : /*
1009 : * Save original error handler and install ours. libxml originally didn't
1010 : * distinguish between the contexts for generic and for structured error
1011 : * handlers. If we're using an old libxml version, we must thus save the
1012 : * generic error context, even though we're using a structured error
1013 : * handler.
1014 : */
1015 14118 : errcxt->saved_errfunc = xmlStructuredError;
1016 :
1017 : #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1018 14118 : errcxt->saved_errcxt = xmlStructuredErrorContext;
1019 : #else
1020 : errcxt->saved_errcxt = xmlGenericErrorContext;
1021 : #endif
1022 :
1023 14118 : xmlSetStructuredErrorFunc((void *) errcxt, xml_errorHandler);
1024 :
1025 : /*
1026 : * Verify that xmlSetStructuredErrorFunc set the context variable we
1027 : * expected it to. If not, the error context pointer we just saved is not
1028 : * the correct thing to restore, and since that leaves us without a way to
1029 : * restore the context in pg_xml_done, we must fail.
1030 : *
1031 : * The only known situation in which this test fails is if we compile with
1032 : * headers from a libxml2 that doesn't track the structured error context
1033 : * separately (< 2.7.4), but at runtime use a version that does, or vice
1034 : * versa. The libxml2 authors did not treat that change as constituting
1035 : * an ABI break, so the LIBXML_TEST_VERSION test in pg_xml_init_library
1036 : * fails to protect us from this.
1037 : */
1038 :
1039 : #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1040 14118 : new_errcxt = xmlStructuredErrorContext;
1041 : #else
1042 : new_errcxt = xmlGenericErrorContext;
1043 : #endif
1044 :
1045 14118 : if (new_errcxt != (void *) errcxt)
1046 0 : ereport(ERROR,
1047 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1048 : errmsg("could not set up XML error handler"),
1049 : errhint("This probably indicates that the version of libxml2"
1050 : " being used is not compatible with the libxml2"
1051 : " header files that PostgreSQL was built with.")));
1052 :
1053 : /*
1054 : * Also, install an entity loader to prevent unwanted fetches of external
1055 : * files and URLs.
1056 : */
1057 14118 : errcxt->saved_entityfunc = xmlGetExternalEntityLoader();
1058 14118 : xmlSetExternalEntityLoader(xmlPgEntityLoader);
1059 :
1060 14118 : return errcxt;
1061 : }
1062 :
1063 :
1064 : /*
1065 : * pg_xml_done --- restore previous libxml error handling
1066 : *
1067 : * Resets libxml's global error-handling state to what it was before
1068 : * pg_xml_init() was called.
1069 : *
1070 : * This routine verifies that all pending errors have been dealt with
1071 : * (in assert-enabled builds, anyway).
1072 : */
1073 : void
1074 14118 : pg_xml_done(PgXmlErrorContext *errcxt, bool isError)
1075 : {
1076 : void *cur_errcxt;
1077 :
1078 : /* An assert seems like enough protection here */
1079 : Assert(errcxt->magic == ERRCXT_MAGIC);
1080 :
1081 : /*
1082 : * In a normal exit, there should be no un-handled libxml errors. But we
1083 : * shouldn't try to enforce this during error recovery, since the longjmp
1084 : * could have been thrown before xml_ereport had a chance to run.
1085 : */
1086 : Assert(!errcxt->err_occurred || isError);
1087 :
1088 : /*
1089 : * Check that libxml's global state is correct, warn if not. This is a
1090 : * real test and not an Assert because it has a higher probability of
1091 : * happening.
1092 : */
1093 : #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1094 14118 : cur_errcxt = xmlStructuredErrorContext;
1095 : #else
1096 : cur_errcxt = xmlGenericErrorContext;
1097 : #endif
1098 :
1099 14118 : if (cur_errcxt != (void *) errcxt)
1100 0 : elog(WARNING, "libxml error handling state is out of sync with xml.c");
1101 :
1102 : /* Restore the saved handlers */
1103 14118 : xmlSetStructuredErrorFunc(errcxt->saved_errcxt, errcxt->saved_errfunc);
1104 14118 : xmlSetExternalEntityLoader(errcxt->saved_entityfunc);
1105 :
1106 : /*
1107 : * Mark the struct as invalid, just in case somebody somehow manages to
1108 : * call xml_errorHandler or xml_ereport with it.
1109 : */
1110 14118 : errcxt->magic = 0;
1111 :
1112 : /* Release memory */
1113 14118 : pfree(errcxt->err_buf.data);
1114 14118 : pfree(errcxt);
1115 14118 : }
1116 :
1117 :
1118 : /*
1119 : * pg_xml_error_occurred() --- test the error flag
1120 : */
1121 : bool
1122 0 : pg_xml_error_occurred(PgXmlErrorContext *errcxt)
1123 : {
1124 0 : return errcxt->err_occurred;
1125 : }
1126 :
1127 :
1128 : /*
1129 : * SQL/XML allows storing "XML documents" or "XML content". "XML
1130 : * documents" are specified by the XML specification and are parsed
1131 : * easily by libxml. "XML content" is specified by SQL/XML as the
1132 : * production "XMLDecl? content". But libxml can only parse the
1133 : * "content" part, so we have to parse the XML declaration ourselves
1134 : * to complete this.
1135 : */
1136 :
1137 : #define CHECK_XML_SPACE(p) \
1138 : do { \
1139 : if (!xmlIsBlank_ch(*(p))) \
1140 : return XML_ERR_SPACE_REQUIRED; \
1141 : } while (0)
1142 :
1143 : #define SKIP_XML_SPACE(p) \
1144 : while (xmlIsBlank_ch(*(p))) (p)++
1145 :
1146 : /* Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender */
1147 : /* Beware of multiple evaluations of argument! */
1148 : #define PG_XMLISNAMECHAR(c) \
1149 : (xmlIsBaseChar_ch(c) || xmlIsIdeographicQ(c) \
1150 : || xmlIsDigit_ch(c) \
1151 : || c == '.' || c == '-' || c == '_' || c == ':' \
1152 : || xmlIsCombiningQ(c) \
1153 : || xmlIsExtender_ch(c))
1154 :
1155 : /* pnstrdup, but deal with xmlChar not char; len is measured in xmlChars */
1156 : static xmlChar *
1157 108 : xml_pnstrdup(const xmlChar *str, size_t len)
1158 : {
1159 : xmlChar *result;
1160 :
1161 108 : result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar));
1162 108 : memcpy(result, str, len * sizeof(xmlChar));
1163 108 : result[len] = 0;
1164 108 : return result;
1165 : }
1166 :
1167 : /* Ditto, except input is char* */
1168 : static xmlChar *
1169 1604 : pg_xmlCharStrndup(const char *str, size_t len)
1170 : {
1171 : xmlChar *result;
1172 :
1173 1604 : result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar));
1174 1604 : memcpy(result, str, len);
1175 1604 : result[len] = '\0';
1176 :
1177 1604 : return result;
1178 : }
1179 :
1180 : /*
1181 : * Copy xmlChar string to PostgreSQL-owned memory, freeing the input.
1182 : *
1183 : * The input xmlChar is freed regardless of success of the copy.
1184 : */
1185 : static char *
1186 64752 : xml_pstrdup_and_free(xmlChar *str)
1187 : {
1188 : char *result;
1189 :
1190 64752 : if (str)
1191 : {
1192 64752 : PG_TRY();
1193 : {
1194 64752 : result = pstrdup((char *) str);
1195 : }
1196 0 : PG_CATCH();
1197 : {
1198 0 : xmlFree(str);
1199 0 : PG_RE_THROW();
1200 : }
1201 64752 : PG_END_TRY();
1202 64752 : xmlFree(str);
1203 : }
1204 : else
1205 0 : result = NULL;
1206 :
1207 64752 : return result;
1208 : }
1209 :
1210 : /*
1211 : * str is the null-terminated input string. Remaining arguments are
1212 : * output arguments; each can be NULL if value is not wanted.
1213 : * version and encoding are returned as locally-palloc'd strings.
1214 : * Result is 0 if OK, an error code if not.
1215 : */
1216 : static int
1217 40202 : parse_xml_decl(const xmlChar *str, size_t *lenp,
1218 : xmlChar **version, xmlChar **encoding, int *standalone)
1219 : {
1220 : const xmlChar *p;
1221 : const xmlChar *save_p;
1222 : size_t len;
1223 : int utf8char;
1224 : int utf8len;
1225 :
1226 : /*
1227 : * Only initialize libxml. We don't need error handling here, but we do
1228 : * need to make sure libxml is initialized before calling any of its
1229 : * functions. Note that this is safe (and a no-op) if caller has already
1230 : * done pg_xml_init().
1231 : */
1232 40202 : pg_xml_init_library();
1233 :
1234 : /* Initialize output arguments to "not present" */
1235 40202 : if (version)
1236 39834 : *version = NULL;
1237 40202 : if (encoding)
1238 0 : *encoding = NULL;
1239 40202 : if (standalone)
1240 39834 : *standalone = -1;
1241 :
1242 40202 : p = str;
1243 :
1244 40202 : if (xmlStrncmp(p, (xmlChar *) "<?xml", 5) != 0)
1245 40082 : goto finished;
1246 :
1247 : /*
1248 : * If next char is a name char, it's a PI like <?xml-stylesheet ...?>
1249 : * rather than an XMLDecl, so we have done what we came to do and found no
1250 : * XMLDecl.
1251 : *
1252 : * We need an input length value for xmlGetUTF8Char, but there's no need
1253 : * to count the whole document size, so use strnlen not strlen.
1254 : */
1255 120 : utf8len = strnlen((const char *) (p + 5), MAX_MULTIBYTE_CHAR_LEN);
1256 120 : utf8char = xmlGetUTF8Char(p + 5, &utf8len);
1257 120 : if (PG_XMLISNAMECHAR(utf8char))
1258 : goto finished;
1259 :
1260 112 : p += 5;
1261 :
1262 : /* version */
1263 112 : CHECK_XML_SPACE(p);
1264 112 : SKIP_XML_SPACE(p);
1265 112 : if (xmlStrncmp(p, (xmlChar *) "version", 7) != 0)
1266 0 : return XML_ERR_VERSION_MISSING;
1267 112 : p += 7;
1268 112 : SKIP_XML_SPACE(p);
1269 112 : if (*p != '=')
1270 0 : return XML_ERR_VERSION_MISSING;
1271 112 : p += 1;
1272 112 : SKIP_XML_SPACE(p);
1273 :
1274 112 : if (*p == '\'' || *p == '"')
1275 112 : {
1276 : const xmlChar *q;
1277 :
1278 112 : q = xmlStrchr(p + 1, *p);
1279 112 : if (!q)
1280 0 : return XML_ERR_VERSION_MISSING;
1281 :
1282 112 : if (version)
1283 108 : *version = xml_pnstrdup(p + 1, q - p - 1);
1284 112 : p = q + 1;
1285 : }
1286 : else
1287 0 : return XML_ERR_VERSION_MISSING;
1288 :
1289 : /* encoding */
1290 112 : save_p = p;
1291 112 : SKIP_XML_SPACE(p);
1292 112 : if (xmlStrncmp(p, (xmlChar *) "encoding", 8) == 0)
1293 : {
1294 16 : CHECK_XML_SPACE(save_p);
1295 16 : p += 8;
1296 16 : SKIP_XML_SPACE(p);
1297 16 : if (*p != '=')
1298 0 : return XML_ERR_MISSING_ENCODING;
1299 16 : p += 1;
1300 16 : SKIP_XML_SPACE(p);
1301 :
1302 16 : if (*p == '\'' || *p == '"')
1303 16 : {
1304 : const xmlChar *q;
1305 :
1306 16 : q = xmlStrchr(p + 1, *p);
1307 16 : if (!q)
1308 0 : return XML_ERR_MISSING_ENCODING;
1309 :
1310 16 : if (encoding)
1311 0 : *encoding = xml_pnstrdup(p + 1, q - p - 1);
1312 16 : p = q + 1;
1313 : }
1314 : else
1315 0 : return XML_ERR_MISSING_ENCODING;
1316 : }
1317 : else
1318 : {
1319 96 : p = save_p;
1320 : }
1321 :
1322 : /* standalone */
1323 112 : save_p = p;
1324 112 : SKIP_XML_SPACE(p);
1325 112 : if (xmlStrncmp(p, (xmlChar *) "standalone", 10) == 0)
1326 : {
1327 64 : CHECK_XML_SPACE(save_p);
1328 64 : p += 10;
1329 64 : SKIP_XML_SPACE(p);
1330 64 : if (*p != '=')
1331 0 : return XML_ERR_STANDALONE_VALUE;
1332 64 : p += 1;
1333 64 : SKIP_XML_SPACE(p);
1334 128 : if (xmlStrncmp(p, (xmlChar *) "'yes'", 5) == 0 ||
1335 64 : xmlStrncmp(p, (xmlChar *) "\"yes\"", 5) == 0)
1336 : {
1337 40 : if (standalone)
1338 40 : *standalone = 1;
1339 40 : p += 5;
1340 : }
1341 48 : else if (xmlStrncmp(p, (xmlChar *) "'no'", 4) == 0 ||
1342 24 : xmlStrncmp(p, (xmlChar *) "\"no\"", 4) == 0)
1343 : {
1344 24 : if (standalone)
1345 24 : *standalone = 0;
1346 24 : p += 4;
1347 : }
1348 : else
1349 0 : return XML_ERR_STANDALONE_VALUE;
1350 : }
1351 : else
1352 : {
1353 48 : p = save_p;
1354 : }
1355 :
1356 112 : SKIP_XML_SPACE(p);
1357 112 : if (xmlStrncmp(p, (xmlChar *) "?>", 2) != 0)
1358 0 : return XML_ERR_XMLDECL_NOT_FINISHED;
1359 112 : p += 2;
1360 :
1361 : finished:
1362 40202 : len = p - str;
1363 :
1364 43930 : for (p = str; p < str + len; p++)
1365 3728 : if (*p > 127)
1366 0 : return XML_ERR_INVALID_CHAR;
1367 :
1368 40202 : if (lenp)
1369 40202 : *lenp = len;
1370 :
1371 40202 : return XML_ERR_OK;
1372 : }
1373 :
1374 :
1375 : /*
1376 : * Write an XML declaration. On output, we adjust the XML declaration
1377 : * as follows. (These rules are the moral equivalent of the clause
1378 : * "Serialization of an XML value" in the SQL standard.)
1379 : *
1380 : * We try to avoid generating an XML declaration if possible. This is
1381 : * so that you don't get trivial things like xml '<foo/>' resulting in
1382 : * '<?xml version="1.0"?><foo/>', which would surely be annoying. We
1383 : * must provide a declaration if the standalone property is specified
1384 : * or if we include an encoding declaration. If we have a
1385 : * declaration, we must specify a version (XML requires this).
1386 : * Otherwise we only make a declaration if the version is not "1.0",
1387 : * which is the default version specified in SQL:2003.
1388 : */
1389 : static bool
1390 13684 : print_xml_decl(StringInfo buf, const xmlChar *version,
1391 : pg_enc encoding, int standalone)
1392 : {
1393 13684 : if ((version && strcmp((const char *) version, PG_XML_DEFAULT_VERSION) != 0)
1394 13660 : || (encoding && encoding != PG_UTF8)
1395 13660 : || standalone != -1)
1396 : {
1397 64 : appendStringInfoString(buf, "<?xml");
1398 :
1399 64 : if (version)
1400 48 : appendStringInfo(buf, " version=\"%s\"", version);
1401 : else
1402 16 : appendStringInfo(buf, " version=\"%s\"", PG_XML_DEFAULT_VERSION);
1403 :
1404 64 : if (encoding && encoding != PG_UTF8)
1405 : {
1406 : /*
1407 : * XXX might be useful to convert this to IANA names (ISO-8859-1
1408 : * instead of LATIN1 etc.); needs field experience
1409 : */
1410 0 : appendStringInfo(buf, " encoding=\"%s\"",
1411 : pg_encoding_to_char(encoding));
1412 : }
1413 :
1414 64 : if (standalone == 1)
1415 32 : appendStringInfoString(buf, " standalone=\"yes\"");
1416 32 : else if (standalone == 0)
1417 16 : appendStringInfoString(buf, " standalone=\"no\"");
1418 64 : appendStringInfoString(buf, "?>");
1419 :
1420 64 : return true;
1421 : }
1422 : else
1423 13620 : return false;
1424 : }
1425 :
1426 : /*
1427 : * Test whether an input that is to be parsed as CONTENT contains a DTD.
1428 : *
1429 : * The SQL/XML:2003 definition of CONTENT ("XMLDecl? content") is not
1430 : * satisfied by a document with a DTD, which is a bit of a wart, as it means
1431 : * the CONTENT type is not a proper superset of DOCUMENT. SQL/XML:2006 and
1432 : * later fix that, by redefining content with reference to the "more
1433 : * permissive" Document Node of the XQuery/XPath Data Model, such that any
1434 : * DOCUMENT value is indeed also a CONTENT value. That definition is more
1435 : * useful, as CONTENT becomes usable for parsing input of unknown form (think
1436 : * pg_restore).
1437 : *
1438 : * As used below in parse_xml when parsing for CONTENT, libxml does not give
1439 : * us the 2006+ behavior, but only the 2003; it will choke if the input has
1440 : * a DTD. But we can provide the 2006+ definition of CONTENT easily enough,
1441 : * by detecting this case first and simply doing the parse as DOCUMENT.
1442 : *
1443 : * A DTD can be found arbitrarily far in, but that would be a contrived case;
1444 : * it will ordinarily start within a few dozen characters. The only things
1445 : * that can precede it are an XMLDecl (here, the caller will have called
1446 : * parse_xml_decl already), whitespace, comments, and processing instructions.
1447 : * This function need only return true if it sees a valid sequence of such
1448 : * things leading to <!DOCTYPE. It can simply return false in any other
1449 : * cases, including malformed input; that will mean the input gets parsed as
1450 : * CONTENT as originally planned, with libxml reporting any errors.
1451 : *
1452 : * This is only to be called from xml_parse, when pg_xml_init has already
1453 : * been called. The input is already in UTF8 encoding.
1454 : */
1455 : static bool
1456 478 : xml_doctype_in_content(const xmlChar *str)
1457 : {
1458 478 : const xmlChar *p = str;
1459 :
1460 : for (;;)
1461 24 : {
1462 : const xmlChar *e;
1463 :
1464 502 : SKIP_XML_SPACE(p);
1465 502 : if (*p != '<')
1466 100 : return false;
1467 402 : p++;
1468 :
1469 402 : if (*p == '!')
1470 : {
1471 36 : p++;
1472 :
1473 : /* if we see <!DOCTYPE, we can return true */
1474 36 : if (xmlStrncmp(p, (xmlChar *) "DOCTYPE", 7) == 0)
1475 16 : return true;
1476 :
1477 : /* otherwise, if it's not a comment, fail */
1478 20 : if (xmlStrncmp(p, (xmlChar *) "--", 2) != 0)
1479 0 : return false;
1480 : /* find end of comment: find -- and a > must follow */
1481 20 : p = xmlStrstr(p + 2, (xmlChar *) "--");
1482 20 : if (!p || p[2] != '>')
1483 0 : return false;
1484 : /* advance over comment, and keep scanning */
1485 20 : p += 3;
1486 20 : continue;
1487 : }
1488 :
1489 : /* otherwise, if it's not a PI <?target something?>, fail */
1490 366 : if (*p != '?')
1491 362 : return false;
1492 4 : p++;
1493 :
1494 : /* find end of PI (the string ?> is forbidden within a PI) */
1495 4 : e = xmlStrstr(p, (xmlChar *) "?>");
1496 4 : if (!e)
1497 0 : return false;
1498 :
1499 : /* advance over PI, keep scanning */
1500 4 : p = e + 2;
1501 : }
1502 : }
1503 :
1504 :
1505 : /*
1506 : * Convert a C string to XML internal representation
1507 : *
1508 : * Note: it is caller's responsibility to xmlFreeDoc() the result,
1509 : * else a permanent memory leak will ensue!
1510 : *
1511 : * TODO maybe libxml2's xmlreader is better? (do not construct DOM,
1512 : * yet do not use SAX - see xmlreader.c)
1513 : */
1514 : static xmlDocPtr
1515 622 : xml_parse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace,
1516 : int encoding)
1517 : {
1518 : int32 len;
1519 : xmlChar *string;
1520 : xmlChar *utf8string;
1521 : PgXmlErrorContext *xmlerrcxt;
1522 622 : volatile xmlParserCtxtPtr ctxt = NULL;
1523 622 : volatile xmlDocPtr doc = NULL;
1524 :
1525 622 : len = VARSIZE_ANY_EXHDR(data); /* will be useful later */
1526 622 : string = xml_text2xmlChar(data);
1527 :
1528 622 : utf8string = pg_do_encoding_conversion(string,
1529 : len,
1530 : encoding,
1531 : PG_UTF8);
1532 :
1533 : /* Start up libxml and its parser */
1534 622 : xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_WELLFORMED);
1535 :
1536 : /* Use a TRY block to ensure we clean up correctly */
1537 622 : PG_TRY();
1538 : {
1539 622 : bool parse_as_document = false;
1540 : int res_code;
1541 622 : size_t count = 0;
1542 622 : xmlChar *version = NULL;
1543 622 : int standalone = 0;
1544 :
1545 622 : xmlInitParser();
1546 :
1547 622 : ctxt = xmlNewParserCtxt();
1548 622 : if (ctxt == NULL || xmlerrcxt->err_occurred)
1549 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
1550 : "could not allocate parser context");
1551 :
1552 : /* Decide whether to parse as document or content */
1553 622 : if (xmloption_arg == XMLOPTION_DOCUMENT)
1554 144 : parse_as_document = true;
1555 : else
1556 : {
1557 : /* Parse and skip over the XML declaration, if any */
1558 478 : res_code = parse_xml_decl(utf8string,
1559 : &count, &version, NULL, &standalone);
1560 478 : if (res_code != 0)
1561 0 : xml_ereport_by_code(ERROR, ERRCODE_INVALID_XML_CONTENT,
1562 : "invalid XML content: invalid XML declaration",
1563 : res_code);
1564 :
1565 : /* Is there a DOCTYPE element? */
1566 478 : if (xml_doctype_in_content(utf8string + count))
1567 16 : parse_as_document = true;
1568 : }
1569 :
1570 622 : if (parse_as_document)
1571 : {
1572 : /*
1573 : * Note, that here we try to apply DTD defaults
1574 : * (XML_PARSE_DTDATTR) according to SQL/XML:2008 GR 10.16.7.d:
1575 : * 'Default values defined by internal DTD are applied'. As for
1576 : * external DTDs, we try to support them too, (see SQL/XML:2008 GR
1577 : * 10.16.7.e)
1578 : */
1579 160 : doc = xmlCtxtReadDoc(ctxt, utf8string,
1580 : NULL,
1581 : "UTF-8",
1582 : XML_PARSE_NOENT | XML_PARSE_DTDATTR
1583 : | (preserve_whitespace ? 0 : XML_PARSE_NOBLANKS));
1584 160 : if (doc == NULL || xmlerrcxt->err_occurred)
1585 : {
1586 : /* Use original option to decide which error code to throw */
1587 80 : if (xmloption_arg == XMLOPTION_DOCUMENT)
1588 76 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INVALID_XML_DOCUMENT,
1589 : "invalid XML document");
1590 : else
1591 4 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INVALID_XML_CONTENT,
1592 : "invalid XML content");
1593 : }
1594 : }
1595 : else
1596 : {
1597 462 : doc = xmlNewDoc(version);
1598 : Assert(doc->encoding == NULL);
1599 462 : doc->encoding = xmlStrdup((const xmlChar *) "UTF-8");
1600 462 : doc->standalone = standalone;
1601 :
1602 : /* allow empty content */
1603 462 : if (*(utf8string + count))
1604 : {
1605 916 : res_code = xmlParseBalancedChunkMemory(doc, NULL, NULL, 0,
1606 458 : utf8string + count, NULL);
1607 458 : if (res_code != 0 || xmlerrcxt->err_occurred)
1608 32 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INVALID_XML_CONTENT,
1609 : "invalid XML content");
1610 : }
1611 : }
1612 : }
1613 112 : PG_CATCH();
1614 : {
1615 112 : if (doc != NULL)
1616 32 : xmlFreeDoc(doc);
1617 112 : if (ctxt != NULL)
1618 112 : xmlFreeParserCtxt(ctxt);
1619 :
1620 112 : pg_xml_done(xmlerrcxt, true);
1621 :
1622 112 : PG_RE_THROW();
1623 : }
1624 510 : PG_END_TRY();
1625 :
1626 510 : xmlFreeParserCtxt(ctxt);
1627 :
1628 510 : pg_xml_done(xmlerrcxt, false);
1629 :
1630 510 : return doc;
1631 : }
1632 :
1633 :
1634 : /*
1635 : * xmlChar<->text conversions
1636 : */
1637 : static xmlChar *
1638 638 : xml_text2xmlChar(text *in)
1639 : {
1640 638 : return (xmlChar *) text_to_cstring(in);
1641 : }
1642 :
1643 :
1644 : #ifdef USE_LIBXMLCONTEXT
1645 :
1646 : /*
1647 : * Manage the special context used for all libxml allocations (but only
1648 : * in special debug builds; see notes at top of file)
1649 : */
1650 : static void
1651 : xml_memory_init(void)
1652 : {
1653 : /* Create memory context if not there already */
1654 : if (LibxmlContext == NULL)
1655 : LibxmlContext = AllocSetContextCreate(TopMemoryContext,
1656 : "Libxml context",
1657 : ALLOCSET_DEFAULT_SIZES);
1658 :
1659 : /* Re-establish the callbacks even if already set */
1660 : xmlMemSetup(xml_pfree, xml_palloc, xml_repalloc, xml_pstrdup);
1661 : }
1662 :
1663 : /*
1664 : * Wrappers for memory management functions
1665 : */
1666 : static void *
1667 : xml_palloc(size_t size)
1668 : {
1669 : return MemoryContextAlloc(LibxmlContext, size);
1670 : }
1671 :
1672 :
1673 : static void *
1674 : xml_repalloc(void *ptr, size_t size)
1675 : {
1676 : return repalloc(ptr, size);
1677 : }
1678 :
1679 :
1680 : static void
1681 : xml_pfree(void *ptr)
1682 : {
1683 : /* At least some parts of libxml assume xmlFree(NULL) is allowed */
1684 : if (ptr)
1685 : pfree(ptr);
1686 : }
1687 :
1688 :
1689 : static char *
1690 : xml_pstrdup(const char *string)
1691 : {
1692 : return MemoryContextStrdup(LibxmlContext, string);
1693 : }
1694 : #endif /* USE_LIBXMLCONTEXT */
1695 :
1696 :
1697 : /*
1698 : * xmlPgEntityLoader --- entity loader callback function
1699 : *
1700 : * Silently prevent any external entity URL from being loaded. We don't want
1701 : * to throw an error, so instead make the entity appear to expand to an empty
1702 : * string.
1703 : *
1704 : * We would prefer to allow loading entities that exist in the system's
1705 : * global XML catalog; but the available libxml2 APIs make that a complex
1706 : * and fragile task. For now, just shut down all external access.
1707 : */
1708 : static xmlParserInputPtr
1709 28 : xmlPgEntityLoader(const char *URL, const char *ID,
1710 : xmlParserCtxtPtr ctxt)
1711 : {
1712 28 : return xmlNewStringInputStream(ctxt, (const xmlChar *) "");
1713 : }
1714 :
1715 :
1716 : /*
1717 : * xml_ereport --- report an XML-related error
1718 : *
1719 : * The "msg" is the SQL-level message; some can be adopted from the SQL/XML
1720 : * standard. This function adds libxml's native error message, if any, as
1721 : * detail.
1722 : *
1723 : * This is exported for modules that want to share the core libxml error
1724 : * handler. Note that pg_xml_init() *must* have been called previously.
1725 : */
1726 : void
1727 120 : xml_ereport(PgXmlErrorContext *errcxt, int level, int sqlcode, const char *msg)
1728 : {
1729 : char *detail;
1730 :
1731 : /* Defend against someone passing us a bogus context struct */
1732 120 : if (errcxt->magic != ERRCXT_MAGIC)
1733 0 : elog(ERROR, "xml_ereport called with invalid PgXmlErrorContext");
1734 :
1735 : /* Flag that the current libxml error has been reported */
1736 120 : errcxt->err_occurred = false;
1737 :
1738 : /* Include detail only if we have some text from libxml */
1739 120 : if (errcxt->err_buf.len > 0)
1740 120 : detail = errcxt->err_buf.data;
1741 : else
1742 0 : detail = NULL;
1743 :
1744 120 : ereport(level,
1745 : (errcode(sqlcode),
1746 : errmsg_internal("%s", msg),
1747 : detail ? errdetail_internal("%s", detail) : 0));
1748 0 : }
1749 :
1750 :
1751 : /*
1752 : * Error handler for libxml errors and warnings
1753 : */
1754 : static void
1755 222 : xml_errorHandler(void *data, xmlErrorPtr error)
1756 : {
1757 222 : PgXmlErrorContext *xmlerrcxt = (PgXmlErrorContext *) data;
1758 222 : xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) error->ctxt;
1759 222 : xmlParserInputPtr input = (ctxt != NULL) ? ctxt->input : NULL;
1760 222 : xmlNodePtr node = error->node;
1761 222 : const xmlChar *name = (node != NULL &&
1762 222 : node->type == XML_ELEMENT_NODE) ? node->name : NULL;
1763 222 : int domain = error->domain;
1764 222 : int level = error->level;
1765 : StringInfo errorBuf;
1766 :
1767 : /*
1768 : * Defend against someone passing us a bogus context struct.
1769 : *
1770 : * We force a backend exit if this check fails because longjmp'ing out of
1771 : * libxml would likely render it unsafe to use further.
1772 : */
1773 222 : if (xmlerrcxt->magic != ERRCXT_MAGIC)
1774 0 : elog(FATAL, "xml_errorHandler called with invalid PgXmlErrorContext");
1775 :
1776 : /*----------
1777 : * Older libxml versions report some errors differently.
1778 : * First, some errors were previously reported as coming from the parser
1779 : * domain but are now reported as coming from the namespace domain.
1780 : * Second, some warnings were upgraded to errors.
1781 : * We attempt to compensate for that here.
1782 : *----------
1783 : */
1784 222 : switch (error->code)
1785 : {
1786 : case XML_WAR_NS_URI:
1787 20 : level = XML_ERR_ERROR;
1788 20 : domain = XML_FROM_NAMESPACE;
1789 20 : break;
1790 :
1791 : case XML_ERR_NS_DECL_ERROR:
1792 : case XML_WAR_NS_URI_RELATIVE:
1793 : case XML_WAR_NS_COLUMN:
1794 : case XML_NS_ERR_XML_NAMESPACE:
1795 : case XML_NS_ERR_UNDEFINED_NAMESPACE:
1796 : case XML_NS_ERR_QNAME:
1797 : case XML_NS_ERR_ATTRIBUTE_REDEFINED:
1798 : case XML_NS_ERR_EMPTY:
1799 36 : domain = XML_FROM_NAMESPACE;
1800 36 : break;
1801 : }
1802 :
1803 : /* Decide whether to act on the error or not */
1804 222 : switch (domain)
1805 : {
1806 : case XML_FROM_PARSER:
1807 : case XML_FROM_NONE:
1808 : case XML_FROM_MEMORY:
1809 : case XML_FROM_IO:
1810 :
1811 : /*
1812 : * Suppress warnings about undeclared entities. We need to do
1813 : * this to avoid problems due to not loading DTD definitions.
1814 : */
1815 166 : if (error->code == XML_WAR_UNDECLARED_ENTITY)
1816 4 : return;
1817 :
1818 : /* Otherwise, accept error regardless of the parsing purpose */
1819 162 : break;
1820 :
1821 : default:
1822 : /* Ignore error if only doing well-formedness check */
1823 56 : if (xmlerrcxt->strictness == PG_XML_STRICTNESS_WELLFORMED)
1824 44 : return;
1825 12 : break;
1826 : }
1827 :
1828 : /* Prepare error message in errorBuf */
1829 174 : errorBuf = makeStringInfo();
1830 :
1831 174 : if (error->line > 0)
1832 174 : appendStringInfo(errorBuf, "line %d: ", error->line);
1833 174 : if (name != NULL)
1834 0 : appendStringInfo(errorBuf, "element %s: ", name);
1835 174 : if (error->message != NULL)
1836 174 : appendStringInfoString(errorBuf, error->message);
1837 : else
1838 0 : appendStringInfoString(errorBuf, "(no message provided)");
1839 :
1840 : /*
1841 : * Append context information to errorBuf.
1842 : *
1843 : * xmlParserPrintFileContext() uses libxml's "generic" error handler to
1844 : * write the context. Since we don't want to duplicate libxml
1845 : * functionality here, we set up a generic error handler temporarily.
1846 : *
1847 : * We use appendStringInfo() directly as libxml's generic error handler.
1848 : * This should work because it has essentially the same signature as
1849 : * libxml expects, namely (void *ptr, const char *msg, ...).
1850 : */
1851 174 : if (input != NULL)
1852 : {
1853 174 : xmlGenericErrorFunc errFuncSaved = xmlGenericError;
1854 174 : void *errCtxSaved = xmlGenericErrorContext;
1855 :
1856 174 : xmlSetGenericErrorFunc((void *) errorBuf,
1857 : (xmlGenericErrorFunc) appendStringInfo);
1858 :
1859 : /* Add context information to errorBuf */
1860 174 : appendStringInfoLineSeparator(errorBuf);
1861 :
1862 174 : xmlParserPrintFileContext(input);
1863 :
1864 : /* Restore generic error func */
1865 174 : xmlSetGenericErrorFunc(errCtxSaved, errFuncSaved);
1866 : }
1867 :
1868 : /* Get rid of any trailing newlines in errorBuf */
1869 174 : chopStringInfoNewlines(errorBuf);
1870 :
1871 : /*
1872 : * Legacy error handling mode. err_occurred is never set, we just add the
1873 : * message to err_buf. This mode exists because the xml2 contrib module
1874 : * uses our error-handling infrastructure, but we don't want to change its
1875 : * behaviour since it's deprecated anyway. This is also why we don't
1876 : * distinguish between notices, warnings and errors here --- the old-style
1877 : * generic error handler wouldn't have done that either.
1878 : */
1879 174 : if (xmlerrcxt->strictness == PG_XML_STRICTNESS_LEGACY)
1880 : {
1881 2 : appendStringInfoLineSeparator(&xmlerrcxt->err_buf);
1882 2 : appendStringInfoString(&xmlerrcxt->err_buf, errorBuf->data);
1883 :
1884 2 : pfree(errorBuf->data);
1885 2 : pfree(errorBuf);
1886 2 : return;
1887 : }
1888 :
1889 : /*
1890 : * We don't want to ereport() here because that'd probably leave libxml in
1891 : * an inconsistent state. Instead, we remember the error and ereport()
1892 : * from xml_ereport().
1893 : *
1894 : * Warnings and notices can be reported immediately since they won't cause
1895 : * a longjmp() out of libxml.
1896 : */
1897 172 : if (level >= XML_ERR_ERROR)
1898 : {
1899 168 : appendStringInfoLineSeparator(&xmlerrcxt->err_buf);
1900 168 : appendStringInfoString(&xmlerrcxt->err_buf, errorBuf->data);
1901 :
1902 168 : xmlerrcxt->err_occurred = true;
1903 : }
1904 4 : else if (level >= XML_ERR_WARNING)
1905 : {
1906 4 : ereport(WARNING,
1907 : (errmsg_internal("%s", errorBuf->data)));
1908 : }
1909 : else
1910 : {
1911 0 : ereport(NOTICE,
1912 : (errmsg_internal("%s", errorBuf->data)));
1913 : }
1914 :
1915 172 : pfree(errorBuf->data);
1916 172 : pfree(errorBuf);
1917 : }
1918 :
1919 :
1920 : /*
1921 : * Wrapper for "ereport" function for XML-related errors. The "msg"
1922 : * is the SQL-level message; some can be adopted from the SQL/XML
1923 : * standard. This function uses "code" to create a textual detail
1924 : * message. At the moment, we only need to cover those codes that we
1925 : * may raise in this file.
1926 : */
1927 : static void
1928 0 : xml_ereport_by_code(int level, int sqlcode,
1929 : const char *msg, int code)
1930 : {
1931 : const char *det;
1932 :
1933 0 : switch (code)
1934 : {
1935 : case XML_ERR_INVALID_CHAR:
1936 0 : det = gettext_noop("Invalid character value.");
1937 0 : break;
1938 : case XML_ERR_SPACE_REQUIRED:
1939 0 : det = gettext_noop("Space required.");
1940 0 : break;
1941 : case XML_ERR_STANDALONE_VALUE:
1942 0 : det = gettext_noop("standalone accepts only 'yes' or 'no'.");
1943 0 : break;
1944 : case XML_ERR_VERSION_MISSING:
1945 0 : det = gettext_noop("Malformed declaration: missing version.");
1946 0 : break;
1947 : case XML_ERR_MISSING_ENCODING:
1948 0 : det = gettext_noop("Missing encoding in text declaration.");
1949 0 : break;
1950 : case XML_ERR_XMLDECL_NOT_FINISHED:
1951 0 : det = gettext_noop("Parsing XML declaration: '?>' expected.");
1952 0 : break;
1953 : default:
1954 0 : det = gettext_noop("Unrecognized libxml error code: %d.");
1955 0 : break;
1956 : }
1957 :
1958 0 : ereport(level,
1959 : (errcode(sqlcode),
1960 : errmsg_internal("%s", msg),
1961 : errdetail(det, code)));
1962 0 : }
1963 :
1964 :
1965 : /*
1966 : * Remove all trailing newlines from a StringInfo string
1967 : */
1968 : static void
1969 518 : chopStringInfoNewlines(StringInfo str)
1970 : {
1971 1384 : while (str->len > 0 && str->data[str->len - 1] == '\n')
1972 348 : str->data[--str->len] = '\0';
1973 518 : }
1974 :
1975 :
1976 : /*
1977 : * Append a newline after removing any existing trailing newlines
1978 : */
1979 : static void
1980 344 : appendStringInfoLineSeparator(StringInfo str)
1981 : {
1982 344 : chopStringInfoNewlines(str);
1983 344 : if (str->len > 0)
1984 222 : appendStringInfoChar(str, '\n');
1985 344 : }
1986 :
1987 :
1988 : /*
1989 : * Convert one char in the current server encoding to a Unicode codepoint.
1990 : */
1991 : static pg_wchar
1992 12094 : sqlchar_to_unicode(const char *s)
1993 : {
1994 : char *utf8string;
1995 : pg_wchar ret[2]; /* need space for trailing zero */
1996 :
1997 : /* note we're not assuming s is null-terminated */
1998 12094 : utf8string = pg_server_to_any(s, pg_mblen(s), PG_UTF8);
1999 :
2000 12094 : pg_encoding_mb2wchar_with_len(PG_UTF8, utf8string, ret,
2001 : pg_encoding_mblen(PG_UTF8, utf8string));
2002 :
2003 12094 : if (utf8string != s)
2004 0 : pfree(utf8string);
2005 :
2006 12094 : return ret[0];
2007 : }
2008 :
2009 :
2010 : static bool
2011 2394 : is_valid_xml_namefirst(pg_wchar c)
2012 : {
2013 : /* (Letter | '_' | ':') */
2014 2394 : return (xmlIsBaseCharQ(c) || xmlIsIdeographicQ(c)
2015 4792 : || c == '_' || c == ':');
2016 : }
2017 :
2018 :
2019 : static bool
2020 9700 : is_valid_xml_namechar(pg_wchar c)
2021 : {
2022 : /* Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender */
2023 9700 : return (xmlIsBaseCharQ(c) || xmlIsIdeographicQ(c)
2024 594 : || xmlIsDigitQ(c)
2025 170 : || c == '.' || c == '-' || c == '_' || c == ':'
2026 8 : || xmlIsCombiningQ(c)
2027 20002 : || xmlIsExtenderQ(c));
2028 : }
2029 : #endif /* USE_LIBXML */
2030 :
2031 :
2032 : /*
2033 : * Map SQL identifier to XML name; see SQL/XML:2008 section 9.1.
2034 : */
2035 : char *
2036 2404 : map_sql_identifier_to_xml_name(const char *ident, bool fully_escaped,
2037 : bool escape_period)
2038 : {
2039 : #ifdef USE_LIBXML
2040 : StringInfoData buf;
2041 : const char *p;
2042 :
2043 : /*
2044 : * SQL/XML doesn't make use of this case anywhere, so it's probably a
2045 : * mistake.
2046 : */
2047 : Assert(fully_escaped || !escape_period);
2048 :
2049 2404 : initStringInfo(&buf);
2050 :
2051 14512 : for (p = ident; *p; p += pg_mblen(p))
2052 : {
2053 12108 : if (*p == ':' && (p == ident || fully_escaped))
2054 10 : appendStringInfoString(&buf, "_x003A_");
2055 12098 : else if (*p == '_' && *(p + 1) == 'x')
2056 4 : appendStringInfoString(&buf, "_x005F_");
2057 14250 : else if (fully_escaped && p == ident &&
2058 2156 : pg_strncasecmp(p, "xml", 3) == 0)
2059 : {
2060 0 : if (*p == 'x')
2061 0 : appendStringInfoString(&buf, "_x0078_");
2062 : else
2063 0 : appendStringInfoString(&buf, "_x0058_");
2064 : }
2065 12094 : else if (escape_period && *p == '.')
2066 0 : appendStringInfoString(&buf, "_x002E_");
2067 : else
2068 : {
2069 12094 : pg_wchar u = sqlchar_to_unicode(p);
2070 :
2071 24188 : if ((p == ident)
2072 2394 : ? !is_valid_xml_namefirst(u)
2073 9700 : : !is_valid_xml_namechar(u))
2074 12 : appendStringInfo(&buf, "_x%04X_", (unsigned int) u);
2075 : else
2076 12082 : appendBinaryStringInfo(&buf, p, pg_mblen(p));
2077 : }
2078 : }
2079 :
2080 2404 : return buf.data;
2081 : #else /* not USE_LIBXML */
2082 : NO_XML_SUPPORT();
2083 : return NULL;
2084 : #endif /* not USE_LIBXML */
2085 : }
2086 :
2087 :
2088 : /*
2089 : * Map a Unicode codepoint into the current server encoding.
2090 : */
2091 : static char *
2092 10 : unicode_to_sqlchar(pg_wchar c)
2093 : {
2094 : char utf8string[8]; /* need room for trailing zero */
2095 : char *result;
2096 :
2097 10 : memset(utf8string, 0, sizeof(utf8string));
2098 10 : unicode_to_utf8(c, (unsigned char *) utf8string);
2099 :
2100 10 : result = pg_any_to_server(utf8string, strlen(utf8string), PG_UTF8);
2101 : /* if pg_any_to_server didn't strdup, we must */
2102 10 : if (result == utf8string)
2103 10 : result = pstrdup(result);
2104 10 : return result;
2105 : }
2106 :
2107 :
2108 : /*
2109 : * Map XML name to SQL identifier; see SQL/XML:2008 section 9.3.
2110 : */
2111 : char *
2112 80 : map_xml_name_to_sql_identifier(const char *name)
2113 : {
2114 : StringInfoData buf;
2115 : const char *p;
2116 :
2117 80 : initStringInfo(&buf);
2118 :
2119 440 : for (p = name; *p; p += pg_mblen(p))
2120 : {
2121 360 : if (*p == '_' && *(p + 1) == 'x'
2122 10 : && isxdigit((unsigned char) *(p + 2))
2123 10 : && isxdigit((unsigned char) *(p + 3))
2124 10 : && isxdigit((unsigned char) *(p + 4))
2125 10 : && isxdigit((unsigned char) *(p + 5))
2126 10 : && *(p + 6) == '_')
2127 10 : {
2128 : unsigned int u;
2129 :
2130 10 : sscanf(p + 2, "%X", &u);
2131 10 : appendStringInfoString(&buf, unicode_to_sqlchar(u));
2132 10 : p += 6;
2133 : }
2134 : else
2135 350 : appendBinaryStringInfo(&buf, p, pg_mblen(p));
2136 : }
2137 :
2138 80 : return buf.data;
2139 : }
2140 :
2141 : /*
2142 : * Map SQL value to XML value; see SQL/XML:2008 section 9.8.
2143 : *
2144 : * When xml_escape_strings is true, then certain characters in string
2145 : * values are replaced by entity references (< etc.), as specified
2146 : * in SQL/XML:2008 section 9.8 GR 9) a) iii). This is normally what is
2147 : * wanted. The false case is mainly useful when the resulting value
2148 : * is used with xmlTextWriterWriteAttribute() to write out an
2149 : * attribute, because that function does the escaping itself.
2150 : */
2151 : char *
2152 77412 : map_sql_value_to_xml_value(Datum value, Oid type, bool xml_escape_strings)
2153 : {
2154 77412 : if (type_is_array_domain(type))
2155 : {
2156 : ArrayType *array;
2157 : Oid elmtype;
2158 : int16 elmlen;
2159 : bool elmbyval;
2160 : char elmalign;
2161 : int num_elems;
2162 : Datum *elem_values;
2163 : bool *elem_nulls;
2164 : StringInfoData buf;
2165 : int i;
2166 :
2167 4 : array = DatumGetArrayTypeP(value);
2168 4 : elmtype = ARR_ELEMTYPE(array);
2169 4 : get_typlenbyvalalign(elmtype, &elmlen, &elmbyval, &elmalign);
2170 :
2171 4 : deconstruct_array(array, elmtype,
2172 : elmlen, elmbyval, elmalign,
2173 : &elem_values, &elem_nulls,
2174 : &num_elems);
2175 :
2176 4 : initStringInfo(&buf);
2177 :
2178 16 : for (i = 0; i < num_elems; i++)
2179 : {
2180 12 : if (elem_nulls[i])
2181 0 : continue;
2182 12 : appendStringInfoString(&buf, "<element>");
2183 12 : appendStringInfoString(&buf,
2184 12 : map_sql_value_to_xml_value(elem_values[i],
2185 : elmtype, true));
2186 12 : appendStringInfoString(&buf, "</element>");
2187 : }
2188 :
2189 4 : pfree(elem_values);
2190 4 : pfree(elem_nulls);
2191 :
2192 4 : return buf.data;
2193 : }
2194 : else
2195 : {
2196 : Oid typeOut;
2197 : bool isvarlena;
2198 : char *str;
2199 :
2200 : /*
2201 : * Flatten domains; the special-case treatments below should apply to,
2202 : * eg, domains over boolean not just boolean.
2203 : */
2204 77408 : type = getBaseType(type);
2205 :
2206 : /*
2207 : * Special XSD formatting for some data types
2208 : */
2209 77408 : switch (type)
2210 : {
2211 : case BOOLOID:
2212 44 : if (DatumGetBool(value))
2213 40 : return "true";
2214 : else
2215 4 : return "false";
2216 :
2217 : case DATEOID:
2218 : {
2219 : DateADT date;
2220 : struct pg_tm tm;
2221 : char buf[MAXDATELEN + 1];
2222 :
2223 32 : date = DatumGetDateADT(value);
2224 : /* XSD doesn't support infinite values */
2225 32 : if (DATE_NOT_FINITE(date))
2226 0 : ereport(ERROR,
2227 : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2228 : errmsg("date out of range"),
2229 : errdetail("XML does not support infinite date values.")));
2230 32 : j2date(date + POSTGRES_EPOCH_JDATE,
2231 : &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
2232 32 : EncodeDateOnly(&tm, USE_XSD_DATES, buf);
2233 :
2234 32 : return pstrdup(buf);
2235 : }
2236 :
2237 : case TIMESTAMPOID:
2238 : {
2239 : Timestamp timestamp;
2240 : struct pg_tm tm;
2241 : fsec_t fsec;
2242 : char buf[MAXDATELEN + 1];
2243 :
2244 24 : timestamp = DatumGetTimestamp(value);
2245 :
2246 : /* XSD doesn't support infinite values */
2247 24 : if (TIMESTAMP_NOT_FINITE(timestamp))
2248 4 : ereport(ERROR,
2249 : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2250 : errmsg("timestamp out of range"),
2251 : errdetail("XML does not support infinite timestamp values.")));
2252 20 : else if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, NULL) == 0)
2253 20 : EncodeDateTime(&tm, fsec, false, 0, NULL, USE_XSD_DATES, buf);
2254 : else
2255 0 : ereport(ERROR,
2256 : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2257 : errmsg("timestamp out of range")));
2258 :
2259 20 : return pstrdup(buf);
2260 : }
2261 :
2262 : case TIMESTAMPTZOID:
2263 : {
2264 : TimestampTz timestamp;
2265 : struct pg_tm tm;
2266 : int tz;
2267 : fsec_t fsec;
2268 0 : const char *tzn = NULL;
2269 : char buf[MAXDATELEN + 1];
2270 :
2271 0 : timestamp = DatumGetTimestamp(value);
2272 :
2273 : /* XSD doesn't support infinite values */
2274 0 : if (TIMESTAMP_NOT_FINITE(timestamp))
2275 0 : ereport(ERROR,
2276 : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2277 : errmsg("timestamp out of range"),
2278 : errdetail("XML does not support infinite timestamp values.")));
2279 0 : else if (timestamp2tm(timestamp, &tz, &tm, &fsec, &tzn, NULL) == 0)
2280 0 : EncodeDateTime(&tm, fsec, true, tz, tzn, USE_XSD_DATES, buf);
2281 : else
2282 0 : ereport(ERROR,
2283 : (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2284 : errmsg("timestamp out of range")));
2285 :
2286 0 : return pstrdup(buf);
2287 : }
2288 :
2289 : #ifdef USE_LIBXML
2290 : case BYTEAOID:
2291 : {
2292 24 : bytea *bstr = DatumGetByteaPP(value);
2293 : PgXmlErrorContext *xmlerrcxt;
2294 24 : volatile xmlBufferPtr buf = NULL;
2295 24 : volatile xmlTextWriterPtr writer = NULL;
2296 : char *result;
2297 :
2298 24 : xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
2299 :
2300 24 : PG_TRY();
2301 : {
2302 24 : buf = xmlBufferCreate();
2303 24 : if (buf == NULL || xmlerrcxt->err_occurred)
2304 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
2305 : "could not allocate xmlBuffer");
2306 24 : writer = xmlNewTextWriterMemory(buf, 0);
2307 24 : if (writer == NULL || xmlerrcxt->err_occurred)
2308 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
2309 : "could not allocate xmlTextWriter");
2310 :
2311 24 : if (xmlbinary == XMLBINARY_BASE64)
2312 60 : xmlTextWriterWriteBase64(writer, VARDATA_ANY(bstr),
2313 60 : 0, VARSIZE_ANY_EXHDR(bstr));
2314 : else
2315 12 : xmlTextWriterWriteBinHex(writer, VARDATA_ANY(bstr),
2316 12 : 0, VARSIZE_ANY_EXHDR(bstr));
2317 :
2318 : /* we MUST do this now to flush data out to the buffer */
2319 24 : xmlFreeTextWriter(writer);
2320 24 : writer = NULL;
2321 :
2322 24 : result = pstrdup((const char *) xmlBufferContent(buf));
2323 : }
2324 0 : PG_CATCH();
2325 : {
2326 0 : if (writer)
2327 0 : xmlFreeTextWriter(writer);
2328 0 : if (buf)
2329 0 : xmlBufferFree(buf);
2330 :
2331 0 : pg_xml_done(xmlerrcxt, true);
2332 :
2333 0 : PG_RE_THROW();
2334 : }
2335 24 : PG_END_TRY();
2336 :
2337 24 : xmlBufferFree(buf);
2338 :
2339 24 : pg_xml_done(xmlerrcxt, false);
2340 :
2341 24 : return result;
2342 : }
2343 : #endif /* USE_LIBXML */
2344 :
2345 : }
2346 :
2347 : /*
2348 : * otherwise, just use the type's native text representation
2349 : */
2350 77284 : getTypeOutputInfo(type, &typeOut, &isvarlena);
2351 77284 : str = OidOutputFunctionCall(typeOut, value);
2352 :
2353 : /* ... exactly as-is for XML, and when escaping is not wanted */
2354 77284 : if (type == XMLOID || !xml_escape_strings)
2355 12864 : return str;
2356 :
2357 : /* otherwise, translate special characters as needed */
2358 64420 : return escape_xml(str);
2359 : }
2360 : }
2361 :
2362 :
2363 : /*
2364 : * Escape characters in text that have special meanings in XML.
2365 : *
2366 : * Returns a palloc'd string.
2367 : *
2368 : * NB: this is intentionally not dependent on libxml.
2369 : */
2370 : char *
2371 64452 : escape_xml(const char *str)
2372 : {
2373 : StringInfoData buf;
2374 : const char *p;
2375 :
2376 64452 : initStringInfo(&buf);
2377 386396 : for (p = str; *p; p++)
2378 : {
2379 321944 : switch (*p)
2380 : {
2381 : case '&':
2382 0 : appendStringInfoString(&buf, "&");
2383 0 : break;
2384 : case '<':
2385 24 : appendStringInfoString(&buf, "<");
2386 24 : break;
2387 : case '>':
2388 16 : appendStringInfoString(&buf, ">");
2389 16 : break;
2390 : case '\r':
2391 0 : appendStringInfoString(&buf, "
");
2392 0 : break;
2393 : default:
2394 321904 : appendStringInfoCharMacro(&buf, *p);
2395 321904 : break;
2396 : }
2397 : }
2398 64452 : return buf.data;
2399 : }
2400 :
2401 :
2402 : static char *
2403 16 : _SPI_strdup(const char *s)
2404 : {
2405 16 : size_t len = strlen(s) + 1;
2406 16 : char *ret = SPI_palloc(len);
2407 :
2408 16 : memcpy(ret, s, len);
2409 16 : return ret;
2410 : }
2411 :
2412 :
2413 : /*
2414 : * SQL to XML mapping functions
2415 : *
2416 : * What follows below was at one point intentionally organized so that
2417 : * you can read along in the SQL/XML standard. The functions are
2418 : * mostly split up the way the clauses lay out in the standards
2419 : * document, and the identifiers are also aligned with the standard
2420 : * text. Unfortunately, SQL/XML:2006 reordered the clauses
2421 : * differently than SQL/XML:2003, so the order below doesn't make much
2422 : * sense anymore.
2423 : *
2424 : * There are many things going on there:
2425 : *
2426 : * There are two kinds of mappings: Mapping SQL data (table contents)
2427 : * to XML documents, and mapping SQL structure (the "schema") to XML
2428 : * Schema. And there are functions that do both at the same time.
2429 : *
2430 : * Then you can map a database, a schema, or a table, each in both
2431 : * ways. This breaks down recursively: Mapping a database invokes
2432 : * mapping schemas, which invokes mapping tables, which invokes
2433 : * mapping rows, which invokes mapping columns, although you can't
2434 : * call the last two from the outside. Because of this, there are a
2435 : * number of xyz_internal() functions which are to be called both from
2436 : * the function manager wrapper and from some upper layer in a
2437 : * recursive call.
2438 : *
2439 : * See the documentation about what the common function arguments
2440 : * nulls, tableforest, and targetns mean.
2441 : *
2442 : * Some style guidelines for XML output: Use double quotes for quoting
2443 : * XML attributes. Indent XML elements by two spaces, but remember
2444 : * that a lot of code is called recursively at different levels, so
2445 : * it's better not to indent rather than create output that indents
2446 : * and outdents weirdly. Add newlines to make the output look nice.
2447 : */
2448 :
2449 :
2450 : /*
2451 : * Visibility of objects for XML mappings; see SQL/XML:2008 section
2452 : * 4.10.8.
2453 : */
2454 :
2455 : /*
2456 : * Given a query, which must return type oid as first column, produce
2457 : * a list of Oids with the query results.
2458 : */
2459 : static List *
2460 24 : query_to_oid_list(const char *query)
2461 : {
2462 : uint64 i;
2463 24 : List *list = NIL;
2464 :
2465 24 : SPI_execute(query, true, 0);
2466 :
2467 72 : for (i = 0; i < SPI_processed; i++)
2468 : {
2469 : Datum oid;
2470 : bool isnull;
2471 :
2472 48 : oid = SPI_getbinval(SPI_tuptable->vals[i],
2473 48 : SPI_tuptable->tupdesc,
2474 : 1,
2475 : &isnull);
2476 48 : if (!isnull)
2477 48 : list = lappend_oid(list, DatumGetObjectId(oid));
2478 : }
2479 :
2480 24 : return list;
2481 : }
2482 :
2483 :
2484 : static List *
2485 24 : schema_get_xml_visible_tables(Oid nspid)
2486 : {
2487 : StringInfoData query;
2488 :
2489 24 : initStringInfo(&query);
2490 24 : appendStringInfo(&query, "SELECT oid FROM pg_catalog.pg_class"
2491 : " WHERE relnamespace = %u AND relkind IN ("
2492 : CppAsString2(RELKIND_RELATION) ","
2493 : CppAsString2(RELKIND_MATVIEW) ","
2494 : CppAsString2(RELKIND_VIEW) ")"
2495 : " AND pg_catalog.has_table_privilege (oid, 'SELECT')"
2496 : " ORDER BY relname;", nspid);
2497 :
2498 24 : return query_to_oid_list(query.data);
2499 : }
2500 :
2501 :
2502 : /*
2503 : * Including the system schemas is probably not useful for a database
2504 : * mapping.
2505 : */
2506 : #define XML_VISIBLE_SCHEMAS_EXCLUDE "(nspname ~ '^pg_' OR nspname = 'information_schema')"
2507 :
2508 : #define XML_VISIBLE_SCHEMAS "SELECT oid FROM pg_catalog.pg_namespace WHERE pg_catalog.has_schema_privilege (oid, 'USAGE') AND NOT " XML_VISIBLE_SCHEMAS_EXCLUDE
2509 :
2510 :
2511 : static List *
2512 0 : database_get_xml_visible_schemas(void)
2513 : {
2514 0 : return query_to_oid_list(XML_VISIBLE_SCHEMAS " ORDER BY nspname;");
2515 : }
2516 :
2517 :
2518 : static List *
2519 0 : database_get_xml_visible_tables(void)
2520 : {
2521 : /* At the moment there is no order required here. */
2522 0 : return query_to_oid_list("SELECT oid FROM pg_catalog.pg_class"
2523 : " WHERE relkind IN ("
2524 : CppAsString2(RELKIND_RELATION) ","
2525 : CppAsString2(RELKIND_MATVIEW) ","
2526 : CppAsString2(RELKIND_VIEW) ")"
2527 : " AND pg_catalog.has_table_privilege(pg_class.oid, 'SELECT')"
2528 : " AND relnamespace IN (" XML_VISIBLE_SCHEMAS ");");
2529 : }
2530 :
2531 :
2532 : /*
2533 : * Map SQL table to XML and/or XML Schema document; see SQL/XML:2008
2534 : * section 9.11.
2535 : */
2536 :
2537 : static StringInfo
2538 64 : table_to_xml_internal(Oid relid,
2539 : const char *xmlschema, bool nulls, bool tableforest,
2540 : const char *targetns, bool top_level)
2541 : {
2542 : StringInfoData query;
2543 :
2544 64 : initStringInfo(&query);
2545 64 : appendStringInfo(&query, "SELECT * FROM %s",
2546 64 : DatumGetCString(DirectFunctionCall1(regclassout,
2547 : ObjectIdGetDatum(relid))));
2548 64 : return query_to_xml_internal(query.data, get_rel_name(relid),
2549 : xmlschema, nulls, tableforest,
2550 : targetns, top_level);
2551 : }
2552 :
2553 :
2554 : Datum
2555 24 : table_to_xml(PG_FUNCTION_ARGS)
2556 : {
2557 24 : Oid relid = PG_GETARG_OID(0);
2558 24 : bool nulls = PG_GETARG_BOOL(1);
2559 24 : bool tableforest = PG_GETARG_BOOL(2);
2560 24 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2561 :
2562 24 : PG_RETURN_XML_P(stringinfo_to_xmltype(table_to_xml_internal(relid, NULL,
2563 : nulls, tableforest,
2564 : targetns, true)));
2565 : }
2566 :
2567 :
2568 : Datum
2569 8 : query_to_xml(PG_FUNCTION_ARGS)
2570 : {
2571 8 : char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
2572 8 : bool nulls = PG_GETARG_BOOL(1);
2573 8 : bool tableforest = PG_GETARG_BOOL(2);
2574 8 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2575 :
2576 8 : PG_RETURN_XML_P(stringinfo_to_xmltype(query_to_xml_internal(query, NULL,
2577 : NULL, nulls, tableforest,
2578 : targetns, true)));
2579 : }
2580 :
2581 :
2582 : Datum
2583 8 : cursor_to_xml(PG_FUNCTION_ARGS)
2584 : {
2585 8 : char *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
2586 8 : int32 count = PG_GETARG_INT32(1);
2587 8 : bool nulls = PG_GETARG_BOOL(2);
2588 8 : bool tableforest = PG_GETARG_BOOL(3);
2589 8 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(4));
2590 :
2591 : StringInfoData result;
2592 : Portal portal;
2593 : uint64 i;
2594 :
2595 8 : initStringInfo(&result);
2596 :
2597 8 : if (!tableforest)
2598 : {
2599 4 : xmldata_root_element_start(&result, "table", NULL, targetns, true);
2600 4 : appendStringInfoChar(&result, '\n');
2601 : }
2602 :
2603 8 : SPI_connect();
2604 8 : portal = SPI_cursor_find(name);
2605 8 : if (portal == NULL)
2606 0 : ereport(ERROR,
2607 : (errcode(ERRCODE_UNDEFINED_CURSOR),
2608 : errmsg("cursor \"%s\" does not exist", name)));
2609 :
2610 8 : SPI_cursor_fetch(portal, true, count);
2611 32 : for (i = 0; i < SPI_processed; i++)
2612 24 : SPI_sql_row_to_xmlelement(i, &result, NULL, nulls,
2613 : tableforest, targetns, true);
2614 :
2615 8 : SPI_finish();
2616 :
2617 8 : if (!tableforest)
2618 4 : xmldata_root_element_end(&result, "table");
2619 :
2620 8 : PG_RETURN_XML_P(stringinfo_to_xmltype(&result));
2621 : }
2622 :
2623 :
2624 : /*
2625 : * Write the start tag of the root element of a data mapping.
2626 : *
2627 : * top_level means that this is the very top level of the eventual
2628 : * output. For example, when the user calls table_to_xml, then a call
2629 : * with a table name to this function is the top level. When the user
2630 : * calls database_to_xml, then a call with a schema name to this
2631 : * function is not the top level. If top_level is false, then the XML
2632 : * namespace declarations are omitted, because they supposedly already
2633 : * appeared earlier in the output. Repeating them is not wrong, but
2634 : * it looks ugly.
2635 : */
2636 : static void
2637 160 : xmldata_root_element_start(StringInfo result, const char *eltname,
2638 : const char *xmlschema, const char *targetns,
2639 : bool top_level)
2640 : {
2641 : /* This isn't really wrong but currently makes no sense. */
2642 : Assert(top_level || !xmlschema);
2643 :
2644 160 : appendStringInfo(result, "<%s", eltname);
2645 160 : if (top_level)
2646 : {
2647 120 : appendStringInfoString(result, " xmlns:xsi=\"" NAMESPACE_XSI "\"");
2648 120 : if (strlen(targetns) > 0)
2649 20 : appendStringInfo(result, " xmlns=\"%s\"", targetns);
2650 : }
2651 160 : if (xmlschema)
2652 : {
2653 : /* FIXME: better targets */
2654 12 : if (strlen(targetns) > 0)
2655 4 : appendStringInfo(result, " xsi:schemaLocation=\"%s #\"", targetns);
2656 : else
2657 8 : appendStringInfoString(result, " xsi:noNamespaceSchemaLocation=\"#\"");
2658 : }
2659 160 : appendStringInfoString(result, ">\n");
2660 160 : }
2661 :
2662 :
2663 : static void
2664 160 : xmldata_root_element_end(StringInfo result, const char *eltname)
2665 : {
2666 160 : appendStringInfo(result, "</%s>\n", eltname);
2667 160 : }
2668 :
2669 :
2670 : static StringInfo
2671 76 : query_to_xml_internal(const char *query, char *tablename,
2672 : const char *xmlschema, bool nulls, bool tableforest,
2673 : const char *targetns, bool top_level)
2674 : {
2675 : StringInfo result;
2676 : char *xmltn;
2677 : uint64 i;
2678 :
2679 76 : if (tablename)
2680 64 : xmltn = map_sql_identifier_to_xml_name(tablename, true, false);
2681 : else
2682 12 : xmltn = "table";
2683 :
2684 76 : result = makeStringInfo();
2685 :
2686 76 : SPI_connect();
2687 76 : if (SPI_execute(query, true, 0) != SPI_OK_SELECT)
2688 0 : ereport(ERROR,
2689 : (errcode(ERRCODE_DATA_EXCEPTION),
2690 : errmsg("invalid query")));
2691 :
2692 76 : if (!tableforest)
2693 : {
2694 36 : xmldata_root_element_start(result, xmltn, xmlschema,
2695 : targetns, top_level);
2696 36 : appendStringInfoChar(result, '\n');
2697 : }
2698 :
2699 76 : if (xmlschema)
2700 20 : appendStringInfo(result, "%s\n\n", xmlschema);
2701 :
2702 264 : for (i = 0; i < SPI_processed; i++)
2703 188 : SPI_sql_row_to_xmlelement(i, result, tablename, nulls,
2704 : tableforest, targetns, top_level);
2705 :
2706 76 : if (!tableforest)
2707 36 : xmldata_root_element_end(result, xmltn);
2708 :
2709 76 : SPI_finish();
2710 :
2711 76 : return result;
2712 : }
2713 :
2714 :
2715 : Datum
2716 20 : table_to_xmlschema(PG_FUNCTION_ARGS)
2717 : {
2718 20 : Oid relid = PG_GETARG_OID(0);
2719 20 : bool nulls = PG_GETARG_BOOL(1);
2720 20 : bool tableforest = PG_GETARG_BOOL(2);
2721 20 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2722 : const char *result;
2723 : Relation rel;
2724 :
2725 20 : rel = table_open(relid, AccessShareLock);
2726 20 : result = map_sql_table_to_xmlschema(rel->rd_att, relid, nulls,
2727 : tableforest, targetns);
2728 20 : table_close(rel, NoLock);
2729 :
2730 20 : PG_RETURN_XML_P(cstring_to_xmltype(result));
2731 : }
2732 :
2733 :
2734 : Datum
2735 4 : query_to_xmlschema(PG_FUNCTION_ARGS)
2736 : {
2737 4 : char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
2738 4 : bool nulls = PG_GETARG_BOOL(1);
2739 4 : bool tableforest = PG_GETARG_BOOL(2);
2740 4 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2741 : const char *result;
2742 : SPIPlanPtr plan;
2743 : Portal portal;
2744 :
2745 4 : SPI_connect();
2746 :
2747 4 : if ((plan = SPI_prepare(query, 0, NULL)) == NULL)
2748 0 : elog(ERROR, "SPI_prepare(\"%s\") failed", query);
2749 :
2750 4 : if ((portal = SPI_cursor_open(NULL, plan, NULL, NULL, true)) == NULL)
2751 0 : elog(ERROR, "SPI_cursor_open(\"%s\") failed", query);
2752 :
2753 4 : result = _SPI_strdup(map_sql_table_to_xmlschema(portal->tupDesc,
2754 : InvalidOid, nulls,
2755 : tableforest, targetns));
2756 4 : SPI_cursor_close(portal);
2757 4 : SPI_finish();
2758 :
2759 4 : PG_RETURN_XML_P(cstring_to_xmltype(result));
2760 : }
2761 :
2762 :
2763 : Datum
2764 8 : cursor_to_xmlschema(PG_FUNCTION_ARGS)
2765 : {
2766 8 : char *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
2767 8 : bool nulls = PG_GETARG_BOOL(1);
2768 8 : bool tableforest = PG_GETARG_BOOL(2);
2769 8 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2770 : const char *xmlschema;
2771 : Portal portal;
2772 :
2773 8 : SPI_connect();
2774 8 : portal = SPI_cursor_find(name);
2775 8 : if (portal == NULL)
2776 0 : ereport(ERROR,
2777 : (errcode(ERRCODE_UNDEFINED_CURSOR),
2778 : errmsg("cursor \"%s\" does not exist", name)));
2779 :
2780 8 : xmlschema = _SPI_strdup(map_sql_table_to_xmlschema(portal->tupDesc,
2781 : InvalidOid, nulls,
2782 : tableforest, targetns));
2783 8 : SPI_finish();
2784 :
2785 8 : PG_RETURN_XML_P(cstring_to_xmltype(xmlschema));
2786 : }
2787 :
2788 :
2789 : Datum
2790 16 : table_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
2791 : {
2792 16 : Oid relid = PG_GETARG_OID(0);
2793 16 : bool nulls = PG_GETARG_BOOL(1);
2794 16 : bool tableforest = PG_GETARG_BOOL(2);
2795 16 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2796 : Relation rel;
2797 : const char *xmlschema;
2798 :
2799 16 : rel = table_open(relid, AccessShareLock);
2800 16 : xmlschema = map_sql_table_to_xmlschema(rel->rd_att, relid, nulls,
2801 : tableforest, targetns);
2802 16 : table_close(rel, NoLock);
2803 :
2804 16 : PG_RETURN_XML_P(stringinfo_to_xmltype(table_to_xml_internal(relid,
2805 : xmlschema, nulls, tableforest,
2806 : targetns, true)));
2807 : }
2808 :
2809 :
2810 : Datum
2811 4 : query_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
2812 : {
2813 4 : char *query = text_to_cstring(PG_GETARG_TEXT_PP(0));
2814 4 : bool nulls = PG_GETARG_BOOL(1);
2815 4 : bool tableforest = PG_GETARG_BOOL(2);
2816 4 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2817 :
2818 : const char *xmlschema;
2819 : SPIPlanPtr plan;
2820 : Portal portal;
2821 :
2822 4 : SPI_connect();
2823 :
2824 4 : if ((plan = SPI_prepare(query, 0, NULL)) == NULL)
2825 0 : elog(ERROR, "SPI_prepare(\"%s\") failed", query);
2826 :
2827 4 : if ((portal = SPI_cursor_open(NULL, plan, NULL, NULL, true)) == NULL)
2828 0 : elog(ERROR, "SPI_cursor_open(\"%s\") failed", query);
2829 :
2830 4 : xmlschema = _SPI_strdup(map_sql_table_to_xmlschema(portal->tupDesc,
2831 : InvalidOid, nulls, tableforest, targetns));
2832 4 : SPI_cursor_close(portal);
2833 4 : SPI_finish();
2834 :
2835 4 : PG_RETURN_XML_P(stringinfo_to_xmltype(query_to_xml_internal(query, NULL,
2836 : xmlschema, nulls, tableforest,
2837 : targetns, true)));
2838 : }
2839 :
2840 :
2841 : /*
2842 : * Map SQL schema to XML and/or XML Schema document; see SQL/XML:2008
2843 : * sections 9.13, 9.14.
2844 : */
2845 :
2846 : static StringInfo
2847 12 : schema_to_xml_internal(Oid nspid, const char *xmlschema, bool nulls,
2848 : bool tableforest, const char *targetns, bool top_level)
2849 : {
2850 : StringInfo result;
2851 : char *xmlsn;
2852 : List *relid_list;
2853 : ListCell *cell;
2854 :
2855 12 : xmlsn = map_sql_identifier_to_xml_name(get_namespace_name(nspid),
2856 : true, false);
2857 12 : result = makeStringInfo();
2858 :
2859 12 : xmldata_root_element_start(result, xmlsn, xmlschema, targetns, top_level);
2860 12 : appendStringInfoChar(result, '\n');
2861 :
2862 12 : if (xmlschema)
2863 4 : appendStringInfo(result, "%s\n\n", xmlschema);
2864 :
2865 12 : SPI_connect();
2866 :
2867 12 : relid_list = schema_get_xml_visible_tables(nspid);
2868 :
2869 36 : foreach(cell, relid_list)
2870 : {
2871 24 : Oid relid = lfirst_oid(cell);
2872 : StringInfo subres;
2873 :
2874 24 : subres = table_to_xml_internal(relid, NULL, nulls, tableforest,
2875 : targetns, false);
2876 :
2877 24 : appendStringInfoString(result, subres->data);
2878 24 : appendStringInfoChar(result, '\n');
2879 : }
2880 :
2881 12 : SPI_finish();
2882 :
2883 12 : xmldata_root_element_end(result, xmlsn);
2884 :
2885 12 : return result;
2886 : }
2887 :
2888 :
2889 : Datum
2890 8 : schema_to_xml(PG_FUNCTION_ARGS)
2891 : {
2892 8 : Name name = PG_GETARG_NAME(0);
2893 8 : bool nulls = PG_GETARG_BOOL(1);
2894 8 : bool tableforest = PG_GETARG_BOOL(2);
2895 8 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2896 :
2897 : char *schemaname;
2898 : Oid nspid;
2899 :
2900 8 : schemaname = NameStr(*name);
2901 8 : nspid = LookupExplicitNamespace(schemaname, false);
2902 :
2903 8 : PG_RETURN_XML_P(stringinfo_to_xmltype(schema_to_xml_internal(nspid, NULL,
2904 : nulls, tableforest, targetns, true)));
2905 : }
2906 :
2907 :
2908 : /*
2909 : * Write the start element of the root element of an XML Schema mapping.
2910 : */
2911 : static void
2912 64 : xsd_schema_element_start(StringInfo result, const char *targetns)
2913 : {
2914 64 : appendStringInfoString(result,
2915 : "<xsd:schema\n"
2916 : " xmlns:xsd=\"" NAMESPACE_XSD "\"");
2917 64 : if (strlen(targetns) > 0)
2918 12 : appendStringInfo(result,
2919 : "\n"
2920 : " targetNamespace=\"%s\"\n"
2921 : " elementFormDefault=\"qualified\"",
2922 : targetns);
2923 64 : appendStringInfoString(result,
2924 : ">\n\n");
2925 64 : }
2926 :
2927 :
2928 : static void
2929 64 : xsd_schema_element_end(StringInfo result)
2930 : {
2931 64 : appendStringInfoString(result, "</xsd:schema>");
2932 64 : }
2933 :
2934 :
2935 : static StringInfo
2936 12 : schema_to_xmlschema_internal(const char *schemaname, bool nulls,
2937 : bool tableforest, const char *targetns)
2938 : {
2939 : Oid nspid;
2940 : List *relid_list;
2941 : List *tupdesc_list;
2942 : ListCell *cell;
2943 : StringInfo result;
2944 :
2945 12 : result = makeStringInfo();
2946 :
2947 12 : nspid = LookupExplicitNamespace(schemaname, false);
2948 :
2949 12 : xsd_schema_element_start(result, targetns);
2950 :
2951 12 : SPI_connect();
2952 :
2953 12 : relid_list = schema_get_xml_visible_tables(nspid);
2954 :
2955 12 : tupdesc_list = NIL;
2956 36 : foreach(cell, relid_list)
2957 : {
2958 : Relation rel;
2959 :
2960 24 : rel = table_open(lfirst_oid(cell), AccessShareLock);
2961 24 : tupdesc_list = lappend(tupdesc_list, CreateTupleDescCopy(rel->rd_att));
2962 24 : table_close(rel, NoLock);
2963 : }
2964 :
2965 12 : appendStringInfoString(result,
2966 : map_sql_typecoll_to_xmlschema_types(tupdesc_list));
2967 :
2968 12 : appendStringInfoString(result,
2969 : map_sql_schema_to_xmlschema_types(nspid, relid_list,
2970 : nulls, tableforest, targetns));
2971 :
2972 12 : xsd_schema_element_end(result);
2973 :
2974 12 : SPI_finish();
2975 :
2976 12 : return result;
2977 : }
2978 :
2979 :
2980 : Datum
2981 8 : schema_to_xmlschema(PG_FUNCTION_ARGS)
2982 : {
2983 8 : Name name = PG_GETARG_NAME(0);
2984 8 : bool nulls = PG_GETARG_BOOL(1);
2985 8 : bool tableforest = PG_GETARG_BOOL(2);
2986 8 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
2987 :
2988 8 : PG_RETURN_XML_P(stringinfo_to_xmltype(schema_to_xmlschema_internal(NameStr(*name),
2989 : nulls, tableforest, targetns)));
2990 : }
2991 :
2992 :
2993 : Datum
2994 4 : schema_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
2995 : {
2996 4 : Name name = PG_GETARG_NAME(0);
2997 4 : bool nulls = PG_GETARG_BOOL(1);
2998 4 : bool tableforest = PG_GETARG_BOOL(2);
2999 4 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(3));
3000 : char *schemaname;
3001 : Oid nspid;
3002 : StringInfo xmlschema;
3003 :
3004 4 : schemaname = NameStr(*name);
3005 4 : nspid = LookupExplicitNamespace(schemaname, false);
3006 :
3007 4 : xmlschema = schema_to_xmlschema_internal(schemaname, nulls,
3008 : tableforest, targetns);
3009 :
3010 4 : PG_RETURN_XML_P(stringinfo_to_xmltype(schema_to_xml_internal(nspid,
3011 : xmlschema->data, nulls,
3012 : tableforest, targetns, true)));
3013 : }
3014 :
3015 :
3016 : /*
3017 : * Map SQL database to XML and/or XML Schema document; see SQL/XML:2008
3018 : * sections 9.16, 9.17.
3019 : */
3020 :
3021 : static StringInfo
3022 0 : database_to_xml_internal(const char *xmlschema, bool nulls,
3023 : bool tableforest, const char *targetns)
3024 : {
3025 : StringInfo result;
3026 : List *nspid_list;
3027 : ListCell *cell;
3028 : char *xmlcn;
3029 :
3030 0 : xmlcn = map_sql_identifier_to_xml_name(get_database_name(MyDatabaseId),
3031 : true, false);
3032 0 : result = makeStringInfo();
3033 :
3034 0 : xmldata_root_element_start(result, xmlcn, xmlschema, targetns, true);
3035 0 : appendStringInfoChar(result, '\n');
3036 :
3037 0 : if (xmlschema)
3038 0 : appendStringInfo(result, "%s\n\n", xmlschema);
3039 :
3040 0 : SPI_connect();
3041 :
3042 0 : nspid_list = database_get_xml_visible_schemas();
3043 :
3044 0 : foreach(cell, nspid_list)
3045 : {
3046 0 : Oid nspid = lfirst_oid(cell);
3047 : StringInfo subres;
3048 :
3049 0 : subres = schema_to_xml_internal(nspid, NULL, nulls,
3050 : tableforest, targetns, false);
3051 :
3052 0 : appendStringInfoString(result, subres->data);
3053 0 : appendStringInfoChar(result, '\n');
3054 : }
3055 :
3056 0 : SPI_finish();
3057 :
3058 0 : xmldata_root_element_end(result, xmlcn);
3059 :
3060 0 : return result;
3061 : }
3062 :
3063 :
3064 : Datum
3065 0 : database_to_xml(PG_FUNCTION_ARGS)
3066 : {
3067 0 : bool nulls = PG_GETARG_BOOL(0);
3068 0 : bool tableforest = PG_GETARG_BOOL(1);
3069 0 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
3070 :
3071 0 : PG_RETURN_XML_P(stringinfo_to_xmltype(database_to_xml_internal(NULL, nulls,
3072 : tableforest, targetns)));
3073 : }
3074 :
3075 :
3076 : static StringInfo
3077 0 : database_to_xmlschema_internal(bool nulls, bool tableforest,
3078 : const char *targetns)
3079 : {
3080 : List *relid_list;
3081 : List *nspid_list;
3082 : List *tupdesc_list;
3083 : ListCell *cell;
3084 : StringInfo result;
3085 :
3086 0 : result = makeStringInfo();
3087 :
3088 0 : xsd_schema_element_start(result, targetns);
3089 :
3090 0 : SPI_connect();
3091 :
3092 0 : relid_list = database_get_xml_visible_tables();
3093 0 : nspid_list = database_get_xml_visible_schemas();
3094 :
3095 0 : tupdesc_list = NIL;
3096 0 : foreach(cell, relid_list)
3097 : {
3098 : Relation rel;
3099 :
3100 0 : rel = table_open(lfirst_oid(cell), AccessShareLock);
3101 0 : tupdesc_list = lappend(tupdesc_list, CreateTupleDescCopy(rel->rd_att));
3102 0 : table_close(rel, NoLock);
3103 : }
3104 :
3105 0 : appendStringInfoString(result,
3106 : map_sql_typecoll_to_xmlschema_types(tupdesc_list));
3107 :
3108 0 : appendStringInfoString(result,
3109 : map_sql_catalog_to_xmlschema_types(nspid_list, nulls, tableforest, targetns));
3110 :
3111 0 : xsd_schema_element_end(result);
3112 :
3113 0 : SPI_finish();
3114 :
3115 0 : return result;
3116 : }
3117 :
3118 :
3119 : Datum
3120 0 : database_to_xmlschema(PG_FUNCTION_ARGS)
3121 : {
3122 0 : bool nulls = PG_GETARG_BOOL(0);
3123 0 : bool tableforest = PG_GETARG_BOOL(1);
3124 0 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
3125 :
3126 0 : PG_RETURN_XML_P(stringinfo_to_xmltype(database_to_xmlschema_internal(nulls,
3127 : tableforest, targetns)));
3128 : }
3129 :
3130 :
3131 : Datum
3132 0 : database_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
3133 : {
3134 0 : bool nulls = PG_GETARG_BOOL(0);
3135 0 : bool tableforest = PG_GETARG_BOOL(1);
3136 0 : const char *targetns = text_to_cstring(PG_GETARG_TEXT_PP(2));
3137 : StringInfo xmlschema;
3138 :
3139 0 : xmlschema = database_to_xmlschema_internal(nulls, tableforest, targetns);
3140 :
3141 0 : PG_RETURN_XML_P(stringinfo_to_xmltype(database_to_xml_internal(xmlschema->data,
3142 : nulls, tableforest, targetns)));
3143 : }
3144 :
3145 :
3146 : /*
3147 : * Map a multi-part SQL name to an XML name; see SQL/XML:2008 section
3148 : * 9.2.
3149 : */
3150 : static char *
3151 256 : map_multipart_sql_identifier_to_xml_name(const char *a, const char *b, const char *c, const char *d)
3152 : {
3153 : StringInfoData result;
3154 :
3155 256 : initStringInfo(&result);
3156 :
3157 256 : if (a)
3158 256 : appendStringInfoString(&result,
3159 256 : map_sql_identifier_to_xml_name(a, true, true));
3160 256 : if (b)
3161 256 : appendStringInfo(&result, ".%s",
3162 : map_sql_identifier_to_xml_name(b, true, true));
3163 256 : if (c)
3164 256 : appendStringInfo(&result, ".%s",
3165 : map_sql_identifier_to_xml_name(c, true, true));
3166 256 : if (d)
3167 244 : appendStringInfo(&result, ".%s",
3168 : map_sql_identifier_to_xml_name(d, true, true));
3169 :
3170 256 : return result.data;
3171 : }
3172 :
3173 :
3174 : /*
3175 : * Map an SQL table to an XML Schema document; see SQL/XML:2008
3176 : * section 9.11.
3177 : *
3178 : * Map an SQL table to XML Schema data types; see SQL/XML:2008 section
3179 : * 9.9.
3180 : */
3181 : static const char *
3182 52 : map_sql_table_to_xmlschema(TupleDesc tupdesc, Oid relid, bool nulls,
3183 : bool tableforest, const char *targetns)
3184 : {
3185 : int i;
3186 : char *xmltn;
3187 : char *tabletypename;
3188 : char *rowtypename;
3189 : StringInfoData result;
3190 :
3191 52 : initStringInfo(&result);
3192 :
3193 52 : if (OidIsValid(relid))
3194 : {
3195 : HeapTuple tuple;
3196 : Form_pg_class reltuple;
3197 :
3198 36 : tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
3199 36 : if (!HeapTupleIsValid(tuple))
3200 0 : elog(ERROR, "cache lookup failed for relation %u", relid);
3201 36 : reltuple = (Form_pg_class) GETSTRUCT(tuple);
3202 :
3203 36 : xmltn = map_sql_identifier_to_xml_name(NameStr(reltuple->relname),
3204 : true, false);
3205 :
3206 72 : tabletypename = map_multipart_sql_identifier_to_xml_name("TableType",
3207 36 : get_database_name(MyDatabaseId),
3208 36 : get_namespace_name(reltuple->relnamespace),
3209 36 : NameStr(reltuple->relname));
3210 :
3211 72 : rowtypename = map_multipart_sql_identifier_to_xml_name("RowType",
3212 36 : get_database_name(MyDatabaseId),
3213 36 : get_namespace_name(reltuple->relnamespace),
3214 36 : NameStr(reltuple->relname));
3215 :
3216 36 : ReleaseSysCache(tuple);
3217 : }
3218 : else
3219 : {
3220 16 : if (tableforest)
3221 8 : xmltn = "row";
3222 : else
3223 8 : xmltn = "table";
3224 :
3225 16 : tabletypename = "TableType";
3226 16 : rowtypename = "RowType";
3227 : }
3228 :
3229 52 : xsd_schema_element_start(&result, targetns);
3230 :
3231 52 : appendStringInfoString(&result,
3232 : map_sql_typecoll_to_xmlschema_types(list_make1(tupdesc)));
3233 :
3234 52 : appendStringInfo(&result,
3235 : "<xsd:complexType name=\"%s\">\n"
3236 : " <xsd:sequence>\n",
3237 : rowtypename);
3238 :
3239 208 : for (i = 0; i < tupdesc->natts; i++)
3240 : {
3241 156 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3242 :
3243 156 : if (att->attisdropped)
3244 4 : continue;
3245 304 : appendStringInfo(&result,
3246 : " <xsd:element name=\"%s\" type=\"%s\"%s></xsd:element>\n",
3247 152 : map_sql_identifier_to_xml_name(NameStr(att->attname),
3248 : true, false),
3249 : map_sql_type_to_xml_name(att->atttypid, -1),
3250 : nulls ? " nillable=\"true\"" : " minOccurs=\"0\"");
3251 : }
3252 :
3253 52 : appendStringInfoString(&result,
3254 : " </xsd:sequence>\n"
3255 : "</xsd:complexType>\n\n");
3256 :
3257 52 : if (!tableforest)
3258 : {
3259 28 : appendStringInfo(&result,
3260 : "<xsd:complexType name=\"%s\">\n"
3261 : " <xsd:sequence>\n"
3262 : " <xsd:element name=\"row\" type=\"%s\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n"
3263 : " </xsd:sequence>\n"
3264 : "</xsd:complexType>\n\n",
3265 : tabletypename, rowtypename);
3266 :
3267 28 : appendStringInfo(&result,
3268 : "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3269 : xmltn, tabletypename);
3270 : }
3271 : else
3272 24 : appendStringInfo(&result,
3273 : "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3274 : xmltn, rowtypename);
3275 :
3276 52 : xsd_schema_element_end(&result);
3277 :
3278 52 : return result.data;
3279 : }
3280 :
3281 :
3282 : /*
3283 : * Map an SQL schema to XML Schema data types; see SQL/XML:2008
3284 : * section 9.12.
3285 : */
3286 : static const char *
3287 12 : map_sql_schema_to_xmlschema_types(Oid nspid, List *relid_list, bool nulls,
3288 : bool tableforest, const char *targetns)
3289 : {
3290 : char *dbname;
3291 : char *nspname;
3292 : char *xmlsn;
3293 : char *schematypename;
3294 : StringInfoData result;
3295 : ListCell *cell;
3296 :
3297 12 : dbname = get_database_name(MyDatabaseId);
3298 12 : nspname = get_namespace_name(nspid);
3299 :
3300 12 : initStringInfo(&result);
3301 :
3302 12 : xmlsn = map_sql_identifier_to_xml_name(nspname, true, false);
3303 :
3304 12 : schematypename = map_multipart_sql_identifier_to_xml_name("SchemaType",
3305 : dbname,
3306 : nspname,
3307 : NULL);
3308 :
3309 12 : appendStringInfo(&result,
3310 : "<xsd:complexType name=\"%s\">\n", schematypename);
3311 12 : if (!tableforest)
3312 4 : appendStringInfoString(&result,
3313 : " <xsd:all>\n");
3314 : else
3315 8 : appendStringInfoString(&result,
3316 : " <xsd:sequence>\n");
3317 :
3318 36 : foreach(cell, relid_list)
3319 : {
3320 24 : Oid relid = lfirst_oid(cell);
3321 24 : char *relname = get_rel_name(relid);
3322 24 : char *xmltn = map_sql_identifier_to_xml_name(relname, true, false);
3323 24 : char *tabletypename = map_multipart_sql_identifier_to_xml_name(tableforest ? "RowType" : "TableType",
3324 : dbname,
3325 : nspname,
3326 : relname);
3327 :
3328 24 : if (!tableforest)
3329 8 : appendStringInfo(&result,
3330 : " <xsd:element name=\"%s\" type=\"%s\"/>\n",
3331 : xmltn, tabletypename);
3332 : else
3333 16 : appendStringInfo(&result,
3334 : " <xsd:element name=\"%s\" type=\"%s\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n",
3335 : xmltn, tabletypename);
3336 : }
3337 :
3338 12 : if (!tableforest)
3339 4 : appendStringInfoString(&result,
3340 : " </xsd:all>\n");
3341 : else
3342 8 : appendStringInfoString(&result,
3343 : " </xsd:sequence>\n");
3344 12 : appendStringInfoString(&result,
3345 : "</xsd:complexType>\n\n");
3346 :
3347 12 : appendStringInfo(&result,
3348 : "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3349 : xmlsn, schematypename);
3350 :
3351 12 : return result.data;
3352 : }
3353 :
3354 :
3355 : /*
3356 : * Map an SQL catalog to XML Schema data types; see SQL/XML:2008
3357 : * section 9.15.
3358 : */
3359 : static const char *
3360 0 : map_sql_catalog_to_xmlschema_types(List *nspid_list, bool nulls,
3361 : bool tableforest, const char *targetns)
3362 : {
3363 : char *dbname;
3364 : char *xmlcn;
3365 : char *catalogtypename;
3366 : StringInfoData result;
3367 : ListCell *cell;
3368 :
3369 0 : dbname = get_database_name(MyDatabaseId);
3370 :
3371 0 : initStringInfo(&result);
3372 :
3373 0 : xmlcn = map_sql_identifier_to_xml_name(dbname, true, false);
3374 :
3375 0 : catalogtypename = map_multipart_sql_identifier_to_xml_name("CatalogType",
3376 : dbname,
3377 : NULL,
3378 : NULL);
3379 :
3380 0 : appendStringInfo(&result,
3381 : "<xsd:complexType name=\"%s\">\n", catalogtypename);
3382 0 : appendStringInfoString(&result,
3383 : " <xsd:all>\n");
3384 :
3385 0 : foreach(cell, nspid_list)
3386 : {
3387 0 : Oid nspid = lfirst_oid(cell);
3388 0 : char *nspname = get_namespace_name(nspid);
3389 0 : char *xmlsn = map_sql_identifier_to_xml_name(nspname, true, false);
3390 0 : char *schematypename = map_multipart_sql_identifier_to_xml_name("SchemaType",
3391 : dbname,
3392 : nspname,
3393 : NULL);
3394 :
3395 0 : appendStringInfo(&result,
3396 : " <xsd:element name=\"%s\" type=\"%s\"/>\n",
3397 : xmlsn, schematypename);
3398 : }
3399 :
3400 0 : appendStringInfoString(&result,
3401 : " </xsd:all>\n");
3402 0 : appendStringInfoString(&result,
3403 : "</xsd:complexType>\n\n");
3404 :
3405 0 : appendStringInfo(&result,
3406 : "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3407 : xmlcn, catalogtypename);
3408 :
3409 0 : return result.data;
3410 : }
3411 :
3412 :
3413 : /*
3414 : * Map an SQL data type to an XML name; see SQL/XML:2008 section 9.4.
3415 : */
3416 : static const char *
3417 500 : map_sql_type_to_xml_name(Oid typeoid, int typmod)
3418 : {
3419 : StringInfoData result;
3420 :
3421 500 : initStringInfo(&result);
3422 :
3423 500 : switch (typeoid)
3424 : {
3425 : case BPCHAROID:
3426 20 : if (typmod == -1)
3427 20 : appendStringInfoString(&result, "CHAR");
3428 : else
3429 0 : appendStringInfo(&result, "CHAR_%d", typmod - VARHDRSZ);
3430 20 : break;
3431 : case VARCHAROID:
3432 36 : if (typmod == -1)
3433 36 : appendStringInfoString(&result, "VARCHAR");
3434 : else
3435 0 : appendStringInfo(&result, "VARCHAR_%d", typmod - VARHDRSZ);
3436 36 : break;
3437 : case NUMERICOID:
3438 20 : if (typmod == -1)
3439 20 : appendStringInfoString(&result, "NUMERIC");
3440 : else
3441 0 : appendStringInfo(&result, "NUMERIC_%d_%d",
3442 0 : ((typmod - VARHDRSZ) >> 16) & 0xffff,
3443 0 : (typmod - VARHDRSZ) & 0xffff);
3444 20 : break;
3445 : case INT4OID:
3446 116 : appendStringInfoString(&result, "INTEGER");
3447 116 : break;
3448 : case INT2OID:
3449 20 : appendStringInfoString(&result, "SMALLINT");
3450 20 : break;
3451 : case INT8OID:
3452 20 : appendStringInfoString(&result, "BIGINT");
3453 20 : break;
3454 : case FLOAT4OID:
3455 20 : appendStringInfoString(&result, "REAL");
3456 20 : break;
3457 : case FLOAT8OID:
3458 0 : appendStringInfoString(&result, "DOUBLE");
3459 0 : break;
3460 : case BOOLOID:
3461 20 : appendStringInfoString(&result, "BOOLEAN");
3462 20 : break;
3463 : case TIMEOID:
3464 20 : if (typmod == -1)
3465 20 : appendStringInfoString(&result, "TIME");
3466 : else
3467 0 : appendStringInfo(&result, "TIME_%d", typmod);
3468 20 : break;
3469 : case TIMETZOID:
3470 0 : if (typmod == -1)
3471 0 : appendStringInfoString(&result, "TIME_WTZ");
3472 : else
3473 0 : appendStringInfo(&result, "TIME_WTZ_%d", typmod);
3474 0 : break;
3475 : case TIMESTAMPOID:
3476 20 : if (typmod == -1)
3477 20 : appendStringInfoString(&result, "TIMESTAMP");
3478 : else
3479 0 : appendStringInfo(&result, "TIMESTAMP_%d", typmod);
3480 20 : break;
3481 : case TIMESTAMPTZOID:
3482 0 : if (typmod == -1)
3483 0 : appendStringInfoString(&result, "TIMESTAMP_WTZ");
3484 : else
3485 0 : appendStringInfo(&result, "TIMESTAMP_WTZ_%d", typmod);
3486 0 : break;
3487 : case DATEOID:
3488 20 : appendStringInfoString(&result, "DATE");
3489 20 : break;
3490 : case XMLOID:
3491 20 : appendStringInfoString(&result, "XML");
3492 20 : break;
3493 : default:
3494 : {
3495 : HeapTuple tuple;
3496 : Form_pg_type typtuple;
3497 :
3498 148 : tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeoid));
3499 148 : if (!HeapTupleIsValid(tuple))
3500 0 : elog(ERROR, "cache lookup failed for type %u", typeoid);
3501 148 : typtuple = (Form_pg_type) GETSTRUCT(tuple);
3502 :
3503 148 : appendStringInfoString(&result,
3504 296 : map_multipart_sql_identifier_to_xml_name((typtuple->typtype == TYPTYPE_DOMAIN) ? "Domain" : "UDT",
3505 148 : get_database_name(MyDatabaseId),
3506 148 : get_namespace_name(typtuple->typnamespace),
3507 148 : NameStr(typtuple->typname)));
3508 :
3509 148 : ReleaseSysCache(tuple);
3510 : }
3511 : }
3512 :
3513 500 : return result.data;
3514 : }
3515 :
3516 :
3517 : /*
3518 : * Map a collection of SQL data types to XML Schema data types; see
3519 : * SQL/XML:2008 section 9.7.
3520 : */
3521 : static const char *
3522 64 : map_sql_typecoll_to_xmlschema_types(List *tupdesc_list)
3523 : {
3524 64 : List *uniquetypes = NIL;
3525 : int i;
3526 : StringInfoData result;
3527 : ListCell *cell0;
3528 :
3529 : /* extract all column types used in the set of TupleDescs */
3530 140 : foreach(cell0, tupdesc_list)
3531 : {
3532 76 : TupleDesc tupdesc = (TupleDesc) lfirst(cell0);
3533 :
3534 436 : for (i = 0; i < tupdesc->natts; i++)
3535 : {
3536 360 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
3537 :
3538 360 : if (att->attisdropped)
3539 16 : continue;
3540 344 : uniquetypes = list_append_unique_oid(uniquetypes, att->atttypid);
3541 : }
3542 : }
3543 :
3544 : /* add base types of domains */
3545 396 : foreach(cell0, uniquetypes)
3546 : {
3547 332 : Oid typid = lfirst_oid(cell0);
3548 332 : Oid basetypid = getBaseType(typid);
3549 :
3550 332 : if (basetypid != typid)
3551 16 : uniquetypes = list_append_unique_oid(uniquetypes, basetypid);
3552 : }
3553 :
3554 : /* Convert to textual form */
3555 64 : initStringInfo(&result);
3556 :
3557 396 : foreach(cell0, uniquetypes)
3558 : {
3559 332 : appendStringInfo(&result, "%s\n",
3560 : map_sql_type_to_xmlschema_type(lfirst_oid(cell0),
3561 : -1));
3562 : }
3563 :
3564 64 : return result.data;
3565 : }
3566 :
3567 :
3568 : /*
3569 : * Map an SQL data type to a named XML Schema data type; see
3570 : * SQL/XML:2008 sections 9.5 and 9.6.
3571 : *
3572 : * (The distinction between 9.5 and 9.6 is basically that 9.6 adds
3573 : * a name attribute, which this function does. The name-less version
3574 : * 9.5 doesn't appear to be required anywhere.)
3575 : */
3576 : static const char *
3577 332 : map_sql_type_to_xmlschema_type(Oid typeoid, int typmod)
3578 : {
3579 : StringInfoData result;
3580 332 : const char *typename = map_sql_type_to_xml_name(typeoid, typmod);
3581 :
3582 332 : initStringInfo(&result);
3583 :
3584 332 : if (typeoid == XMLOID)
3585 : {
3586 16 : appendStringInfoString(&result,
3587 : "<xsd:complexType mixed=\"true\">\n"
3588 : " <xsd:sequence>\n"
3589 : " <xsd:any name=\"element\" minOccurs=\"0\" maxOccurs=\"unbounded\" processContents=\"skip\"/>\n"
3590 : " </xsd:sequence>\n"
3591 : "</xsd:complexType>\n");
3592 : }
3593 : else
3594 : {
3595 316 : appendStringInfo(&result,
3596 : "<xsd:simpleType name=\"%s\">\n", typename);
3597 :
3598 316 : switch (typeoid)
3599 : {
3600 : case BPCHAROID:
3601 : case VARCHAROID:
3602 : case TEXTOID:
3603 92 : appendStringInfoString(&result,
3604 : " <xsd:restriction base=\"xsd:string\">\n");
3605 92 : if (typmod != -1)
3606 0 : appendStringInfo(&result,
3607 : " <xsd:maxLength value=\"%d\"/>\n",
3608 : typmod - VARHDRSZ);
3609 92 : appendStringInfoString(&result, " </xsd:restriction>\n");
3610 92 : break;
3611 :
3612 : case BYTEAOID:
3613 16 : appendStringInfo(&result,
3614 : " <xsd:restriction base=\"xsd:%s\">\n"
3615 : " </xsd:restriction>\n",
3616 16 : xmlbinary == XMLBINARY_BASE64 ? "base64Binary" : "hexBinary");
3617 16 : break;
3618 :
3619 : case NUMERICOID:
3620 16 : if (typmod != -1)
3621 0 : appendStringInfo(&result,
3622 : " <xsd:restriction base=\"xsd:decimal\">\n"
3623 : " <xsd:totalDigits value=\"%d\"/>\n"
3624 : " <xsd:fractionDigits value=\"%d\"/>\n"
3625 : " </xsd:restriction>\n",
3626 0 : ((typmod - VARHDRSZ) >> 16) & 0xffff,
3627 0 : (typmod - VARHDRSZ) & 0xffff);
3628 16 : break;
3629 :
3630 : case INT2OID:
3631 16 : appendStringInfo(&result,
3632 : " <xsd:restriction base=\"xsd:short\">\n"
3633 : " <xsd:maxInclusive value=\"%d\"/>\n"
3634 : " <xsd:minInclusive value=\"%d\"/>\n"
3635 : " </xsd:restriction>\n",
3636 : SHRT_MAX, SHRT_MIN);
3637 16 : break;
3638 :
3639 : case INT4OID:
3640 64 : appendStringInfo(&result,
3641 : " <xsd:restriction base=\"xsd:int\">\n"
3642 : " <xsd:maxInclusive value=\"%d\"/>\n"
3643 : " <xsd:minInclusive value=\"%d\"/>\n"
3644 : " </xsd:restriction>\n",
3645 : INT_MAX, INT_MIN);
3646 64 : break;
3647 :
3648 : case INT8OID:
3649 16 : appendStringInfo(&result,
3650 : " <xsd:restriction base=\"xsd:long\">\n"
3651 : " <xsd:maxInclusive value=\"" INT64_FORMAT "\"/>\n"
3652 : " <xsd:minInclusive value=\"" INT64_FORMAT "\"/>\n"
3653 : " </xsd:restriction>\n",
3654 : (((uint64) 1) << (sizeof(int64) * 8 - 1)) - 1,
3655 : (((uint64) 1) << (sizeof(int64) * 8 - 1)));
3656 16 : break;
3657 :
3658 : case FLOAT4OID:
3659 16 : appendStringInfoString(&result,
3660 : " <xsd:restriction base=\"xsd:float\"></xsd:restriction>\n");
3661 16 : break;
3662 :
3663 : case FLOAT8OID:
3664 0 : appendStringInfoString(&result,
3665 : " <xsd:restriction base=\"xsd:double\"></xsd:restriction>\n");
3666 0 : break;
3667 :
3668 : case BOOLOID:
3669 16 : appendStringInfoString(&result,
3670 : " <xsd:restriction base=\"xsd:boolean\"></xsd:restriction>\n");
3671 16 : break;
3672 :
3673 : case TIMEOID:
3674 : case TIMETZOID:
3675 : {
3676 16 : const char *tz = (typeoid == TIMETZOID ? "(+|-)\\p{Nd}{2}:\\p{Nd}{2}" : "");
3677 :
3678 16 : if (typmod == -1)
3679 16 : appendStringInfo(&result,
3680 : " <xsd:restriction base=\"xsd:time\">\n"
3681 : " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}(.\\p{Nd}+)?%s\"/>\n"
3682 : " </xsd:restriction>\n", tz);
3683 0 : else if (typmod == 0)
3684 0 : appendStringInfo(&result,
3685 : " <xsd:restriction base=\"xsd:time\">\n"
3686 : " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}%s\"/>\n"
3687 : " </xsd:restriction>\n", tz);
3688 : else
3689 0 : appendStringInfo(&result,
3690 : " <xsd:restriction base=\"xsd:time\">\n"
3691 : " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}.\\p{Nd}{%d}%s\"/>\n"
3692 : " </xsd:restriction>\n", typmod - VARHDRSZ, tz);
3693 16 : break;
3694 : }
3695 :
3696 : case TIMESTAMPOID:
3697 : case TIMESTAMPTZOID:
3698 : {
3699 16 : const char *tz = (typeoid == TIMESTAMPTZOID ? "(+|-)\\p{Nd}{2}:\\p{Nd}{2}" : "");
3700 :
3701 16 : if (typmod == -1)
3702 16 : appendStringInfo(&result,
3703 : " <xsd:restriction base=\"xsd:dateTime\">\n"
3704 : " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}T\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}(.\\p{Nd}+)?%s\"/>\n"
3705 : " </xsd:restriction>\n", tz);
3706 0 : else if (typmod == 0)
3707 0 : appendStringInfo(&result,
3708 : " <xsd:restriction base=\"xsd:dateTime\">\n"
3709 : " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}T\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}%s\"/>\n"
3710 : " </xsd:restriction>\n", tz);
3711 : else
3712 0 : appendStringInfo(&result,
3713 : " <xsd:restriction base=\"xsd:dateTime\">\n"
3714 : " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}T\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}.\\p{Nd}{%d}%s\"/>\n"
3715 : " </xsd:restriction>\n", typmod - VARHDRSZ, tz);
3716 16 : break;
3717 : }
3718 :
3719 : case DATEOID:
3720 16 : appendStringInfoString(&result,
3721 : " <xsd:restriction base=\"xsd:date\">\n"
3722 : " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}\"/>\n"
3723 : " </xsd:restriction>\n");
3724 16 : break;
3725 :
3726 : default:
3727 16 : if (get_typtype(typeoid) == TYPTYPE_DOMAIN)
3728 : {
3729 : Oid base_typeoid;
3730 16 : int32 base_typmod = -1;
3731 :
3732 16 : base_typeoid = getBaseTypeAndTypmod(typeoid, &base_typmod);
3733 :
3734 16 : appendStringInfo(&result,
3735 : " <xsd:restriction base=\"%s\"/>\n",
3736 : map_sql_type_to_xml_name(base_typeoid, base_typmod));
3737 : }
3738 16 : break;
3739 : }
3740 316 : appendStringInfoString(&result, "</xsd:simpleType>\n");
3741 : }
3742 :
3743 332 : return result.data;
3744 : }
3745 :
3746 :
3747 : /*
3748 : * Map an SQL row to an XML element, taking the row from the active
3749 : * SPI cursor. See also SQL/XML:2008 section 9.10.
3750 : */
3751 : static void
3752 212 : SPI_sql_row_to_xmlelement(uint64 rownum, StringInfo result, char *tablename,
3753 : bool nulls, bool tableforest,
3754 : const char *targetns, bool top_level)
3755 : {
3756 : int i;
3757 : char *xmltn;
3758 :
3759 212 : if (tablename)
3760 152 : xmltn = map_sql_identifier_to_xml_name(tablename, true, false);
3761 : else
3762 : {
3763 60 : if (tableforest)
3764 24 : xmltn = "row";
3765 : else
3766 36 : xmltn = "table";
3767 : }
3768 :
3769 212 : if (tableforest)
3770 108 : xmldata_root_element_start(result, xmltn, NULL, targetns, top_level);
3771 : else
3772 104 : appendStringInfoString(result, "<row>\n");
3773 :
3774 824 : for (i = 1; i <= SPI_tuptable->tupdesc->natts; i++)
3775 : {
3776 : char *colname;
3777 : Datum colval;
3778 : bool isnull;
3779 :
3780 612 : colname = map_sql_identifier_to_xml_name(SPI_fname(SPI_tuptable->tupdesc, i),
3781 : true, false);
3782 612 : colval = SPI_getbinval(SPI_tuptable->vals[rownum],
3783 612 : SPI_tuptable->tupdesc,
3784 : i,
3785 : &isnull);
3786 612 : if (isnull)
3787 : {
3788 76 : if (nulls)
3789 40 : appendStringInfo(result, " <%s xsi:nil=\"true\"/>\n", colname);
3790 : }
3791 : else
3792 536 : appendStringInfo(result, " <%s>%s</%s>\n",
3793 : colname,
3794 : map_sql_value_to_xml_value(colval,
3795 536 : SPI_gettypeid(SPI_tuptable->tupdesc, i), true),
3796 : colname);
3797 : }
3798 :
3799 212 : if (tableforest)
3800 : {
3801 108 : xmldata_root_element_end(result, xmltn);
3802 108 : appendStringInfoChar(result, '\n');
3803 : }
3804 : else
3805 104 : appendStringInfoString(result, "</row>\n\n");
3806 212 : }
3807 :
3808 :
3809 : /*
3810 : * XPath related functions
3811 : */
3812 :
3813 : #ifdef USE_LIBXML
3814 :
3815 : /*
3816 : * Convert XML node to text.
3817 : *
3818 : * For attribute and text nodes, return the escaped text. For anything else,
3819 : * dump the whole subtree.
3820 : */
3821 : static text *
3822 148 : xml_xmlnodetoxmltype(xmlNodePtr cur, PgXmlErrorContext *xmlerrcxt)
3823 : {
3824 : xmltype *result;
3825 :
3826 148 : if (cur->type != XML_ATTRIBUTE_NODE && cur->type != XML_TEXT_NODE)
3827 120 : {
3828 120 : void (*volatile nodefree) (xmlNodePtr) = NULL;
3829 120 : volatile xmlBufferPtr buf = NULL;
3830 120 : volatile xmlNodePtr cur_copy = NULL;
3831 :
3832 120 : PG_TRY();
3833 : {
3834 : int bytes;
3835 :
3836 120 : buf = xmlBufferCreate();
3837 120 : if (buf == NULL || xmlerrcxt->err_occurred)
3838 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
3839 : "could not allocate xmlBuffer");
3840 :
3841 : /*
3842 : * Produce a dump of the node that we can serialize. xmlNodeDump
3843 : * does that, but the result of that function won't contain
3844 : * namespace definitions from ancestor nodes, so we first do a
3845 : * xmlCopyNode() which duplicates the node along with its required
3846 : * namespace definitions.
3847 : *
3848 : * Some old libxml2 versions such as 2.7.6 produce partially
3849 : * broken XML_DOCUMENT_NODE nodes (unset content field) when
3850 : * copying them. xmlNodeDump of such a node works fine, but
3851 : * xmlFreeNode crashes; set us up to call xmlFreeDoc instead.
3852 : */
3853 120 : cur_copy = xmlCopyNode(cur, 1);
3854 120 : if (cur_copy == NULL || xmlerrcxt->err_occurred)
3855 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
3856 : "could not copy node");
3857 240 : nodefree = (cur_copy->type == XML_DOCUMENT_NODE) ?
3858 120 : (void (*) (xmlNodePtr)) xmlFreeDoc : xmlFreeNode;
3859 :
3860 120 : bytes = xmlNodeDump(buf, NULL, cur_copy, 0, 0);
3861 120 : if (bytes == -1 || xmlerrcxt->err_occurred)
3862 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
3863 : "could not dump node");
3864 :
3865 120 : result = xmlBuffer_to_xmltype(buf);
3866 : }
3867 0 : PG_CATCH();
3868 : {
3869 0 : if (nodefree)
3870 0 : nodefree(cur_copy);
3871 0 : if (buf)
3872 0 : xmlBufferFree(buf);
3873 0 : PG_RE_THROW();
3874 : }
3875 120 : PG_END_TRY();
3876 :
3877 120 : if (nodefree)
3878 120 : nodefree(cur_copy);
3879 120 : xmlBufferFree(buf);
3880 : }
3881 : else
3882 : {
3883 : xmlChar *str;
3884 :
3885 28 : str = xmlXPathCastNodeToString(cur);
3886 28 : PG_TRY();
3887 : {
3888 : /* Here we rely on XML having the same representation as TEXT */
3889 28 : char *escaped = escape_xml((char *) str);
3890 :
3891 28 : result = (xmltype *) cstring_to_text(escaped);
3892 28 : pfree(escaped);
3893 : }
3894 0 : PG_CATCH();
3895 : {
3896 0 : xmlFree(str);
3897 0 : PG_RE_THROW();
3898 : }
3899 28 : PG_END_TRY();
3900 28 : xmlFree(str);
3901 : }
3902 :
3903 148 : return result;
3904 : }
3905 :
3906 : /*
3907 : * Convert an XML XPath object (the result of evaluating an XPath expression)
3908 : * to an array of xml values, which are appended to astate. The function
3909 : * result value is the number of elements in the array.
3910 : *
3911 : * If "astate" is NULL then we don't generate the array value, but we still
3912 : * return the number of elements it would have had.
3913 : *
3914 : * Nodesets are converted to an array containing the nodes' textual
3915 : * representations. Primitive values (float, double, string) are converted
3916 : * to a single-element array containing the value's string representation.
3917 : */
3918 : static int
3919 360 : xml_xpathobjtoxmlarray(xmlXPathObjectPtr xpathobj,
3920 : ArrayBuildState *astate,
3921 : PgXmlErrorContext *xmlerrcxt)
3922 : {
3923 360 : int result = 0;
3924 : Datum datum;
3925 : Oid datumtype;
3926 : char *result_str;
3927 :
3928 360 : switch (xpathobj->type)
3929 : {
3930 : case XPATH_NODESET:
3931 332 : if (xpathobj->nodesetval != NULL)
3932 : {
3933 236 : result = xpathobj->nodesetval->nodeNr;
3934 236 : if (astate != NULL)
3935 : {
3936 : int i;
3937 :
3938 112 : for (i = 0; i < result; i++)
3939 : {
3940 60 : datum = PointerGetDatum(xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[i],
3941 : xmlerrcxt));
3942 60 : (void) accumArrayResult(astate, datum, false,
3943 : XMLOID, CurrentMemoryContext);
3944 : }
3945 : }
3946 : }
3947 332 : return result;
3948 :
3949 : case XPATH_BOOLEAN:
3950 8 : if (astate == NULL)
3951 0 : return 1;
3952 8 : datum = BoolGetDatum(xpathobj->boolval);
3953 8 : datumtype = BOOLOID;
3954 8 : break;
3955 :
3956 : case XPATH_NUMBER:
3957 12 : if (astate == NULL)
3958 8 : return 1;
3959 4 : datum = Float8GetDatum(xpathobj->floatval);
3960 4 : datumtype = FLOAT8OID;
3961 4 : break;
3962 :
3963 : case XPATH_STRING:
3964 8 : if (astate == NULL)
3965 0 : return 1;
3966 8 : datum = CStringGetDatum((char *) xpathobj->stringval);
3967 8 : datumtype = CSTRINGOID;
3968 8 : break;
3969 :
3970 : default:
3971 0 : elog(ERROR, "xpath expression result type %d is unsupported",
3972 : xpathobj->type);
3973 : return 0; /* keep compiler quiet */
3974 : }
3975 :
3976 : /* Common code for scalar-value cases */
3977 20 : result_str = map_sql_value_to_xml_value(datum, datumtype, true);
3978 20 : datum = PointerGetDatum(cstring_to_xmltype(result_str));
3979 20 : (void) accumArrayResult(astate, datum, false,
3980 : XMLOID, CurrentMemoryContext);
3981 20 : return 1;
3982 : }
3983 :
3984 :
3985 : /*
3986 : * Common code for xpath() and xmlexists()
3987 : *
3988 : * Evaluate XPath expression and return number of nodes in res_items
3989 : * and array of XML values in astate. Either of those pointers can be
3990 : * NULL if the corresponding result isn't wanted.
3991 : *
3992 : * It is up to the user to ensure that the XML passed is in fact
3993 : * an XML document - XPath doesn't work easily on fragments without
3994 : * a context node being known.
3995 : */
3996 : static void
3997 372 : xpath_internal(text *xpath_expr_text, xmltype *data, ArrayType *namespaces,
3998 : int *res_nitems, ArrayBuildState *astate)
3999 : {
4000 : PgXmlErrorContext *xmlerrcxt;
4001 372 : volatile xmlParserCtxtPtr ctxt = NULL;
4002 372 : volatile xmlDocPtr doc = NULL;
4003 372 : volatile xmlXPathContextPtr xpathctx = NULL;
4004 372 : volatile xmlXPathCompExprPtr xpathcomp = NULL;
4005 372 : volatile xmlXPathObjectPtr xpathobj = NULL;
4006 : char *datastr;
4007 : int32 len;
4008 : int32 xpath_len;
4009 : xmlChar *string;
4010 : xmlChar *xpath_expr;
4011 372 : size_t xmldecl_len = 0;
4012 : int i;
4013 : int ndim;
4014 : Datum *ns_names_uris;
4015 : bool *ns_names_uris_nulls;
4016 : int ns_count;
4017 :
4018 : /*
4019 : * Namespace mappings are passed as text[]. If an empty array is passed
4020 : * (ndim = 0, "0-dimensional"), then there are no namespace mappings.
4021 : * Else, a 2-dimensional array with length of the second axis being equal
4022 : * to 2 should be passed, i.e., every subarray contains 2 elements, the
4023 : * first element defining the name, the second one the URI. Example:
4024 : * ARRAY[ARRAY['myns', 'http://example.com'], ARRAY['myns2',
4025 : * 'http://example2.com']].
4026 : */
4027 372 : ndim = namespaces ? ARR_NDIM(namespaces) : 0;
4028 372 : if (ndim != 0)
4029 : {
4030 : int *dims;
4031 :
4032 84 : dims = ARR_DIMS(namespaces);
4033 :
4034 84 : if (ndim != 2 || dims[1] != 2)
4035 0 : ereport(ERROR,
4036 : (errcode(ERRCODE_DATA_EXCEPTION),
4037 : errmsg("invalid array for XML namespace mapping"),
4038 : errdetail("The array must be two-dimensional with length of the second axis equal to 2.")));
4039 :
4040 : Assert(ARR_ELEMTYPE(namespaces) == TEXTOID);
4041 :
4042 84 : deconstruct_array(namespaces, TEXTOID, -1, false, 'i',
4043 : &ns_names_uris, &ns_names_uris_nulls,
4044 : &ns_count);
4045 :
4046 : Assert((ns_count % 2) == 0); /* checked above */
4047 84 : ns_count /= 2; /* count pairs only */
4048 : }
4049 : else
4050 : {
4051 288 : ns_names_uris = NULL;
4052 288 : ns_names_uris_nulls = NULL;
4053 288 : ns_count = 0;
4054 : }
4055 :
4056 372 : datastr = VARDATA(data);
4057 372 : len = VARSIZE(data) - VARHDRSZ;
4058 372 : xpath_len = VARSIZE_ANY_EXHDR(xpath_expr_text);
4059 372 : if (xpath_len == 0)
4060 4 : ereport(ERROR,
4061 : (errcode(ERRCODE_DATA_EXCEPTION),
4062 : errmsg("empty XPath expression")));
4063 :
4064 368 : string = pg_xmlCharStrndup(datastr, len);
4065 368 : xpath_expr = pg_xmlCharStrndup(VARDATA_ANY(xpath_expr_text), xpath_len);
4066 :
4067 : /*
4068 : * In a UTF8 database, skip any xml declaration, which might assert
4069 : * another encoding. Ignore parse_xml_decl() failure, letting
4070 : * xmlCtxtReadMemory() report parse errors. Documentation disclaims
4071 : * xpath() support for non-ASCII data in non-UTF8 databases, so leave
4072 : * those scenarios bug-compatible with historical behavior.
4073 : */
4074 368 : if (GetDatabaseEncoding() == PG_UTF8)
4075 368 : parse_xml_decl(string, &xmldecl_len, NULL, NULL, NULL);
4076 :
4077 368 : xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
4078 :
4079 368 : PG_TRY();
4080 : {
4081 368 : xmlInitParser();
4082 :
4083 : /*
4084 : * redundant XML parsing (two parsings for the same value during one
4085 : * command execution are possible)
4086 : */
4087 368 : ctxt = xmlNewParserCtxt();
4088 368 : if (ctxt == NULL || xmlerrcxt->err_occurred)
4089 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
4090 : "could not allocate parser context");
4091 368 : doc = xmlCtxtReadMemory(ctxt, (char *) string + xmldecl_len,
4092 368 : len - xmldecl_len, NULL, NULL, 0);
4093 368 : if (doc == NULL || xmlerrcxt->err_occurred)
4094 8 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INVALID_XML_DOCUMENT,
4095 : "could not parse XML document");
4096 360 : xpathctx = xmlXPathNewContext(doc);
4097 360 : if (xpathctx == NULL || xmlerrcxt->err_occurred)
4098 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
4099 : "could not allocate XPath context");
4100 360 : xpathctx->node = (xmlNodePtr) doc;
4101 :
4102 : /* register namespaces, if any */
4103 360 : if (ns_count > 0)
4104 : {
4105 168 : for (i = 0; i < ns_count; i++)
4106 : {
4107 : char *ns_name;
4108 : char *ns_uri;
4109 :
4110 168 : if (ns_names_uris_nulls[i * 2] ||
4111 84 : ns_names_uris_nulls[i * 2 + 1])
4112 0 : ereport(ERROR,
4113 : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
4114 : errmsg("neither namespace name nor URI may be null")));
4115 84 : ns_name = TextDatumGetCString(ns_names_uris[i * 2]);
4116 84 : ns_uri = TextDatumGetCString(ns_names_uris[i * 2 + 1]);
4117 84 : if (xmlXPathRegisterNs(xpathctx,
4118 : (xmlChar *) ns_name,
4119 : (xmlChar *) ns_uri) != 0)
4120 0 : ereport(ERROR, /* is this an internal error??? */
4121 : (errmsg("could not register XML namespace with name \"%s\" and URI \"%s\"",
4122 : ns_name, ns_uri)));
4123 : }
4124 : }
4125 :
4126 360 : xpathcomp = xmlXPathCompile(xpath_expr);
4127 360 : if (xpathcomp == NULL || xmlerrcxt->err_occurred)
4128 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
4129 : "invalid XPath expression");
4130 :
4131 : /*
4132 : * Version 2.6.27 introduces a function named
4133 : * xmlXPathCompiledEvalToBoolean, which would be enough for xmlexists,
4134 : * but we can derive the existence by whether any nodes are returned,
4135 : * thereby preventing a library version upgrade and keeping the code
4136 : * the same.
4137 : */
4138 360 : xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx);
4139 360 : if (xpathobj == NULL || xmlerrcxt->err_occurred)
4140 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
4141 : "could not create XPath object");
4142 :
4143 : /*
4144 : * Extract the results as requested.
4145 : */
4146 360 : if (res_nitems != NULL)
4147 288 : *res_nitems = xml_xpathobjtoxmlarray(xpathobj, astate, xmlerrcxt);
4148 : else
4149 72 : (void) xml_xpathobjtoxmlarray(xpathobj, astate, xmlerrcxt);
4150 : }
4151 8 : PG_CATCH();
4152 : {
4153 8 : if (xpathobj)
4154 0 : xmlXPathFreeObject(xpathobj);
4155 8 : if (xpathcomp)
4156 0 : xmlXPathFreeCompExpr(xpathcomp);
4157 8 : if (xpathctx)
4158 0 : xmlXPathFreeContext(xpathctx);
4159 8 : if (doc)
4160 8 : xmlFreeDoc(doc);
4161 8 : if (ctxt)
4162 8 : xmlFreeParserCtxt(ctxt);
4163 :
4164 8 : pg_xml_done(xmlerrcxt, true);
4165 :
4166 8 : PG_RE_THROW();
4167 : }
4168 360 : PG_END_TRY();
4169 :
4170 360 : xmlXPathFreeObject(xpathobj);
4171 360 : xmlXPathFreeCompExpr(xpathcomp);
4172 360 : xmlXPathFreeContext(xpathctx);
4173 360 : xmlFreeDoc(doc);
4174 360 : xmlFreeParserCtxt(ctxt);
4175 :
4176 360 : pg_xml_done(xmlerrcxt, false);
4177 360 : }
4178 : #endif /* USE_LIBXML */
4179 :
4180 : /*
4181 : * Evaluate XPath expression and return array of XML values.
4182 : *
4183 : * As we have no support of XQuery sequences yet, this function seems
4184 : * to be the most useful one (array of XML functions plays a role of
4185 : * some kind of substitution for XQuery sequences).
4186 : */
4187 : Datum
4188 84 : xpath(PG_FUNCTION_ARGS)
4189 : {
4190 : #ifdef USE_LIBXML
4191 84 : text *xpath_expr_text = PG_GETARG_TEXT_PP(0);
4192 84 : xmltype *data = PG_GETARG_XML_P(1);
4193 84 : ArrayType *namespaces = PG_GETARG_ARRAYTYPE_P(2);
4194 : ArrayBuildState *astate;
4195 :
4196 84 : astate = initArrayResult(XMLOID, CurrentMemoryContext, true);
4197 84 : xpath_internal(xpath_expr_text, data, namespaces,
4198 : NULL, astate);
4199 72 : PG_RETURN_ARRAYTYPE_P(makeArrayResult(astate, CurrentMemoryContext));
4200 : #else
4201 : NO_XML_SUPPORT();
4202 : return 0;
4203 : #endif
4204 : }
4205 :
4206 : /*
4207 : * Determines if the node specified by the supplied XPath exists
4208 : * in a given XML document, returning a boolean.
4209 : */
4210 : Datum
4211 132 : xmlexists(PG_FUNCTION_ARGS)
4212 : {
4213 : #ifdef USE_LIBXML
4214 132 : text *xpath_expr_text = PG_GETARG_TEXT_PP(0);
4215 132 : xmltype *data = PG_GETARG_XML_P(1);
4216 : int res_nitems;
4217 :
4218 132 : xpath_internal(xpath_expr_text, data, NULL,
4219 : &res_nitems, NULL);
4220 :
4221 132 : PG_RETURN_BOOL(res_nitems > 0);
4222 : #else
4223 : NO_XML_SUPPORT();
4224 : return 0;
4225 : #endif
4226 : }
4227 :
4228 : /*
4229 : * Determines if the node specified by the supplied XPath exists
4230 : * in a given XML document, returning a boolean. Differs from
4231 : * xmlexists as it supports namespaces and is not defined in SQL/XML.
4232 : */
4233 : Datum
4234 156 : xpath_exists(PG_FUNCTION_ARGS)
4235 : {
4236 : #ifdef USE_LIBXML
4237 156 : text *xpath_expr_text = PG_GETARG_TEXT_PP(0);
4238 156 : xmltype *data = PG_GETARG_XML_P(1);
4239 156 : ArrayType *namespaces = PG_GETARG_ARRAYTYPE_P(2);
4240 : int res_nitems;
4241 :
4242 156 : xpath_internal(xpath_expr_text, data, namespaces,
4243 : &res_nitems, NULL);
4244 :
4245 156 : PG_RETURN_BOOL(res_nitems > 0);
4246 : #else
4247 : NO_XML_SUPPORT();
4248 : return 0;
4249 : #endif
4250 : }
4251 :
4252 : /*
4253 : * Functions for checking well-formed-ness
4254 : */
4255 :
4256 : #ifdef USE_LIBXML
4257 : static bool
4258 76 : wellformed_xml(text *data, XmlOptionType xmloption_arg)
4259 : {
4260 : bool result;
4261 76 : volatile xmlDocPtr doc = NULL;
4262 :
4263 : /* We want to catch any exceptions and return false */
4264 76 : PG_TRY();
4265 : {
4266 76 : doc = xml_parse(data, xmloption_arg, true, GetDatabaseEncoding());
4267 40 : result = true;
4268 : }
4269 36 : PG_CATCH();
4270 : {
4271 36 : FlushErrorState();
4272 36 : result = false;
4273 : }
4274 76 : PG_END_TRY();
4275 :
4276 76 : if (doc)
4277 40 : xmlFreeDoc(doc);
4278 :
4279 76 : return result;
4280 : }
4281 : #endif
4282 :
4283 : Datum
4284 60 : xml_is_well_formed(PG_FUNCTION_ARGS)
4285 : {
4286 : #ifdef USE_LIBXML
4287 60 : text *data = PG_GETARG_TEXT_PP(0);
4288 :
4289 60 : PG_RETURN_BOOL(wellformed_xml(data, xmloption));
4290 : #else
4291 : NO_XML_SUPPORT();
4292 : return 0;
4293 : #endif /* not USE_LIBXML */
4294 : }
4295 :
4296 : Datum
4297 8 : xml_is_well_formed_document(PG_FUNCTION_ARGS)
4298 : {
4299 : #ifdef USE_LIBXML
4300 8 : text *data = PG_GETARG_TEXT_PP(0);
4301 :
4302 8 : PG_RETURN_BOOL(wellformed_xml(data, XMLOPTION_DOCUMENT));
4303 : #else
4304 : NO_XML_SUPPORT();
4305 : return 0;
4306 : #endif /* not USE_LIBXML */
4307 : }
4308 :
4309 : Datum
4310 8 : xml_is_well_formed_content(PG_FUNCTION_ARGS)
4311 : {
4312 : #ifdef USE_LIBXML
4313 8 : text *data = PG_GETARG_TEXT_PP(0);
4314 :
4315 8 : PG_RETURN_BOOL(wellformed_xml(data, XMLOPTION_CONTENT));
4316 : #else
4317 : NO_XML_SUPPORT();
4318 : return 0;
4319 : #endif /* not USE_LIBXML */
4320 : }
4321 :
4322 : /*
4323 : * support functions for XMLTABLE
4324 : *
4325 : */
4326 : #ifdef USE_LIBXML
4327 :
4328 : /*
4329 : * Returns private data from executor state. Ensure validity by check with
4330 : * MAGIC number.
4331 : */
4332 : static inline XmlTableBuilderData *
4333 92520 : GetXmlTableBuilderPrivateData(TableFuncScanState *state, const char *fname)
4334 : {
4335 : XmlTableBuilderData *result;
4336 :
4337 92520 : if (!IsA(state, TableFuncScanState))
4338 0 : elog(ERROR, "%s called with invalid TableFuncScanState", fname);
4339 92520 : result = (XmlTableBuilderData *) state->opaque;
4340 92520 : if (result->magic != XMLTABLE_CONTEXT_MAGIC)
4341 0 : elog(ERROR, "%s called with invalid TableFuncScanState", fname);
4342 :
4343 92520 : return result;
4344 : }
4345 : #endif
4346 :
4347 : /*
4348 : * XmlTableInitOpaque
4349 : * Fill in TableFuncScanState->opaque for XmlTable processor; initialize
4350 : * the XML parser.
4351 : *
4352 : * Note: Because we call pg_xml_init() here and pg_xml_done() in
4353 : * XmlTableDestroyOpaque, it is critical for robustness that no other
4354 : * executor nodes run until this node is processed to completion. Caller
4355 : * must execute this to completion (probably filling a tuplestore to exhaust
4356 : * this node in a single pass) instead of using row-per-call mode.
4357 : */
4358 : static void
4359 172 : XmlTableInitOpaque(TableFuncScanState *state, int natts)
4360 : {
4361 : #ifdef USE_LIBXML
4362 172 : volatile xmlParserCtxtPtr ctxt = NULL;
4363 : XmlTableBuilderData *xtCxt;
4364 : PgXmlErrorContext *xmlerrcxt;
4365 :
4366 172 : xtCxt = palloc0(sizeof(XmlTableBuilderData));
4367 172 : xtCxt->magic = XMLTABLE_CONTEXT_MAGIC;
4368 172 : xtCxt->natts = natts;
4369 172 : xtCxt->xpathscomp = palloc0(sizeof(xmlXPathCompExprPtr) * natts);
4370 :
4371 172 : xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
4372 :
4373 172 : PG_TRY();
4374 : {
4375 172 : xmlInitParser();
4376 :
4377 172 : ctxt = xmlNewParserCtxt();
4378 172 : if (ctxt == NULL || xmlerrcxt->err_occurred)
4379 0 : xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
4380 : "could not allocate parser context");
4381 : }
4382 0 : PG_CATCH();
4383 : {
4384 0 : if (ctxt != NULL)
4385 0 : xmlFreeParserCtxt(ctxt);
4386 :
4387 0 : pg_xml_done(xmlerrcxt, true);
4388 :
4389 0 : PG_RE_THROW();
4390 : }
4391 172 : PG_END_TRY();
4392 :
4393 172 : xtCxt->xmlerrcxt = xmlerrcxt;
4394 172 : xtCxt->ctxt = ctxt;
4395 :
4396 172 : state->opaque = xtCxt;
4397 : #else
4398 : NO_XML_SUPPORT();
4399 : #endif /* not USE_LIBXML */
4400 172 : }
4401 :
4402 : /*
4403 : * XmlTableSetDocument
4404 : * Install the input document
4405 : */
4406 : static void
4407 172 : XmlTableSetDocument(TableFuncScanState *state, Datum value)
4408 : {
4409 : #ifdef USE_LIBXML
4410 : XmlTableBuilderData *xtCxt;
4411 172 : xmltype *xmlval = DatumGetXmlP(value);
4412 : char *str;
4413 : xmlChar *xstr;
4414 : int length;
4415 172 : volatile xmlDocPtr doc = NULL;
4416 172 : volatile xmlXPathContextPtr xpathcxt = NULL;
4417 :
4418 172 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableSetDocument");
4419 :
4420 : /*
4421 : * Use out function for casting to string (remove encoding property). See
4422 : * comment in xml_out.
4423 : */
4424 172 : str = xml_out_internal(xmlval, 0);
4425 :
4426 172 : length = strlen(str);
4427 172 : xstr = pg_xmlCharStrndup(str, length);
4428 :
4429 172 : PG_TRY();
4430 : {
4431 172 : doc = xmlCtxtReadMemory(xtCxt->ctxt, (char *) xstr, length, NULL, NULL, 0);
4432 172 : if (doc == NULL || xtCxt->xmlerrcxt->err_occurred)
4433 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_INVALID_XML_DOCUMENT,
4434 : "could not parse XML document");
4435 172 : xpathcxt = xmlXPathNewContext(doc);
4436 172 : if (xpathcxt == NULL || xtCxt->xmlerrcxt->err_occurred)
4437 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
4438 : "could not allocate XPath context");
4439 172 : xpathcxt->node = (xmlNodePtr) doc;
4440 : }
4441 0 : PG_CATCH();
4442 : {
4443 0 : if (xpathcxt != NULL)
4444 0 : xmlXPathFreeContext(xpathcxt);
4445 0 : if (doc != NULL)
4446 0 : xmlFreeDoc(doc);
4447 :
4448 0 : PG_RE_THROW();
4449 : }
4450 172 : PG_END_TRY();
4451 :
4452 172 : xtCxt->doc = doc;
4453 172 : xtCxt->xpathcxt = xpathcxt;
4454 : #else
4455 : NO_XML_SUPPORT();
4456 : #endif /* not USE_LIBXML */
4457 172 : }
4458 :
4459 : /*
4460 : * XmlTableSetNamespace
4461 : * Add a namespace declaration
4462 : */
4463 : static void
4464 12 : XmlTableSetNamespace(TableFuncScanState *state, const char *name, const char *uri)
4465 : {
4466 : #ifdef USE_LIBXML
4467 : XmlTableBuilderData *xtCxt;
4468 :
4469 12 : if (name == NULL)
4470 4 : ereport(ERROR,
4471 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4472 : errmsg("DEFAULT namespace is not supported")));
4473 8 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableSetNamespace");
4474 :
4475 8 : if (xmlXPathRegisterNs(xtCxt->xpathcxt,
4476 8 : pg_xmlCharStrndup(name, strlen(name)),
4477 8 : pg_xmlCharStrndup(uri, strlen(uri))))
4478 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_DATA_EXCEPTION,
4479 : "could not set XML namespace");
4480 : #else
4481 : NO_XML_SUPPORT();
4482 : #endif /* not USE_LIBXML */
4483 8 : }
4484 :
4485 : /*
4486 : * XmlTableSetRowFilter
4487 : * Install the row-filter Xpath expression.
4488 : */
4489 : static void
4490 168 : XmlTableSetRowFilter(TableFuncScanState *state, const char *path)
4491 : {
4492 : #ifdef USE_LIBXML
4493 : XmlTableBuilderData *xtCxt;
4494 : xmlChar *xstr;
4495 :
4496 168 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableSetRowFilter");
4497 :
4498 168 : if (*path == '\0')
4499 0 : ereport(ERROR,
4500 : (errcode(ERRCODE_DATA_EXCEPTION),
4501 : errmsg("row path filter must not be empty string")));
4502 :
4503 168 : xstr = pg_xmlCharStrndup(path, strlen(path));
4504 :
4505 168 : xtCxt->xpathcomp = xmlXPathCompile(xstr);
4506 168 : if (xtCxt->xpathcomp == NULL || xtCxt->xmlerrcxt->err_occurred)
4507 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_SYNTAX_ERROR,
4508 : "invalid XPath expression");
4509 : #else
4510 : NO_XML_SUPPORT();
4511 : #endif /* not USE_LIBXML */
4512 168 : }
4513 :
4514 : /*
4515 : * XmlTableSetColumnFilter
4516 : * Install the column-filter Xpath expression, for the given column.
4517 : */
4518 : static void
4519 512 : XmlTableSetColumnFilter(TableFuncScanState *state, const char *path, int colnum)
4520 : {
4521 : #ifdef USE_LIBXML
4522 : XmlTableBuilderData *xtCxt;
4523 : xmlChar *xstr;
4524 :
4525 : AssertArg(PointerIsValid(path));
4526 :
4527 512 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableSetColumnFilter");
4528 :
4529 512 : if (*path == '\0')
4530 0 : ereport(ERROR,
4531 : (errcode(ERRCODE_DATA_EXCEPTION),
4532 : errmsg("column path filter must not be empty string")));
4533 :
4534 512 : xstr = pg_xmlCharStrndup(path, strlen(path));
4535 :
4536 512 : xtCxt->xpathscomp[colnum] = xmlXPathCompile(xstr);
4537 512 : if (xtCxt->xpathscomp[colnum] == NULL || xtCxt->xmlerrcxt->err_occurred)
4538 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_DATA_EXCEPTION,
4539 : "invalid XPath expression");
4540 : #else
4541 : NO_XML_SUPPORT();
4542 : #endif /* not USE_LIBXML */
4543 512 : }
4544 :
4545 : /*
4546 : * XmlTableFetchRow
4547 : * Prepare the next "current" tuple for upcoming GetValue calls.
4548 : * Returns false if the row-filter expression returned no more rows.
4549 : */
4550 : static bool
4551 13304 : XmlTableFetchRow(TableFuncScanState *state)
4552 : {
4553 : #ifdef USE_LIBXML
4554 : XmlTableBuilderData *xtCxt;
4555 :
4556 13304 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableFetchRow");
4557 :
4558 : /*
4559 : * XmlTable returns table - set of composite values. The error context, is
4560 : * used for producement more values, between two calls, there can be
4561 : * created and used another libxml2 error context. It is libxml2 global
4562 : * value, so it should be refreshed any time before any libxml2 usage,
4563 : * that is finished by returning some value.
4564 : */
4565 13304 : xmlSetStructuredErrorFunc((void *) xtCxt->xmlerrcxt, xml_errorHandler);
4566 :
4567 13304 : if (xtCxt->xpathobj == NULL)
4568 : {
4569 168 : xtCxt->xpathobj = xmlXPathCompiledEval(xtCxt->xpathcomp, xtCxt->xpathcxt);
4570 168 : if (xtCxt->xpathobj == NULL || xtCxt->xmlerrcxt->err_occurred)
4571 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
4572 : "could not create XPath object");
4573 :
4574 168 : xtCxt->row_count = 0;
4575 : }
4576 :
4577 13304 : if (xtCxt->xpathobj->type == XPATH_NODESET)
4578 : {
4579 13304 : if (xtCxt->xpathobj->nodesetval != NULL)
4580 : {
4581 13304 : if (xtCxt->row_count++ < xtCxt->xpathobj->nodesetval->nodeNr)
4582 13144 : return true;
4583 : }
4584 : }
4585 :
4586 160 : return false;
4587 : #else
4588 : NO_XML_SUPPORT();
4589 : return false;
4590 : #endif /* not USE_LIBXML */
4591 : }
4592 :
4593 : /*
4594 : * XmlTableGetValue
4595 : * Return the value for column number 'colnum' for the current row. If
4596 : * column -1 is requested, return representation of the whole row.
4597 : *
4598 : * This leaks memory, so be sure to reset often the context in which it's
4599 : * called.
4600 : */
4601 : static Datum
4602 78184 : XmlTableGetValue(TableFuncScanState *state, int colnum,
4603 : Oid typid, int32 typmod, bool *isnull)
4604 : {
4605 : #ifdef USE_LIBXML
4606 : XmlTableBuilderData *xtCxt;
4607 78184 : Datum result = (Datum) 0;
4608 : xmlNodePtr cur;
4609 78184 : char *cstr = NULL;
4610 78184 : volatile xmlXPathObjectPtr xpathobj = NULL;
4611 :
4612 78184 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableGetValue");
4613 :
4614 : Assert(xtCxt->xpathobj &&
4615 : xtCxt->xpathobj->type == XPATH_NODESET &&
4616 : xtCxt->xpathobj->nodesetval != NULL);
4617 :
4618 : /* Propagate context related error context to libxml2 */
4619 78184 : xmlSetStructuredErrorFunc((void *) xtCxt->xmlerrcxt, xml_errorHandler);
4620 :
4621 78184 : *isnull = false;
4622 :
4623 78184 : cur = xtCxt->xpathobj->nodesetval->nodeTab[xtCxt->row_count - 1];
4624 :
4625 : Assert(xtCxt->xpathscomp[colnum] != NULL);
4626 :
4627 78184 : PG_TRY();
4628 : {
4629 : /* Set current node as entry point for XPath evaluation */
4630 78184 : xtCxt->xpathcxt->node = cur;
4631 :
4632 : /* Evaluate column path */
4633 78184 : xpathobj = xmlXPathCompiledEval(xtCxt->xpathscomp[colnum], xtCxt->xpathcxt);
4634 78184 : if (xpathobj == NULL || xtCxt->xmlerrcxt->err_occurred)
4635 0 : xml_ereport(xtCxt->xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
4636 : "could not create XPath object");
4637 :
4638 : /*
4639 : * There are four possible cases, depending on the number of nodes
4640 : * returned by the XPath expression and the type of the target column:
4641 : * a) XPath returns no nodes. b) The target type is XML (return all
4642 : * as XML). For non-XML return types: c) One node (return content).
4643 : * d) Multiple nodes (error).
4644 : */
4645 78184 : if (xpathobj->type == XPATH_NODESET)
4646 : {
4647 78164 : int count = 0;
4648 :
4649 78164 : if (xpathobj->nodesetval != NULL)
4650 78024 : count = xpathobj->nodesetval->nodeNr;
4651 :
4652 78164 : if (xpathobj->nodesetval == NULL || count == 0)
4653 : {
4654 13368 : *isnull = true;
4655 : }
4656 : else
4657 : {
4658 64796 : if (typid == XMLOID)
4659 : {
4660 : text *textstr;
4661 : StringInfoData str;
4662 :
4663 : /* Concatenate serialized values */
4664 48 : initStringInfo(&str);
4665 136 : for (int i = 0; i < count; i++)
4666 : {
4667 88 : textstr =
4668 88 : xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[i],
4669 : xtCxt->xmlerrcxt);
4670 :
4671 88 : appendStringInfoText(&str, textstr);
4672 : }
4673 48 : cstr = str.data;
4674 : }
4675 : else
4676 : {
4677 : xmlChar *str;
4678 :
4679 64748 : if (count > 1)
4680 4 : ereport(ERROR,
4681 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
4682 : errmsg("more than one value returned by column XPath expression")));
4683 :
4684 64744 : str = xmlXPathCastNodeSetToString(xpathobj->nodesetval);
4685 64744 : cstr = str ? xml_pstrdup_and_free(str) : "";
4686 : }
4687 : }
4688 : }
4689 20 : else if (xpathobj->type == XPATH_STRING)
4690 : {
4691 : /* Content should be escaped when target will be XML */
4692 12 : if (typid == XMLOID)
4693 4 : cstr = escape_xml((char *) xpathobj->stringval);
4694 : else
4695 8 : cstr = (char *) xpathobj->stringval;
4696 : }
4697 8 : else if (xpathobj->type == XPATH_BOOLEAN)
4698 : {
4699 : char typcategory;
4700 : bool typispreferred;
4701 : xmlChar *str;
4702 :
4703 : /* Allow implicit casting from boolean to numbers */
4704 4 : get_type_category_preferred(typid, &typcategory, &typispreferred);
4705 :
4706 4 : if (typcategory != TYPCATEGORY_NUMERIC)
4707 4 : str = xmlXPathCastBooleanToString(xpathobj->boolval);
4708 : else
4709 0 : str = xmlXPathCastNumberToString(xmlXPathCastBooleanToNumber(xpathobj->boolval));
4710 :
4711 4 : cstr = xml_pstrdup_and_free(str);
4712 : }
4713 4 : else if (xpathobj->type == XPATH_NUMBER)
4714 : {
4715 : xmlChar *str;
4716 :
4717 4 : str = xmlXPathCastNumberToString(xpathobj->floatval);
4718 4 : cstr = xml_pstrdup_and_free(str);
4719 : }
4720 : else
4721 0 : elog(ERROR, "unexpected XPath object type %u", xpathobj->type);
4722 :
4723 : /*
4724 : * By here, either cstr contains the result value, or the isnull flag
4725 : * has been set.
4726 : */
4727 : Assert(cstr || *isnull);
4728 :
4729 78180 : if (!*isnull)
4730 64812 : result = InputFunctionCall(&state->in_functions[colnum],
4731 : cstr,
4732 64812 : state->typioparams[colnum],
4733 : typmod);
4734 : }
4735 4 : PG_CATCH();
4736 : {
4737 4 : if (xpathobj != NULL)
4738 4 : xmlXPathFreeObject(xpathobj);
4739 4 : PG_RE_THROW();
4740 : }
4741 78180 : PG_END_TRY();
4742 :
4743 78180 : xmlXPathFreeObject(xpathobj);
4744 :
4745 78180 : return result;
4746 : #else
4747 : NO_XML_SUPPORT();
4748 : return 0;
4749 : #endif /* not USE_LIBXML */
4750 : }
4751 :
4752 : /*
4753 : * XmlTableDestroyOpaque
4754 : * Release all libxml2 resources
4755 : */
4756 : static void
4757 172 : XmlTableDestroyOpaque(TableFuncScanState *state)
4758 : {
4759 : #ifdef USE_LIBXML
4760 : XmlTableBuilderData *xtCxt;
4761 :
4762 172 : xtCxt = GetXmlTableBuilderPrivateData(state, "XmlTableDestroyOpaque");
4763 :
4764 : /* Propagate context related error context to libxml2 */
4765 172 : xmlSetStructuredErrorFunc((void *) xtCxt->xmlerrcxt, xml_errorHandler);
4766 :
4767 172 : if (xtCxt->xpathscomp != NULL)
4768 : {
4769 : int i;
4770 :
4771 736 : for (i = 0; i < xtCxt->natts; i++)
4772 564 : if (xtCxt->xpathscomp[i] != NULL)
4773 512 : xmlXPathFreeCompExpr(xtCxt->xpathscomp[i]);
4774 : }
4775 :
4776 172 : if (xtCxt->xpathobj != NULL)
4777 168 : xmlXPathFreeObject(xtCxt->xpathobj);
4778 172 : if (xtCxt->xpathcomp != NULL)
4779 168 : xmlXPathFreeCompExpr(xtCxt->xpathcomp);
4780 172 : if (xtCxt->xpathcxt != NULL)
4781 172 : xmlXPathFreeContext(xtCxt->xpathcxt);
4782 172 : if (xtCxt->doc != NULL)
4783 172 : xmlFreeDoc(xtCxt->doc);
4784 172 : if (xtCxt->ctxt != NULL)
4785 172 : xmlFreeParserCtxt(xtCxt->ctxt);
4786 :
4787 172 : pg_xml_done(xtCxt->xmlerrcxt, true);
4788 :
4789 : /* not valid anymore */
4790 172 : xtCxt->magic = 0;
4791 172 : state->opaque = NULL;
4792 :
4793 : #else
4794 : NO_XML_SUPPORT();
4795 : #endif /* not USE_LIBXML */
4796 172 : }
|
