49 #include <libxml/chvalid.h>
50 #include <libxml/entities.h>
51 #include <libxml/parser.h>
52 #include <libxml/parserInternals.h>
53 #include <libxml/tree.h>
54 #include <libxml/uri.h>
55 #include <libxml/xmlerror.h>
56 #include <libxml/xmlsave.h>
57 #include <libxml/xmlversion.h>
58 #include <libxml/xmlwriter.h>
59 #include <libxml/xpath.h>
60 #include <libxml/xpathInternals.h>
67 #if LIBXML_VERSION >= 20704
68 #define HAVE_XMLSTRUCTUREDERRORCONTEXT 1
74 #if LIBXML_VERSION >= 21200
75 #define PgXmlErrorPtr const xmlError *
77 #define PgXmlErrorPtr xmlErrorPtr
115 #define ERRCXT_MAGIC 68275028
126 xmlStructuredErrorFunc saved_errfunc;
129 xmlExternalEntityLoader saved_entityfunc;
132 static xmlParserInputPtr xmlPgEntityLoader(
const char *URL,
const char *ID,
133 xmlParserCtxtPtr ctxt);
135 int sqlcode,
const char *msg);
136 static void xml_errorHandler(
void *
data, PgXmlErrorPtr
error);
137 static int errdetail_for_xml_code(
int code);
141 #ifdef USE_LIBXMLCONTEXT
145 static void xml_memory_init(
void);
146 static void *xml_palloc(
size_t size);
147 static void *xml_repalloc(
void *ptr,
size_t size);
148 static void xml_pfree(
void *ptr);
149 static char *xml_pstrdup(
const char *
string);
152 static xmlChar *xml_text2xmlChar(
text *in);
153 static int parse_xml_decl(
const xmlChar *
str,
size_t *lenp,
154 xmlChar **version, xmlChar **
encoding,
int *standalone);
155 static bool print_xml_decl(
StringInfo buf,
const xmlChar *version,
157 static bool xml_doctype_in_content(
const xmlChar *
str);
159 bool preserve_whitespace,
int encoding,
161 xmlNodePtr *parsed_nodes,
164 static int xml_xpathobjtoxmlarray(xmlXPathObjectPtr xpathobj,
167 static xmlChar *pg_xmlCharStrndup(
const char *
str,
size_t len);
171 const char *xmlschema,
const char *targetns,
175 const char *xmlschema,
bool nulls,
bool tableforest,
176 const char *targetns,
bool top_level);
178 bool nulls,
bool tableforest,
const char *targetns);
180 List *relid_list,
bool nulls,
181 bool tableforest,
const char *targetns);
183 bool nulls,
bool tableforest,
184 const char *targetns);
189 char *tablename,
bool nulls,
bool tableforest,
190 const char *targetns,
bool top_level);
195 #define XMLTABLE_CONTEXT_MAGIC 46922182
196 typedef struct XmlTableBuilderData
202 xmlParserCtxtPtr ctxt;
204 xmlXPathContextPtr xpathcxt;
205 xmlXPathCompExprPtr xpathcomp;
206 xmlXPathObjectPtr xpathobj;
207 xmlXPathCompExprPtr *xpathscomp;
208 } XmlTableBuilderData;
217 const char *path,
int colnum);
220 Oid typid,
int32 typmod,
bool *isnull);
235 #define NO_XML_SUPPORT() \
237 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), \
238 errmsg("unsupported XML feature"), \
239 errdetail("This functionality requires the server to be built with libxml support.")))
243 #define NAMESPACE_XSD "http://www.w3.org/2001/XMLSchema"
244 #define NAMESPACE_XSI "http://www.w3.org/2001/XMLSchema-instance"
245 #define NAMESPACE_SQLXML "http://standards.iso.org/iso/9075/2003/sqlxml"
251 xmlChar_to_encoding(
const xmlChar *encoding_name)
257 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
258 errmsg(
"invalid encoding name \"%s\"",
259 (
const char *) encoding_name)));
289 NULL, NULL, fcinfo->context);
301 #define PG_XML_DEFAULT_VERSION "1.0"
322 if ((res_code = parse_xml_decl((xmlChar *)
str,
323 &
len, &version, NULL, &standalone)) == 0)
329 if (!print_xml_decl(&
buf, version, target_encoding, standalone))
347 errcode(ERRCODE_INTERNAL_ERROR),
349 errdetail_for_xml_code(res_code));
380 xmlChar *encodingStr = NULL;
388 nbytes =
buf->len -
buf->cursor;
402 parse_xml_decl((
const xmlChar *)
str, NULL, NULL, &encodingStr, NULL);
482 xmlBuffer_to_xmltype(xmlBufferPtr
buf)
485 xmlBufferLength(
buf));
503 if (argdata[
i] ==
'-' && argdata[
i - 1] ==
'-')
505 (
errcode(ERRCODE_INVALID_XML_COMMENT),
506 errmsg(
"invalid XML comment")));
508 if (
len > 0 && argdata[
len - 1] ==
'-')
510 (
errcode(ERRCODE_INVALID_XML_COMMENT),
511 errmsg(
"invalid XML comment")));
532 xmlChar *xmlbuf = NULL;
534 xmlbuf = xmlEncodeSpecialChars(NULL, xml_text2xmlChar(
arg));
556 int global_standalone = 1;
557 xmlChar *global_version = NULL;
558 bool global_version_no_value =
false;
574 parse_xml_decl((xmlChar *)
str, &
len, &version, NULL, &standalone);
576 if (standalone == 0 && global_standalone == 1)
577 global_standalone = 0;
579 global_standalone = -1;
582 global_version_no_value =
true;
583 else if (!global_version)
584 global_version = version;
585 else if (xmlStrcmp(version, global_version) != 0)
586 global_version_no_value =
true;
592 if (!global_version_no_value || global_standalone >= 0)
598 print_xml_decl(&buf2,
599 (!global_version_no_value) ? global_version : NULL,
659 text *
volatile result;
662 xmlNodePtr content_nodes;
663 volatile xmlBufferPtr
buf = NULL;
664 volatile xmlSaveCtxtPtr ctxt = NULL;
682 &parsed_xmloptiontype, &content_nodes,
683 (
Node *) &escontext);
690 (
errcode(ERRCODE_NOT_AN_XML_DOCUMENT),
691 errmsg(
"not an XML document")));
709 buf = xmlBufferCreate();
711 if (
buf == NULL || xmlerrcxt->err_occurred)
713 "could not allocate xmlBuffer");
716 parse_xml_decl(xml_text2xmlChar(
data), &decl_len, NULL, NULL, NULL);
725 ctxt = xmlSaveToBuffer(
buf, NULL,
726 XML_SAVE_NO_DECL | XML_SAVE_FORMAT);
728 ctxt = xmlSaveToBuffer(
buf, NULL,
731 if (ctxt == NULL || xmlerrcxt->err_occurred)
733 "could not allocate xmlSaveCtxt");
738 if (xmlSaveDoc(ctxt, doc) == -1 || xmlerrcxt->err_occurred)
740 "could not save document to xmlBuffer");
742 else if (content_nodes != NULL)
753 root = xmlNewNode(NULL, (
const xmlChar *)
"content-root");
754 if (
root == NULL || xmlerrcxt->err_occurred)
756 "could not allocate xml node");
759 xmlDocSetRootElement(doc,
root);
760 xmlAddChildList(
root, content_nodes);
769 newline = xmlNewDocText(NULL, (
const xmlChar *)
"\n");
770 if (
newline == NULL || xmlerrcxt->err_occurred)
772 "could not allocate xml node");
774 for (xmlNodePtr node =
root->children; node; node = node->next)
777 if (node->type != XML_TEXT_NODE && node->prev != NULL)
779 if (xmlSaveTree(ctxt,
newline) == -1 || xmlerrcxt->err_occurred)
783 "could not save newline to xmlBuffer");
787 if (xmlSaveTree(ctxt, node) == -1 || xmlerrcxt->err_occurred)
791 "could not save content to xmlBuffer");
798 if (xmlSaveClose(ctxt) == -1 || xmlerrcxt->err_occurred)
802 "could not close xmlSaveCtxtPtr");
805 result = (
text *) xmlBuffer_to_xmltype(
buf);
837 Datum *named_argvalue,
bool *named_argnull,
838 Datum *argvalue,
bool *argnull)
842 List *named_arg_strings;
848 volatile xmlBufferPtr
buf = NULL;
849 volatile xmlTextWriterPtr writer = NULL;
858 named_arg_strings =
NIL;
865 if (named_argnull[
i])
871 named_arg_strings =
lappend(named_arg_strings,
str);
897 buf = xmlBufferCreate();
898 if (
buf == NULL || xmlerrcxt->err_occurred)
900 "could not allocate xmlBuffer");
901 writer = xmlNewTextWriterMemory(
buf, 0);
902 if (writer == NULL || xmlerrcxt->err_occurred)
904 "could not allocate xmlTextWriter");
906 xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name);
908 forboth(
arg, named_arg_strings, narg, xexpr->arg_names)
914 xmlTextWriterWriteAttribute(writer,
919 foreach(
arg, arg_strings)
923 xmlTextWriterWriteRaw(writer, (xmlChar *)
str);
926 xmlTextWriterEndElement(writer);
929 xmlFreeTextWriter(writer);
932 result = xmlBuffer_to_xmltype(
buf);
937 xmlFreeTextWriter(writer);
965 doc = xml_parse(
data, xmloption_arg, preserve_whitespace,
978 xmlpi(
const char *target,
text *
arg,
bool arg_is_null,
bool *result_is_null)
986 (
errcode(ERRCODE_SYNTAX_ERROR),
987 errmsg(
"invalid XML processing instruction"),
988 errdetail(
"XML processing instruction target name cannot be \"%s\".", target)));
994 *result_is_null = arg_is_null;
1007 if (strstr(
string,
"?>") != NULL)
1009 (
errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION),
1010 errmsg(
"invalid XML processing instruction"),
1011 errdetail(
"XML processing instruction cannot contain \"?>\".")));
1035 xmlChar *orig_version;
1036 int orig_standalone;
1042 parse_xml_decl((xmlChar *)
str, &
len, &orig_version, NULL, &orig_standalone);
1045 orig_version = xml_text2xmlChar(version);
1047 orig_version = NULL;
1052 orig_standalone = 1;
1055 orig_standalone = 0;
1058 orig_standalone = -1;
1066 print_xml_decl(&
buf, orig_version, 0, orig_standalone);
1089 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1090 errmsg(
"xmlvalidate is not implemented")));
1134 static bool first_time =
true;
1144 if (
sizeof(
char) !=
sizeof(xmlChar))
1146 (
errmsg(
"could not initialize XML library"),
1147 errdetail(
"libxml2 has incompatible char type: sizeof(char)=%zu, sizeof(xmlChar)=%zu.",
1148 sizeof(
char),
sizeof(xmlChar))));
1150 #ifdef USE_LIBXMLCONTEXT
1156 LIBXML_TEST_VERSION;
1188 errcxt->magic = ERRCXT_MAGIC;
1189 errcxt->strictness = strictness;
1190 errcxt->err_occurred =
false;
1200 errcxt->saved_errfunc = xmlStructuredError;
1202 #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1203 errcxt->saved_errcxt = xmlStructuredErrorContext;
1205 errcxt->saved_errcxt = xmlGenericErrorContext;
1208 xmlSetStructuredErrorFunc((
void *) errcxt, xml_errorHandler);
1224 #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1225 new_errcxt = xmlStructuredErrorContext;
1227 new_errcxt = xmlGenericErrorContext;
1230 if (new_errcxt != (
void *) errcxt)
1232 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1233 errmsg(
"could not set up XML error handler"),
1234 errhint(
"This probably indicates that the version of libxml2"
1235 " being used is not compatible with the libxml2"
1236 " header files that PostgreSQL was built with.")));
1242 errcxt->saved_entityfunc = xmlGetExternalEntityLoader();
1243 xmlSetExternalEntityLoader(xmlPgEntityLoader);
1264 Assert(errcxt->magic == ERRCXT_MAGIC);
1271 Assert(!errcxt->err_occurred || isError);
1278 #ifdef HAVE_XMLSTRUCTUREDERRORCONTEXT
1279 cur_errcxt = xmlStructuredErrorContext;
1281 cur_errcxt = xmlGenericErrorContext;
1284 if (cur_errcxt != (
void *) errcxt)
1285 elog(
WARNING,
"libxml error handling state is out of sync with xml.c");
1288 xmlSetStructuredErrorFunc(errcxt->saved_errcxt, errcxt->saved_errfunc);
1289 xmlSetExternalEntityLoader(errcxt->saved_entityfunc);
1298 pfree(errcxt->err_buf.data);
1309 return errcxt->err_occurred;
1322 #define CHECK_XML_SPACE(p) \
1324 if (!xmlIsBlank_ch(*(p))) \
1325 return XML_ERR_SPACE_REQUIRED; \
1328 #define SKIP_XML_SPACE(p) \
1329 while (xmlIsBlank_ch(*(p))) (p)++
1333 #define PG_XMLISNAMECHAR(c) \
1334 (xmlIsBaseChar_ch(c) || xmlIsIdeographicQ(c) \
1335 || xmlIsDigit_ch(c) \
1336 || c == '.' || c == '-' || c == '_' || c == ':' \
1337 || xmlIsCombiningQ(c) \
1338 || xmlIsExtender_ch(c))
1342 xml_pnstrdup(
const xmlChar *
str,
size_t len)
1346 result = (xmlChar *)
palloc((
len + 1) *
sizeof(xmlChar));
1347 memcpy(result,
str,
len *
sizeof(xmlChar));
1354 pg_xmlCharStrndup(
const char *
str,
size_t len)
1358 result = (xmlChar *)
palloc((
len + 1) *
sizeof(xmlChar));
1359 memcpy(result,
str,
len);
1371 xml_pstrdup_and_free(xmlChar *
str)
1400 parse_xml_decl(
const xmlChar *
str,
size_t *lenp,
1401 xmlChar **version, xmlChar **
encoding,
int *standalone)
1404 const xmlChar *save_p;
1427 if (xmlStrncmp(p, (xmlChar *)
"<?xml", 5) != 0)
1439 utf8char = xmlGetUTF8Char(p + 5, &utf8len);
1440 if (PG_XMLISNAMECHAR(utf8char))
1448 if (xmlStrncmp(p, (xmlChar *)
"version", 7) != 0)
1449 return XML_ERR_VERSION_MISSING;
1453 return XML_ERR_VERSION_MISSING;
1457 if (*p ==
'\'' || *p ==
'"')
1461 q = xmlStrchr(p + 1, *p);
1463 return XML_ERR_VERSION_MISSING;
1466 *version = xml_pnstrdup(p + 1, q - p - 1);
1470 return XML_ERR_VERSION_MISSING;
1475 if (xmlStrncmp(p, (xmlChar *)
"encoding", 8) == 0)
1477 CHECK_XML_SPACE(save_p);
1481 return XML_ERR_MISSING_ENCODING;
1485 if (*p ==
'\'' || *p ==
'"')
1489 q = xmlStrchr(p + 1, *p);
1491 return XML_ERR_MISSING_ENCODING;
1494 *
encoding = xml_pnstrdup(p + 1, q - p - 1);
1498 return XML_ERR_MISSING_ENCODING;
1508 if (xmlStrncmp(p, (xmlChar *)
"standalone", 10) == 0)
1510 CHECK_XML_SPACE(save_p);
1514 return XML_ERR_STANDALONE_VALUE;
1517 if (xmlStrncmp(p, (xmlChar *)
"'yes'", 5) == 0 ||
1518 xmlStrncmp(p, (xmlChar *)
"\"yes\"", 5) == 0)
1524 else if (xmlStrncmp(p, (xmlChar *)
"'no'", 4) == 0 ||
1525 xmlStrncmp(p, (xmlChar *)
"\"no\"", 4) == 0)
1532 return XML_ERR_STANDALONE_VALUE;
1540 if (xmlStrncmp(p, (xmlChar *)
"?>", 2) != 0)
1541 return XML_ERR_XMLDECL_NOT_FINISHED;
1549 return XML_ERR_INVALID_CHAR;
1578 || standalone != -1)
1597 if (standalone == 1)
1599 else if (standalone == 0)
1639 xml_doctype_in_content(
const xmlChar *
str)
1641 const xmlChar *p =
str;
1657 if (xmlStrncmp(p, (xmlChar *)
"DOCTYPE", 7) == 0)
1661 if (xmlStrncmp(p, (xmlChar *)
"--", 2) != 0)
1664 p = xmlStrstr(p + 2, (xmlChar *)
"--");
1665 if (!p || p[2] !=
'>')
1678 e = xmlStrstr(p, (xmlChar *)
"?>");
1716 bool preserve_whitespace,
int encoding,
1717 XmlOptionType *parsed_xmloptiontype, xmlNodePtr *parsed_nodes,
1722 xmlChar *utf8string;
1724 volatile xmlParserCtxtPtr ctxt = NULL;
1725 volatile xmlDocPtr doc = NULL;
1732 string = xml_text2xmlChar(
data);
1752 bool parse_as_document =
false;
1756 xmlChar *version = NULL;
1764 parse_as_document =
true;
1768 res_code = parse_xml_decl(utf8string,
1769 &count, &version, NULL, &standalone);
1773 errcode(ERRCODE_INVALID_XML_CONTENT),
1775 errdetail_for_xml_code(res_code));
1780 if (xml_doctype_in_content(utf8string + count))
1781 parse_as_document =
true;
1793 options = XML_PARSE_NOENT | XML_PARSE_DTDATTR
1794 | (preserve_whitespace ? 0 : XML_PARSE_NOBLANKS);
1797 if (parsed_xmloptiontype != NULL)
1800 if (parsed_nodes != NULL)
1801 *parsed_nodes = NULL;
1803 if (parse_as_document)
1805 ctxt = xmlNewParserCtxt();
1806 if (ctxt == NULL || xmlerrcxt->err_occurred)
1808 "could not allocate parser context");
1810 doc = xmlCtxtReadDoc(ctxt, utf8string,
1815 if (doc == NULL || xmlerrcxt->err_occurred)
1819 xml_errsave(escontext, xmlerrcxt,
1820 ERRCODE_INVALID_XML_DOCUMENT,
1821 "invalid XML document");
1823 xml_errsave(escontext, xmlerrcxt,
1824 ERRCODE_INVALID_XML_CONTENT,
1825 "invalid XML content");
1834 doc = xmlNewDoc(version);
1835 if (doc == NULL || xmlerrcxt->err_occurred)
1837 "could not allocate XML document");
1839 Assert(doc->encoding == NULL);
1840 doc->encoding = xmlStrdup((
const xmlChar *)
"UTF-8");
1841 if (doc->encoding == NULL || xmlerrcxt->err_occurred)
1843 "could not allocate XML document");
1844 doc->standalone = standalone;
1846 root = xmlNewNode(NULL, (
const xmlChar *)
"content-root");
1847 if (
root == NULL || xmlerrcxt->err_occurred)
1849 "could not allocate xml node");
1851 xmlDocSetRootElement(doc,
root);
1854 if (*(utf8string + count))
1856 xmlNodePtr node_list = NULL;
1857 xmlParserErrors
res;
1859 res = xmlParseInNodeContext(
root,
1860 (
char *) utf8string + count,
1861 strlen((
char *) utf8string + count),
1865 if (
res != XML_ERR_OK || xmlerrcxt->err_occurred)
1867 xmlFreeNodeList(node_list);
1868 xml_errsave(escontext, xmlerrcxt,
1869 ERRCODE_INVALID_XML_CONTENT,
1870 "invalid XML content");
1874 if (parsed_nodes != NULL)
1875 *parsed_nodes = node_list;
1877 xmlFreeNodeList(node_list);
1889 xmlFreeParserCtxt(ctxt);
1898 xmlFreeParserCtxt(ctxt);
1910 xml_text2xmlChar(
text *in)
1916 #ifdef USE_LIBXMLCONTEXT
1923 xml_memory_init(
void)
1926 if (LibxmlContext == NULL)
1932 xmlMemSetup(xml_pfree, xml_palloc, xml_repalloc, xml_pstrdup);
1939 xml_palloc(
size_t size)
1946 xml_repalloc(
void *ptr,
size_t size)
1953 xml_pfree(
void *ptr)
1962 xml_pstrdup(
const char *
string)
1980 static xmlParserInputPtr
1981 xmlPgEntityLoader(
const char *URL,
const char *ID,
1982 xmlParserCtxtPtr ctxt)
1984 return xmlNewStringInputStream(ctxt, (
const xmlChar *)
"");
2004 if (errcxt->magic != ERRCXT_MAGIC)
2005 elog(
ERROR,
"xml_ereport called with invalid PgXmlErrorContext");
2008 errcxt->err_occurred =
false;
2011 if (errcxt->err_buf.len > 0)
2012 detail = errcxt->err_buf.data;
2037 int sqlcode,
const char *msg)
2042 if (errcxt->magic != ERRCXT_MAGIC)
2043 elog(
ERROR,
"xml_errsave called with invalid PgXmlErrorContext");
2046 errcxt->err_occurred =
false;
2049 if (errcxt->err_buf.len > 0)
2050 detail = errcxt->err_buf.data;
2065 xml_errorHandler(
void *
data, PgXmlErrorPtr
error)
2068 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)
error->ctxt;
2069 xmlParserInputPtr
input = (ctxt != NULL) ? ctxt->input : NULL;
2070 xmlNodePtr node =
error->node;
2071 const xmlChar *
name = (node != NULL &&
2072 node->type == XML_ELEMENT_NODE) ? node->name : NULL;
2073 int domain =
error->domain;
2074 int level =
error->level;
2083 if (xmlerrcxt->magic != ERRCXT_MAGIC)
2084 elog(
FATAL,
"xml_errorHandler called with invalid PgXmlErrorContext");
2094 switch (
error->code)
2096 case XML_WAR_NS_URI:
2097 level = XML_ERR_ERROR;
2098 domain = XML_FROM_NAMESPACE;
2101 case XML_ERR_NS_DECL_ERROR:
2102 case XML_WAR_NS_URI_RELATIVE:
2103 case XML_WAR_NS_COLUMN:
2104 case XML_NS_ERR_XML_NAMESPACE:
2105 case XML_NS_ERR_UNDEFINED_NAMESPACE:
2106 case XML_NS_ERR_QNAME:
2107 case XML_NS_ERR_ATTRIBUTE_REDEFINED:
2108 case XML_NS_ERR_EMPTY:
2109 domain = XML_FROM_NAMESPACE;
2116 case XML_FROM_PARSER:
2125 if (
error->code == XML_ERR_NOT_WELL_BALANCED &&
2126 xmlerrcxt->err_occurred)
2131 case XML_FROM_MEMORY:
2138 if (
error->code == XML_WAR_UNDECLARED_ENTITY)
2154 if (
error->line > 0)
2158 if (
error->message != NULL)
2176 xmlGenericErrorFunc errFuncSaved = xmlGenericError;
2177 void *errCtxSaved = xmlGenericErrorContext;
2179 xmlSetGenericErrorFunc((
void *) errorBuf,
2183 appendStringInfoLineSeparator(errorBuf);
2185 xmlParserPrintFileContext(
input);
2188 xmlSetGenericErrorFunc(errCtxSaved, errFuncSaved);
2192 chopStringInfoNewlines(errorBuf);
2204 appendStringInfoLineSeparator(&xmlerrcxt->err_buf);
2220 if (level >= XML_ERR_ERROR)
2222 appendStringInfoLineSeparator(&xmlerrcxt->err_buf);
2226 xmlerrcxt->err_occurred =
true;
2228 else if (level >= XML_ERR_WARNING)
2253 errdetail_for_xml_code(
int code)
2259 case XML_ERR_INVALID_CHAR:
2262 case XML_ERR_SPACE_REQUIRED:
2265 case XML_ERR_STANDALONE_VALUE:
2266 det =
gettext_noop(
"standalone accepts only 'yes' or 'no'.");
2268 case XML_ERR_VERSION_MISSING:
2269 det =
gettext_noop(
"Malformed declaration: missing version.");
2271 case XML_ERR_MISSING_ENCODING:
2272 det =
gettext_noop(
"Missing encoding in text declaration.");
2274 case XML_ERR_XMLDECL_NOT_FINISHED:
2275 det =
gettext_noop(
"Parsing XML declaration: '?>' expected.");
2278 det =
gettext_noop(
"Unrecognized libxml error code: %d.");
2292 while (
str->len > 0 &&
str->data[
str->len - 1] ==
'\n')
2293 str->data[--
str->len] =
'\0';
2303 chopStringInfoNewlines(
str);
2313 sqlchar_to_unicode(
const char *s)
2324 if (utf8string != s)
2335 return (xmlIsBaseCharQ(
c) || xmlIsIdeographicQ(
c)
2336 ||
c ==
'_' ||
c ==
':');
2344 return (xmlIsBaseCharQ(
c) || xmlIsIdeographicQ(
c)
2346 ||
c ==
'.' ||
c ==
'-' ||
c ==
'_' ||
c ==
':'
2347 || xmlIsCombiningQ(
c)
2348 || xmlIsExtenderQ(
c));
2368 Assert(fully_escaped || !escape_period);
2374 if (*p ==
':' && (p ==
ident || fully_escaped))
2376 else if (*p ==
'_' && *(p + 1) ==
'x')
2378 else if (fully_escaped && p ==
ident &&
2386 else if (escape_period && *p ==
'.')
2390 pg_wchar u = sqlchar_to_unicode(p);
2393 ? !is_valid_xml_namefirst(u)
2394 : !is_valid_xml_namechar(u))
2422 if (*p ==
'_' && *(p + 1) ==
'x'
2423 && isxdigit((
unsigned char) *(p + 2))
2424 && isxdigit((
unsigned char) *(p + 3))
2425 && isxdigit((
unsigned char) *(p + 4))
2426 && isxdigit((
unsigned char) *(p + 5))
2432 sscanf(p + 2,
"%X", &u);
2475 elmlen, elmbyval, elmalign,
2476 &elem_values, &elem_nulls,
2481 for (
i = 0;
i < num_elems;
i++)
2530 (
errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2531 errmsg(
"date out of range"),
2532 errdetail(
"XML does not support infinite date values.")));
2552 (
errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2553 errmsg(
"timestamp out of range"),
2554 errdetail(
"XML does not support infinite timestamp values.")));
2559 (
errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2560 errmsg(
"timestamp out of range")));
2565 case TIMESTAMPTZOID:
2571 const char *tzn = NULL;
2579 (
errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2580 errmsg(
"timestamp out of range"),
2581 errdetail(
"XML does not support infinite timestamp values.")));
2586 (
errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
2587 errmsg(
"timestamp out of range")));
2597 volatile xmlBufferPtr
buf = NULL;
2598 volatile xmlTextWriterPtr writer = NULL;
2605 buf = xmlBufferCreate();
2606 if (
buf == NULL || xmlerrcxt->err_occurred)
2608 "could not allocate xmlBuffer");
2609 writer = xmlNewTextWriterMemory(
buf, 0);
2610 if (writer == NULL || xmlerrcxt->err_occurred)
2612 "could not allocate xmlTextWriter");
2615 xmlTextWriterWriteBase64(writer,
VARDATA_ANY(bstr),
2618 xmlTextWriterWriteBinHex(writer,
VARDATA_ANY(bstr),
2622 xmlFreeTextWriter(writer);
2625 result =
pstrdup((
const char *) xmlBufferContent(
buf));
2630 xmlFreeTextWriter(writer);
2657 if (
type == XMLOID || !xml_escape_strings)
2680 for (p =
str; *p; p++)
2708 size_t len = strlen(s) + 1;
2711 memcpy(ret, s,
len);
2771 elog(
ERROR,
"SPI_execute returned %s for %s",
2798 " WHERE relnamespace = %u AND relkind IN ("
2802 " AND pg_catalog.has_table_privilege (oid, 'SELECT')"
2803 " ORDER BY relname;",
nspid);
2813 #define XML_VISIBLE_SCHEMAS_EXCLUDE "(nspname ~ '^pg_' OR nspname = 'information_schema')"
2815 #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
2830 " WHERE relkind IN ("
2834 " AND pg_catalog.has_table_privilege(pg_class.oid, 'SELECT')"
2846 const char *xmlschema,
bool nulls,
bool tableforest,
2847 const char *targetns,
bool top_level)
2856 xmlschema, nulls, tableforest,
2857 targetns, top_level);
2884 NULL, nulls, tableforest,
2914 (
errcode(ERRCODE_UNDEFINED_CURSOR),
2915 errmsg(
"cursor \"%s\" does not exist",
name)));
2920 tableforest, targetns,
true);
2945 const char *xmlschema,
const char *targetns,
2949 Assert(top_level || !xmlschema);
2955 if (strlen(targetns) > 0)
2961 if (strlen(targetns) > 0)
2979 const char *xmlschema,
bool nulls,
bool tableforest,
2980 const char *targetns,
bool top_level)
2996 (
errcode(ERRCODE_DATA_EXCEPTION),
2997 errmsg(
"invalid query")));
3002 targetns, top_level);
3011 tableforest, targetns, top_level);
3034 tableforest, targetns);
3055 elog(
ERROR,
"SPI_prepare(\"%s\") failed", query);
3058 elog(
ERROR,
"SPI_cursor_open(\"%s\") failed", query);
3062 tableforest, targetns));
3077 const char *xmlschema;
3084 (
errcode(ERRCODE_UNDEFINED_CURSOR),
3085 errmsg(
"cursor \"%s\" does not exist",
name)));
3088 (
errcode(ERRCODE_INVALID_CURSOR_STATE),
3089 errmsg(
"portal \"%s\" does not return tuples",
name)));
3093 tableforest, targetns));
3108 const char *xmlschema;
3112 tableforest, targetns);
3116 xmlschema, nulls, tableforest,
3129 const char *xmlschema;
3136 elog(
ERROR,
"SPI_prepare(\"%s\") failed", query);
3139 elog(
ERROR,
"SPI_cursor_open(\"%s\") failed", query);
3147 xmlschema, nulls, tableforest,
3159 bool tableforest,
const char *targetns,
bool top_level)
3180 foreach(cell, relid_list)
3215 nulls, tableforest, targetns,
true)));
3228 if (strlen(targetns) > 0)
3231 " targetNamespace=\"%s\"\n"
3232 " elementFormDefault=\"qualified\"",
3248 bool tableforest,
const char *targetns)
3267 foreach(cell, relid_list)
3281 nulls, tableforest, targetns));
3300 nulls, tableforest, targetns)));
3319 tableforest, targetns);
3322 xmlschema->
data, nulls,
3323 tableforest, targetns,
true)));
3334 bool tableforest,
const char *targetns)
3355 foreach(cell, nspid_list)
3361 tableforest, targetns,
false);
3383 tableforest, targetns)));
3389 const char *targetns)
3407 foreach(cell, relid_list)
3438 tableforest, targetns)));
3453 nulls, tableforest, targetns)));
3494 bool tableforest,
const char *targetns)
3498 char *tabletypename;
3511 elog(
ERROR,
"cache lookup failed for relation %u", relid);
3536 tabletypename =
"TableType";
3537 rowtypename =
"RowType";
3546 "<xsd:complexType name=\"%s\">\n"
3547 " <xsd:sequence>\n",
3550 for (
i = 0;
i < tupdesc->
natts;
i++)
3554 if (att->attisdropped)
3557 " <xsd:element name=\"%s\" type=\"%s\"%s></xsd:element>\n",
3561 nulls ?
" nillable=\"true\"" :
" minOccurs=\"0\"");
3565 " </xsd:sequence>\n"
3566 "</xsd:complexType>\n\n");
3571 "<xsd:complexType name=\"%s\">\n"
3573 " <xsd:element name=\"row\" type=\"%s\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n"
3574 " </xsd:sequence>\n"
3575 "</xsd:complexType>\n\n",
3576 tabletypename, rowtypename);
3579 "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3580 xmltn, tabletypename);
3584 "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3585 xmltn, rowtypename);
3599 bool tableforest,
const char *targetns)
3604 char *schematypename;
3621 "<xsd:complexType name=\"%s\">\n", schematypename);
3627 " <xsd:sequence>\n");
3629 foreach(cell, relid_list)
3641 " <xsd:element name=\"%s\" type=\"%s\"/>\n",
3642 xmltn, tabletypename);
3645 " <xsd:element name=\"%s\" type=\"%s\" minOccurs=\"0\" maxOccurs=\"unbounded\"/>\n",
3646 xmltn, tabletypename);
3654 " </xsd:sequence>\n");
3656 "</xsd:complexType>\n\n");
3659 "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3660 xmlsn, schematypename);
3672 bool tableforest,
const char *targetns)
3676 char *catalogtypename;
3692 "<xsd:complexType name=\"%s\">\n", catalogtypename);
3696 foreach(cell, nspid_list)
3707 " <xsd:element name=\"%s\" type=\"%s\"/>\n",
3708 xmlsn, schematypename);
3714 "</xsd:complexType>\n\n");
3717 "<xsd:element name=\"%s\" type=\"%s\"/>\n\n",
3718 xmlcn, catalogtypename);
3753 ((typmod -
VARHDRSZ) >> 16) & 0xffff,
3792 case TIMESTAMPTZOID:
3811 elog(
ERROR,
"cache lookup failed for type %u", typeoid);
3841 foreach(cell0, tupdesc_list)
3845 for (
i = 0;
i < tupdesc->
natts;
i++)
3849 if (att->attisdropped)
3856 foreach(cell0, uniquetypes)
3861 if (basetypid != typid)
3868 foreach(cell0, uniquetypes)
3895 if (typeoid == XMLOID)
3898 "<xsd:complexType mixed=\"true\">\n"
3900 " <xsd:any name=\"element\" minOccurs=\"0\" maxOccurs=\"unbounded\" processContents=\"skip\"/>\n"
3901 " </xsd:sequence>\n"
3902 "</xsd:complexType>\n");
3907 "<xsd:simpleType name=\"%s\">\n",
typename);
3915 " <xsd:restriction base=\"xsd:string\">\n");
3918 " <xsd:maxLength value=\"%d\"/>\n",
3925 " <xsd:restriction base=\"xsd:%s\">\n"
3926 " </xsd:restriction>\n",
3933 " <xsd:restriction base=\"xsd:decimal\">\n"
3934 " <xsd:totalDigits value=\"%d\"/>\n"
3935 " <xsd:fractionDigits value=\"%d\"/>\n"
3936 " </xsd:restriction>\n",
3937 ((typmod -
VARHDRSZ) >> 16) & 0xffff,
3943 " <xsd:restriction base=\"xsd:short\">\n"
3944 " <xsd:maxInclusive value=\"%d\"/>\n"
3945 " <xsd:minInclusive value=\"%d\"/>\n"
3946 " </xsd:restriction>\n",
3947 SHRT_MAX, SHRT_MIN);
3952 " <xsd:restriction base=\"xsd:int\">\n"
3953 " <xsd:maxInclusive value=\"%d\"/>\n"
3954 " <xsd:minInclusive value=\"%d\"/>\n"
3955 " </xsd:restriction>\n",
3961 " <xsd:restriction base=\"xsd:long\">\n"
3964 " </xsd:restriction>\n",
3971 " <xsd:restriction base=\"xsd:float\"></xsd:restriction>\n");
3976 " <xsd:restriction base=\"xsd:double\"></xsd:restriction>\n");
3981 " <xsd:restriction base=\"xsd:boolean\"></xsd:restriction>\n");
3987 const char *tz = (typeoid == TIMETZOID ?
"(\\+|-)\\p{Nd}{2}:\\p{Nd}{2}" :
"");
3991 " <xsd:restriction base=\"xsd:time\">\n"
3992 " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}(.\\p{Nd}+)?%s\"/>\n"
3993 " </xsd:restriction>\n", tz);
3994 else if (typmod == 0)
3996 " <xsd:restriction base=\"xsd:time\">\n"
3997 " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}%s\"/>\n"
3998 " </xsd:restriction>\n", tz);
4001 " <xsd:restriction base=\"xsd:time\">\n"
4002 " <xsd:pattern value=\"\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}.\\p{Nd}{%d}%s\"/>\n"
4003 " </xsd:restriction>\n", typmod -
VARHDRSZ, tz);
4008 case TIMESTAMPTZOID:
4010 const char *tz = (typeoid == TIMESTAMPTZOID ?
"(\\+|-)\\p{Nd}{2}:\\p{Nd}{2}" :
"");
4014 " <xsd:restriction base=\"xsd:dateTime\">\n"
4015 " <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"
4016 " </xsd:restriction>\n", tz);
4017 else if (typmod == 0)
4019 " <xsd:restriction base=\"xsd:dateTime\">\n"
4020 " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}T\\p{Nd}{2}:\\p{Nd}{2}:\\p{Nd}{2}%s\"/>\n"
4021 " </xsd:restriction>\n", tz);
4024 " <xsd:restriction base=\"xsd:dateTime\">\n"
4025 " <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"
4026 " </xsd:restriction>\n", typmod -
VARHDRSZ, tz);
4032 " <xsd:restriction base=\"xsd:date\">\n"
4033 " <xsd:pattern value=\"\\p{Nd}{4}-\\p{Nd}{2}-\\p{Nd}{2}\"/>\n"
4034 " </xsd:restriction>\n");
4041 int32 base_typmod = -1;
4046 " <xsd:restriction base=\"%s\"/>\n",
4064 bool nulls,
bool tableforest,
4065 const char *targetns,
bool top_level)
4137 if (
cur->type != XML_ATTRIBUTE_NODE &&
cur->type != XML_TEXT_NODE)
4139 void (*
volatile nodefree) (xmlNodePtr) = NULL;
4140 volatile xmlBufferPtr
buf = NULL;
4141 volatile xmlNodePtr cur_copy = NULL;
4147 buf = xmlBufferCreate();
4148 if (
buf == NULL || xmlerrcxt->err_occurred)
4150 "could not allocate xmlBuffer");
4164 cur_copy = xmlCopyNode(
cur, 1);
4165 if (cur_copy == NULL || xmlerrcxt->err_occurred)
4167 "could not copy node");
4168 nodefree = (cur_copy->type == XML_DOCUMENT_NODE) ?
4169 (
void (*) (xmlNodePtr)) xmlFreeDoc : xmlFreeNode;
4171 bytes = xmlNodeDump(
buf, NULL, cur_copy, 0, 0);
4172 if (bytes == -1 || xmlerrcxt->err_occurred)
4174 "could not dump node");
4176 result = xmlBuffer_to_xmltype(
buf);
4191 str = xmlXPathCastNodeToString(
cur);
4223 xml_xpathobjtoxmlarray(xmlXPathObjectPtr xpathobj,
4232 switch (xpathobj->type)
4235 if (xpathobj->nodesetval != NULL)
4237 result = xpathobj->nodesetval->nodeNr;
4242 for (
i = 0;
i < result;
i++)
4244 datum =
PointerGetDatum(xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[
i],
4257 datumtype = BOOLOID;
4264 datumtype = FLOAT8OID;
4271 datumtype = CSTRINGOID;
4275 elog(
ERROR,
"xpath expression result type %d is unsupported",
4305 volatile xmlParserCtxtPtr ctxt = NULL;
4306 volatile xmlDocPtr doc = NULL;
4307 volatile xmlXPathContextPtr xpathctx = NULL;
4308 volatile xmlXPathCompExprPtr xpathcomp = NULL;
4309 volatile xmlXPathObjectPtr xpathobj = NULL;
4314 xmlChar *xpath_expr;
4315 size_t xmldecl_len = 0;
4318 Datum *ns_names_uris;
4319 bool *ns_names_uris_nulls;
4331 ndim = namespaces ?
ARR_NDIM(namespaces) : 0;
4338 if (ndim != 2 || dims[1] != 2)
4340 (
errcode(ERRCODE_DATA_EXCEPTION),
4341 errmsg(
"invalid array for XML namespace mapping"),
4342 errdetail(
"The array must be two-dimensional with length of the second axis equal to 2.")));
4347 &ns_names_uris, &ns_names_uris_nulls,
4350 Assert((ns_count % 2) == 0);
4355 ns_names_uris = NULL;
4356 ns_names_uris_nulls = NULL;
4365 (
errcode(ERRCODE_DATA_EXCEPTION),
4366 errmsg(
"empty XPath expression")));
4368 string = pg_xmlCharStrndup(datastr,
len);
4369 xpath_expr = pg_xmlCharStrndup(
VARDATA_ANY(xpath_expr_text), xpath_len);
4379 parse_xml_decl(
string, &xmldecl_len, NULL, NULL, NULL);
4391 ctxt = xmlNewParserCtxt();
4392 if (ctxt == NULL || xmlerrcxt->err_occurred)
4394 "could not allocate parser context");
4395 doc = xmlCtxtReadMemory(ctxt, (
char *)
string + xmldecl_len,
4396 len - xmldecl_len, NULL, NULL, 0);
4397 if (doc == NULL || xmlerrcxt->err_occurred)
4399 "could not parse XML document");
4400 xpathctx = xmlXPathNewContext(doc);
4401 if (xpathctx == NULL || xmlerrcxt->err_occurred)
4403 "could not allocate XPath context");
4404 xpathctx->node = (xmlNodePtr) doc;
4409 for (
i = 0;
i < ns_count;
i++)
4414 if (ns_names_uris_nulls[
i * 2] ||
4415 ns_names_uris_nulls[
i * 2 + 1])
4417 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
4418 errmsg(
"neither namespace name nor URI may be null")));
4421 if (xmlXPathRegisterNs(xpathctx,
4422 (xmlChar *) ns_name,
4423 (xmlChar *) ns_uri) != 0)
4425 (
errmsg(
"could not register XML namespace with name \"%s\" and URI \"%s\"",
4430 xpathcomp = xmlXPathCompile(xpath_expr);
4431 if (xpathcomp == NULL || xmlerrcxt->err_occurred)
4433 "invalid XPath expression");
4442 xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx);
4443 if (xpathobj == NULL || xmlerrcxt->err_occurred)
4445 "could not create XPath object");
4450 if (res_nitems != NULL)
4451 *res_nitems = xml_xpathobjtoxmlarray(xpathobj, astate, xmlerrcxt);
4453 (
void) xml_xpathobjtoxmlarray(xpathobj, astate, xmlerrcxt);
4458 xmlXPathFreeObject(xpathobj);
4460 xmlXPathFreeCompExpr(xpathcomp);
4462 xmlXPathFreeContext(xpathctx);
4466 xmlFreeParserCtxt(ctxt);
4474 xmlXPathFreeObject(xpathobj);
4475 xmlXPathFreeCompExpr(xpathcomp);
4476 xmlXPathFreeContext(xpathctx);
4478 xmlFreeParserCtxt(ctxt);
4501 xpath_internal(xpath_expr_text,
data, namespaces,
4522 xpath_internal(xpath_expr_text,
data, NULL,
4546 xpath_internal(xpath_expr_text,
data, namespaces,
4570 doc = xml_parse(
data, xmloption_arg,
true,
4628 static inline XmlTableBuilderData *
4631 XmlTableBuilderData *result;
4634 elog(
ERROR,
"%s called with invalid TableFuncScanState", fname);
4635 result = (XmlTableBuilderData *)
state->opaque;
4636 if (result->magic != XMLTABLE_CONTEXT_MAGIC)
4637 elog(
ERROR,
"%s called with invalid TableFuncScanState", fname);
4658 volatile xmlParserCtxtPtr ctxt = NULL;
4659 XmlTableBuilderData *xtCxt;
4662 xtCxt =
palloc0(
sizeof(XmlTableBuilderData));
4663 xtCxt->magic = XMLTABLE_CONTEXT_MAGIC;
4664 xtCxt->natts = natts;
4665 xtCxt->xpathscomp =
palloc0(
sizeof(xmlXPathCompExprPtr) * natts);
4673 ctxt = xmlNewParserCtxt();
4674 if (ctxt == NULL || xmlerrcxt->err_occurred)
4676 "could not allocate parser context");
4681 xmlFreeParserCtxt(ctxt);
4689 xtCxt->xmlerrcxt = xmlerrcxt;
4692 state->opaque = xtCxt;
4706 XmlTableBuilderData *xtCxt;
4711 volatile xmlDocPtr doc = NULL;
4712 volatile xmlXPathContextPtr xpathcxt = NULL;
4714 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableSetDocument");
4722 length = strlen(
str);
4723 xstr = pg_xmlCharStrndup(
str, length);
4727 doc = xmlCtxtReadMemory(xtCxt->ctxt, (
char *) xstr, length, NULL, NULL, 0);
4728 if (doc == NULL || xtCxt->xmlerrcxt->err_occurred)
4730 "could not parse XML document");
4731 xpathcxt = xmlXPathNewContext(doc);
4732 if (xpathcxt == NULL || xtCxt->xmlerrcxt->err_occurred)
4734 "could not allocate XPath context");
4735 xpathcxt->node = (xmlNodePtr) doc;
4739 if (xpathcxt != NULL)
4740 xmlXPathFreeContext(xpathcxt);
4749 xtCxt->xpathcxt = xpathcxt;
4763 XmlTableBuilderData *xtCxt;
4767 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4768 errmsg(
"DEFAULT namespace is not supported")));
4769 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableSetNamespace");
4771 if (xmlXPathRegisterNs(xtCxt->xpathcxt,
4772 pg_xmlCharStrndup(
name, strlen(
name)),
4773 pg_xmlCharStrndup(uri, strlen(uri))))
4775 "could not set XML namespace");
4789 XmlTableBuilderData *xtCxt;
4792 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableSetRowFilter");
4796 (
errcode(ERRCODE_DATA_EXCEPTION),
4797 errmsg(
"row path filter must not be empty string")));
4799 xstr = pg_xmlCharStrndup(path, strlen(path));
4801 xtCxt->xpathcomp = xmlXPathCompile(xstr);
4802 if (xtCxt->xpathcomp == NULL || xtCxt->xmlerrcxt->err_occurred)
4804 "invalid XPath expression");
4818 XmlTableBuilderData *xtCxt;
4823 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableSetColumnFilter");
4827 (
errcode(ERRCODE_DATA_EXCEPTION),
4828 errmsg(
"column path filter must not be empty string")));
4830 xstr = pg_xmlCharStrndup(path, strlen(path));
4832 xtCxt->xpathscomp[colnum] = xmlXPathCompile(xstr);
4833 if (xtCxt->xpathscomp[colnum] == NULL || xtCxt->xmlerrcxt->err_occurred)
4835 "invalid XPath expression");
4850 XmlTableBuilderData *xtCxt;
4852 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableFetchRow");
4855 xmlSetStructuredErrorFunc((
void *) xtCxt->xmlerrcxt, xml_errorHandler);
4857 if (xtCxt->xpathobj == NULL)
4859 xtCxt->xpathobj = xmlXPathCompiledEval(xtCxt->xpathcomp, xtCxt->xpathcxt);
4860 if (xtCxt->xpathobj == NULL || xtCxt->xmlerrcxt->err_occurred)
4862 "could not create XPath object");
4864 xtCxt->row_count = 0;
4867 if (xtCxt->xpathobj->type == XPATH_NODESET)
4869 if (xtCxt->xpathobj->nodesetval != NULL)
4871 if (xtCxt->row_count++ < xtCxt->xpathobj->nodesetval->nodeNr)
4893 Oid typid,
int32 typmod,
bool *isnull)
4896 XmlTableBuilderData *xtCxt;
4900 volatile xmlXPathObjectPtr xpathobj = NULL;
4902 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableGetValue");
4904 Assert(xtCxt->xpathobj &&
4905 xtCxt->xpathobj->type == XPATH_NODESET &&
4906 xtCxt->xpathobj->nodesetval != NULL);
4909 xmlSetStructuredErrorFunc((
void *) xtCxt->xmlerrcxt, xml_errorHandler);
4913 cur = xtCxt->xpathobj->nodesetval->nodeTab[xtCxt->row_count - 1];
4915 Assert(xtCxt->xpathscomp[colnum] != NULL);
4920 xtCxt->xpathcxt->node =
cur;
4923 xpathobj = xmlXPathCompiledEval(xtCxt->xpathscomp[colnum], xtCxt->xpathcxt);
4924 if (xpathobj == NULL || xtCxt->xmlerrcxt->err_occurred)
4926 "could not create XPath object");
4935 if (xpathobj->type == XPATH_NODESET)
4939 if (xpathobj->nodesetval != NULL)
4940 count = xpathobj->nodesetval->nodeNr;
4942 if (xpathobj->nodesetval == NULL || count == 0)
4948 if (typid == XMLOID)
4955 for (
int i = 0;
i < count;
i++)
4958 xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[
i],
4971 (
errcode(ERRCODE_CARDINALITY_VIOLATION),
4972 errmsg(
"more than one value returned by column XPath expression")));
4974 str = xmlXPathCastNodeSetToString(xpathobj->nodesetval);
4975 cstr =
str ? xml_pstrdup_and_free(
str) :
"";
4979 else if (xpathobj->type == XPATH_STRING)
4982 if (typid == XMLOID)
4983 cstr =
escape_xml((
char *) xpathobj->stringval);
4985 cstr = (
char *) xpathobj->stringval;
4987 else if (xpathobj->type == XPATH_BOOLEAN)
4990 bool typispreferred;
4996 if (typcategory != TYPCATEGORY_NUMERIC)
4997 str = xmlXPathCastBooleanToString(xpathobj->boolval);
4999 str = xmlXPathCastNumberToString(xmlXPathCastBooleanToNumber(xpathobj->boolval));
5001 cstr = xml_pstrdup_and_free(
str);
5003 else if (xpathobj->type == XPATH_NUMBER)
5007 str = xmlXPathCastNumberToString(xpathobj->floatval);
5008 cstr = xml_pstrdup_and_free(
str);
5011 elog(
ERROR,
"unexpected XPath object type %u", xpathobj->type);
5022 state->typioparams[colnum],
5027 if (xpathobj != NULL)
5028 xmlXPathFreeObject(xpathobj);
5047 XmlTableBuilderData *xtCxt;
5049 xtCxt = GetXmlTableBuilderPrivateData(
state,
"XmlTableDestroyOpaque");
5052 xmlSetStructuredErrorFunc((
void *) xtCxt->xmlerrcxt, xml_errorHandler);
5054 if (xtCxt->xpathscomp != NULL)
5058 for (
i = 0;
i < xtCxt->natts;
i++)
5059 if (xtCxt->xpathscomp[
i] != NULL)
5060 xmlXPathFreeCompExpr(xtCxt->xpathscomp[
i]);
5063 if (xtCxt->xpathobj != NULL)
5064 xmlXPathFreeObject(xtCxt->xpathobj);
5065 if (xtCxt->xpathcomp != NULL)
5066 xmlXPathFreeCompExpr(xtCxt->xpathcomp);
5067 if (xtCxt->xpathcxt != NULL)
5068 xmlXPathFreeContext(xtCxt->xpathcxt);
5069 if (xtCxt->doc != NULL)
5070 xmlFreeDoc(xtCxt->doc);
5071 if (xtCxt->ctxt != NULL)
5072 xmlFreeParserCtxt(xtCxt->ctxt);
5078 state->opaque = NULL;
#define PG_GETARG_ARRAYTYPE_P(n)
#define DatumGetArrayTypeP(X)
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
void deconstruct_array_builtin(ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
void j2date(int jd, int *year, int *month, int *day)
void EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str)
void EncodeDateOnly(struct pg_tm *tm, int style, char *str)
int timestamp2tm(Timestamp dt, int *tzp, struct pg_tm *tm, fsec_t *fsec, const char **tzn, pg_tz *attimezone)
#define TextDatumGetCString(d)
#define Assert(condition)
#define PointerIsValid(pointer)
#define OidIsValid(objectId)
#define TIMESTAMP_NOT_FINITE(j)
#define POSTGRES_EPOCH_JDATE
#define DATE_NOT_FINITE(j)
static DateADT DatumGetDateADT(Datum X)
char * get_database_name(Oid dbid)
static void PGresult * res
int errmsg_internal(const char *fmt,...)
int errdetail_internal(const char *fmt,...)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define errsave(context,...)
#define ereport(elevel,...)
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Datum Float8GetDatum(float8 X)
char * OidOutputFunctionCall(Oid functionId, Datum val)
#define PG_GETARG_TEXT_PP(n)
#define PG_RETURN_BYTEA_P(x)
#define DatumGetByteaPP(X)
#define PG_GETARG_POINTER(n)
#define PG_RETURN_CSTRING(x)
#define DirectFunctionCall1(func, arg1)
#define PG_GETARG_CSTRING(n)
#define PG_GETARG_NAME(n)
#define PG_RETURN_TEXT_P(x)
#define PG_GETARG_INT32(n)
#define PG_GETARG_BOOL(n)
#define PG_RETURN_DATUM(x)
#define PG_RETURN_BOOL(x)
#define HeapTupleIsValid(tuple)
if(TABLE==NULL||TABLE_index==NULL)
List * lappend(List *list, void *datum)
List * lappend_oid(List *list, Oid datum)
List * list_append_unique_oid(List *list, Oid datum)
char * get_namespace_name(Oid nspid)
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
char * get_rel_name(Oid relid)
char get_typtype(Oid typid)
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Oid getBaseType(Oid typid)
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
#define type_is_array_domain(typid)
unsigned char * pg_do_encoding_conversion(unsigned char *src, int len, int src_encoding, int dest_encoding)
char * pg_any_to_server(const char *s, int len, int encoding)
int GetDatabaseEncoding(void)
void pg_unicode_to_server(pg_wchar c, unsigned char *s)
int pg_get_client_encoding(void)
int pg_encoding_mb2wchar_with_len(int encoding, const char *from, pg_wchar *to, int len)
char * pg_server_to_any(const char *s, int len, int encoding)
int pg_mblen(const char *mbstr)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
void * repalloc(void *pointer, Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
char * MemoryContextStrdup(MemoryContext context, const char *string)
#define AllocSetContextCreate
#define ALLOCSET_DEFAULT_SIZES
Oid LookupExplicitNamespace(const char *nspname, bool missing_ok)
Oid exprType(const Node *expr)
#define IsA(nodeptr, _type_)
FormData_pg_attribute * Form_pg_attribute
FormData_pg_class * Form_pg_class
#define forboth(cell1, list1, cell2, list2)
#define list_make2(x1, x2)
FormData_pg_type * Form_pg_type
#define MAX_MULTIBYTE_CHAR_LEN
#define MAX_UNICODE_EQUIVALENT_STRING
#define pg_encoding_to_char
#define pg_char_to_encoding
int pg_strcasecmp(const char *s1, const char *s2)
size_t strnlen(const char *str, size_t maxlen)
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
static bool DatumGetBool(Datum X)
static Datum PointerGetDatum(const void *X)
static char * DatumGetCString(Datum X)
static Oid DatumGetObjectId(Datum X)
static Datum BoolGetDatum(bool X)
static Datum ObjectIdGetDatum(Oid X)
static Datum CStringGetDatum(const char *X)
Datum regclassout(PG_FUNCTION_ARGS)
static pg_noinline void Size size
Oid SPI_gettypeid(TupleDesc tupdesc, int fnumber)
SPITupleTable * SPI_tuptable
Portal SPI_cursor_find(const char *name)
const char * SPI_result_code_string(int code)
void SPI_cursor_fetch(Portal portal, bool forward, long count)
Portal SPI_cursor_open(const char *name, SPIPlanPtr plan, Datum *Values, const char *Nulls, bool read_only)
SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes)
void SPI_cursor_close(Portal portal)
void * SPI_palloc(Size size)
char * SPI_fname(TupleDesc tupdesc, int fnumber)
int SPI_execute(const char *src, bool read_only, long tcount)
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
void destroyStringInfo(StringInfo str)
StringInfo makeStringInfo(void)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
void appendStringInfoString(StringInfo str, const char *s)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
StringInfoData * StringInfo
#define appendStringInfoCharMacro(str, ch)
void(* InitOpaque)(struct TableFuncScanState *state, int natts)
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
struct TupleDescData * TupleDesc
#define TupleDescAttr(tupdesc, i)
static Timestamp DatumGetTimestamp(Datum X)
#define SET_VARSIZE(PTR, len)
#define VARSIZE_ANY_EXHDR(PTR)
static void appendStringInfoText(StringInfo str, const text *t)
char * text_to_cstring(const text *t)
text * cstring_to_text_with_len(const char *s, int len)
text * cstring_to_text(const char *s)
int pg_encoding_mblen(int encoding, const char *mbstr)
Datum xml_in(PG_FUNCTION_ARGS)
Datum cursor_to_xmlschema(PG_FUNCTION_ARGS)
static char * _SPI_strdup(const char *s)
xmltype * xmlconcat(List *args)
Datum table_to_xml(PG_FUNCTION_ARGS)
Datum query_to_xmlschema(PG_FUNCTION_ARGS)
Datum database_to_xml(PG_FUNCTION_ARGS)
static List * database_get_xml_visible_tables(void)
static const char * map_sql_catalog_to_xmlschema_types(List *nspid_list, bool nulls, bool tableforest, const char *targetns)
static char * map_multipart_sql_identifier_to_xml_name(const char *a, const char *b, const char *c, const char *d)
static void XmlTableInitOpaque(struct TableFuncScanState *state, int natts)
static const char * map_sql_type_to_xml_name(Oid typeoid, int typmod)
static const char * map_sql_type_to_xmlschema_type(Oid typeoid, int typmod)
Datum texttoxml(PG_FUNCTION_ARGS)
static void xsd_schema_element_start(StringInfo result, const char *targetns)
Datum query_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
Datum xmltotext(PG_FUNCTION_ARGS)
Datum schema_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
Datum xmlexists(PG_FUNCTION_ARGS)
Datum xmltext(PG_FUNCTION_ARGS)
static List * query_to_oid_list(const char *query)
static char * xml_out_internal(xmltype *x, pg_enc target_encoding)
static xmltype * stringinfo_to_xmltype(StringInfo buf)
static StringInfo database_to_xmlschema_internal(bool nulls, bool tableforest, const char *targetns)
Datum database_to_xmlschema(PG_FUNCTION_ARGS)
Datum schema_to_xmlschema(PG_FUNCTION_ARGS)
static void xmldata_root_element_start(StringInfo result, const char *eltname, const char *xmlschema, const char *targetns, bool top_level)
Datum xml_send(PG_FUNCTION_ARGS)
static const char * map_sql_schema_to_xmlschema_types(Oid nspid, List *relid_list, bool nulls, bool tableforest, const char *targetns)
const TableFuncRoutine XmlTableRoutine
Datum xmlcomment(PG_FUNCTION_ARGS)
static void XmlTableSetNamespace(struct TableFuncScanState *state, const char *name, const char *uri)
Datum xmlconcat2(PG_FUNCTION_ARGS)
static void XmlTableSetRowFilter(struct TableFuncScanState *state, const char *path)
static void xmldata_root_element_end(StringInfo result, const char *eltname)
text * xmltotext_with_options(xmltype *data, XmlOptionType xmloption_arg, bool indent)
xmltype * xmlparse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace)
static Datum XmlTableGetValue(struct TableFuncScanState *state, int colnum, Oid typid, int32 typmod, bool *isnull)
static xmltype * cstring_to_xmltype(const char *string)
Datum xml_is_well_formed_document(PG_FUNCTION_ARGS)
Datum query_to_xml(PG_FUNCTION_ARGS)
char * map_sql_identifier_to_xml_name(const char *ident, bool fully_escaped, bool escape_period)
static StringInfo database_to_xml_internal(const char *xmlschema, bool nulls, bool tableforest, const char *targetns)
Datum xml_is_well_formed_content(PG_FUNCTION_ARGS)
#define XML_VISIBLE_SCHEMAS
bool xml_is_document(xmltype *arg)
static StringInfo schema_to_xmlschema_internal(const char *schemaname, bool nulls, bool tableforest, const char *targetns)
static List * schema_get_xml_visible_tables(Oid nspid)
char * escape_xml(const char *str)
Datum table_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
Datum xmlvalidate(PG_FUNCTION_ARGS)
static void XmlTableSetDocument(struct TableFuncScanState *state, Datum value)
static void XmlTableDestroyOpaque(struct TableFuncScanState *state)
char * map_xml_name_to_sql_identifier(const char *name)
static const char * map_sql_typecoll_to_xmlschema_types(List *tupdesc_list)
xmltype * xmlpi(const char *target, text *arg, bool arg_is_null, bool *result_is_null)
#define PG_XML_DEFAULT_VERSION
Datum table_to_xmlschema(PG_FUNCTION_ARGS)
static StringInfo query_to_xml_internal(const char *query, char *tablename, const char *xmlschema, bool nulls, bool tableforest, const char *targetns, bool top_level)
static void SPI_sql_row_to_xmlelement(uint64 rownum, StringInfo result, char *tablename, bool nulls, bool tableforest, const char *targetns, bool top_level)
static StringInfo schema_to_xml_internal(Oid nspid, const char *xmlschema, bool nulls, bool tableforest, const char *targetns, bool top_level)
static StringInfo table_to_xml_internal(Oid relid, const char *xmlschema, bool nulls, bool tableforest, const char *targetns, bool top_level)
Datum schema_to_xml(PG_FUNCTION_ARGS)
Datum database_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
char * map_sql_value_to_xml_value(Datum value, Oid type, bool xml_escape_strings)
static bool XmlTableFetchRow(struct TableFuncScanState *state)
Datum cursor_to_xml(PG_FUNCTION_ARGS)
Datum xpath_exists(PG_FUNCTION_ARGS)
Datum xml_is_well_formed(PG_FUNCTION_ARGS)
xmltype * xmlelement(XmlExpr *xexpr, Datum *named_argvalue, bool *named_argnull, Datum *argvalue, bool *argnull)
static void XmlTableSetColumnFilter(struct TableFuncScanState *state, const char *path, int colnum)
static const char * map_sql_table_to_xmlschema(TupleDesc tupdesc, Oid relid, bool nulls, bool tableforest, const char *targetns)
Datum xml_out(PG_FUNCTION_ARGS)
Datum xml_recv(PG_FUNCTION_ARGS)
xmltype * xmlroot(xmltype *data, text *version, int standalone)
Datum xpath(PG_FUNCTION_ARGS)
static void xsd_schema_element_end(StringInfo result)
static List * database_get_xml_visible_schemas(void)
@ XML_STANDALONE_NO_VALUE
struct PgXmlErrorContext PgXmlErrorContext
static xmltype * DatumGetXmlP(Datum X)
#define PG_RETURN_XML_P(x)
void xml_ereport(PgXmlErrorContext *errcxt, int level, int sqlcode, const char *msg)
bool pg_xml_error_occurred(PgXmlErrorContext *errcxt)
void pg_xml_done(PgXmlErrorContext *errcxt, bool isError)
PgXmlErrorContext * pg_xml_init(PgXmlStrictness strictness)
#define PG_GETARG_XML_P(n)
void pg_xml_init_library(void)
@ PG_XML_STRICTNESS_LEGACY
@ PG_XML_STRICTNESS_WELLFORMED