#include <libxml/xmlerror.h>
#include <libxml/parserInternals.h>
-/* declarations */
-
-static void *pgxml_palloc(size_t size);
-static void *pgxml_repalloc(void *ptr, size_t size);
-static void pgxml_pfree(void *ptr);
-static char *pgxml_pstrdup(const char *string);
-static void pgxml_errorHandler(void *ctxt, const char *msg,...);
-
-void elog_error(int level, char *explain, int force);
-void pgxml_parser_init(void);
-
-static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
- xmlChar * toptagname, xmlChar * septagname,
- xmlChar * plainsep);
-
-text *pgxml_result_to_text(xmlXPathObjectPtr res, xmlChar * toptag,
- xmlChar * septag, xmlChar * plainsep);
-
-xmlChar *pgxml_texttoxmlchar(text *textstring);
-
-static xmlXPathObjectPtr pgxml_xpath(text *document, xmlChar * xpath);
-
+/* externally accessible functions */
Datum xml_valid(PG_FUNCTION_ARGS);
Datum xml_encode_special_chars(PG_FUNCTION_ARGS);
Datum xpath_list(PG_FUNCTION_ARGS);
Datum xpath_table(PG_FUNCTION_ARGS);
-/* Global variables */
-char *errbuf; /* per line error buffer */
-char *pgxml_errorMsg = NULL; /* overall error message */
+/* these are exported for use by xslt_proc.c */
-/* Convenience macros */
+void elog_error(const char *explain, bool force);
+void pgxml_parser_init(void);
-#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
-#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
+/* local declarations */
-#define ERRBUF_SIZE 200
+static void pgxml_errorHandler(void *ctxt, const char *msg,...);
-/* memory handling passthrough functions (e.g. palloc, pstrdup are
- currently macros, and the others might become so...) */
+static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
+ xmlChar *toptagname, xmlChar *septagname,
+ xmlChar *plainsep);
-static void *
-pgxml_palloc(size_t size)
-{
-/* elog(DEBUG1,"Alloc %d in CMC %x",size,CurrentMemoryContext); */
- return palloc(size);
-}
+static text *pgxml_result_to_text(xmlXPathObjectPtr res, xmlChar *toptag,
+ xmlChar *septag, xmlChar *plainsep);
-static void *
-pgxml_repalloc(void *ptr, size_t size)
-{
-/* elog(DEBUG1,"ReAlloc in CMC %x",CurrentMemoryContext);*/
- return repalloc(ptr, size);
-}
+static xmlChar *pgxml_texttoxmlchar(text *textstring);
-static void
-pgxml_pfree(void *ptr)
-{
-/* elog(DEBUG1,"Free in CMC %x",CurrentMemoryContext); */
- pfree(ptr);
-}
+static xmlXPathObjectPtr pgxml_xpath(text *document, xmlChar *xpath);
-static char *
-pgxml_pstrdup(const char *string)
-{
- return pstrdup(string);
-}
+/* Global variables */
+static char *pgxml_errorMsg = NULL; /* overall error message */
-/* The error handling function. This formats an error message and sets
+#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
+
+
+/*
+ * The error handling function. This formats an error message and sets
* a flag - an ereport will be issued prior to return
*/
-
static void
pgxml_errorHandler(void *ctxt, const char *msg,...)
{
+ char errbuf[1024]; /* per line error buffer */
va_list args;
+ /* Format the message */
va_start(args, msg);
- vsnprintf(errbuf, ERRBUF_SIZE, msg, args);
+ vsnprintf(errbuf, sizeof(errbuf), msg, args);
va_end(args);
- /* Now copy the argument across */
+ /* Store in, or append to, pgxml_errorMsg */
if (pgxml_errorMsg == NULL)
pgxml_errorMsg = pstrdup(errbuf);
else
{
- int32 xsize = strlen(pgxml_errorMsg);
-
- pgxml_errorMsg = repalloc(pgxml_errorMsg,
- (size_t) (xsize + strlen(errbuf) + 1));
- strncpy(&pgxml_errorMsg[xsize - 1], errbuf, strlen(errbuf));
- pgxml_errorMsg[xsize + strlen(errbuf) - 1] = '\0';
+ size_t oldsize = strlen(pgxml_errorMsg);
+ size_t newsize = strlen(errbuf);
+ /*
+ * We intentionally discard the last char of the existing message,
+ * which should be a carriage return. (XXX wouldn't it be saner
+ * to keep it?)
+ */
+ pgxml_errorMsg = repalloc(pgxml_errorMsg, oldsize + newsize);
+ memcpy(&pgxml_errorMsg[oldsize - 1], errbuf, newsize);
+ pgxml_errorMsg[oldsize + newsize - 1] = '\0';
}
- memset(errbuf, 0, ERRBUF_SIZE);
}
-/* This function reports the current message at the level specified */
+/*
+ * This function ereports the current message if any. If force is true
+ * then an error is thrown even if pgxml_errorMsg hasn't been set.
+ */
void
-elog_error(int level, char *explain, int force)
+elog_error(const char *explain, bool force)
{
- if (force || (pgxml_errorMsg != NULL))
+ if (force || pgxml_errorMsg != NULL)
{
if (pgxml_errorMsg == NULL)
- {
- ereport(level, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
- errmsg(explain)));
- }
+ ereport(ERROR,
+ (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
+ errmsg("%s", explain)));
else
- {
- ereport(level, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
- errmsg("%s:%s", explain, pgxml_errorMsg)));
- pfree(pgxml_errorMsg);
- }
+ ereport(ERROR,
+ (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
+ errmsg("%s: %s", explain, pgxml_errorMsg)));
}
}
+/*
+ * Initialize for xml parsing.
+ */
void
-pgxml_parser_init()
+pgxml_parser_init(void)
{
- /*
- * This code could also set parser settings from user-supplied info.
- * Quite how these settings are made is another matter :)
- */
+ /* Set up error handling */
+ pgxml_errorMsg = NULL;
+ xmlSetGenericErrorFunc(NULL, pgxml_errorHandler);
- xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
+ /* Initialize libxml */
xmlInitParser();
- xmlSetGenericErrorFunc(NULL, pgxml_errorHandler);
-
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
-
- pgxml_errorMsg = NULL;
-
- errbuf = palloc(200);
- memset(errbuf, 0, 200);
-
}
Datum
xml_valid(PG_FUNCTION_ARGS)
{
- /* called as xml_valid(document) */
- xmlDocPtr doctree;
text *t = PG_GETARG_TEXT_P(0); /* document buffer */
int32 docsize = VARSIZE(t) - VARHDRSZ;
+ xmlDocPtr doctree;
pgxml_parser_init();
xmlCleanupParser();
PG_RETURN_BOOL(false); /* i.e. not well-formed */
}
- xmlCleanupParser();
xmlFreeDoc(doctree);
+ xmlCleanupParser();
PG_RETURN_BOOL(true);
}
PG_RETURN_TEXT_P(tout);
}
-static xmlChar
-*
+/*
+ * Function translates a nodeset into a text representation
+ *
+ * iterates over each node in the set and calls xmlNodeDump to write it to
+ * an xmlBuffer -from which an xmlChar * string is returned.
+ *
+ * each representation is surrounded by <tagname> ... </tagname>
+ *
+ * plainsep is an ordinary (not tag) separator - if used, then nodes are
+ * cast to string as output method
+ */
+static xmlChar *
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
- xmlChar * toptagname,
- xmlChar * septagname,
- xmlChar * plainsep)
+ xmlChar *toptagname,
+ xmlChar *septagname,
+ xmlChar *plainsep)
{
- /* Function translates a nodeset into a text representation */
-
- /*
- * iterates over each node in the set and calls xmlNodeDump to write
- * it to an xmlBuffer -from which an xmlChar * string is returned.
- */
-
- /* each representation is surrounded by <tagname> ... </tagname> */
-
- /*
- * plainsep is an ordinary (not tag) seperator - if used, then nodes
- * are cast to string as output method
- */
-
-
xmlBufferPtr buf;
xmlChar *result;
int i;
{
for (i = 0; i < nodeset->nodeNr; i++)
{
-
if (plainsep != NULL)
{
xmlBufferWriteCHAR(buf,
}
else
{
-
-
if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
{
xmlBufferWriteChar(buf, "<");
/* Translate a PostgreSQL "varlena" -i.e. a variable length parameter
* into the libxml2 representation
*/
-
-xmlChar *
+static xmlChar *
pgxml_texttoxmlchar(text *textstring)
{
xmlChar *res;
return res;
}
-/* Public visible XPath functions */
+/* Publicly visible XPath functions */
-/* This is a "raw" xpath function. Check that it returns child elements
+/*
+ * This is a "raw" xpath function. Check that it returns child elements
* properly
*/
-
PG_FUNCTION_INFO_V1(xpath_nodeset);
Datum
*toptag,
*septag;
int32 pathsize;
- text
- *xpathsupp,
+ text *xpathsupp,
*xpres;
/* PG_GETARG_TEXT_P(0) is document buffer */
xpath = pgxml_texttoxmlchar(xpathsupp);
- xpres = pgxml_result_to_text(
- pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
+ xpres = pgxml_result_to_text(pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
toptag, septag, NULL);
/* xmlCleanupParser(); done by result_to_text routine */
PG_RETURN_TEXT_P(xpres);
}
-/* The following function is almost identical, but returns the elements in */
-/* a list. */
-
+/*
+ * The following function is almost identical, but returns the elements in
+ * a list.
+ */
PG_FUNCTION_INFO_V1(xpath_list);
Datum
xmlChar *xpath,
*plainsep;
int32 pathsize;
- text
- *xpathsupp,
+ text *xpathsupp,
*xpres;
/* PG_GETARG_TEXT_P(0) is document buffer */
xpath = pgxml_texttoxmlchar(xpathsupp);
- xpres = pgxml_result_to_text(
- pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
+ xpres = pgxml_result_to_text(pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
NULL, NULL, plainsep);
/* xmlCleanupParser(); done by result_to_text routine */
{
xmlChar *xpath;
int32 pathsize;
- text
- *xpathsupp,
+ text *xpathsupp,
*xpres;
/* PG_GETARG_TEXT_P(0) is document buffer */
xpath[pathsize + 7] = ')';
xpath[pathsize + 8] = '\0';
- xpres = pgxml_result_to_text(
- pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
+ xpres = pgxml_result_to_text(pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
NULL, NULL, NULL);
xmlCleanupParser();
{
xmlChar *xpath;
int32 pathsize;
- text
- *xpathsupp;
-
+ text *xpathsupp;
float4 fRes;
xmlXPathObjectPtr res;
PG_RETURN_NULL();
PG_RETURN_FLOAT4(fRes);
-
}
{
xmlChar *xpath;
int32 pathsize;
- text
- *xpathsupp;
-
+ text *xpathsupp;
int bRes;
xmlXPathObjectPtr res;
bRes = xmlXPathCastToBoolean(res);
xmlCleanupParser();
PG_RETURN_BOOL(bRes);
-
}
/* Core function to evaluate XPath query */
-xmlXPathObjectPtr
-pgxml_xpath(text *document, xmlChar * xpath)
+static xmlXPathObjectPtr
+pgxml_xpath(text *document, xmlChar *xpath)
{
-
xmlDocPtr doctree;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
-
xmlXPathCompExprPtr comppath;
-
int32 docsize;
-
docsize = VARSIZE(document) - VARHDRSZ;
pgxml_parser_init();
ctxt = xmlXPathNewContext(doctree);
ctxt->node = xmlDocGetRootElement(doctree);
-
/* compile the path */
comppath = xmlXPathCompile(xpath);
if (comppath == NULL)
{
xmlCleanupParser();
xmlFreeDoc(doctree);
- elog_error(ERROR, "XPath Syntax Error", 1);
-
- return NULL;
+ elog_error("XPath Syntax Error", true);
}
/* Now evaluate the path expression. */
return res;
}
-text
- *
+static text *
pgxml_result_to_text(xmlXPathObjectPtr res,
- xmlChar * toptag,
- xmlChar * septag,
- xmlChar * plainsep)
+ xmlChar *toptag,
+ xmlChar *septag,
+ xmlChar *plainsep)
{
xmlChar *xpresstr;
int32 ressize;
xpresstr = xmlStrdup("<unsupported/>");
}
-
/* Now convert this result back to text */
ressize = strlen(xpresstr);
xpres = (text *) palloc(ressize + VARHDRSZ);
xmlFree(xpresstr);
- elog_error(ERROR, "XPath error", 0);
-
+ elog_error("XPath error", false);
return xpres;
}
-/* xpath_table is a table function. It needs some tidying (as do the
+/*
+ * xpath_table is a table function. It needs some tidying (as do the
* other functions here!
*/
-
PG_FUNCTION_INFO_V1(xpath_table);
Datum
xpath_table(PG_FUNCTION_ARGS)
{
-/* SPI (input tuple) support */
+ /* Function parameters */
+ char *pkeyfield = GET_STR(PG_GETARG_TEXT_P(0));
+ char *xmlfield = GET_STR(PG_GETARG_TEXT_P(1));
+ char *relname = GET_STR(PG_GETARG_TEXT_P(2));
+ char *xpathset = GET_STR(PG_GETARG_TEXT_P(3));
+ char *condition = GET_STR(PG_GETARG_TEXT_P(4));
+
+ /* SPI (input tuple) support */
SPITupleTable *tuptable;
HeapTuple spi_tuple;
TupleDesc spi_tupdesc;
-/* Output tuple (tuplestore) support */
+ /* Output tuple (tuplestore) support */
Tuplestorestate *tupstore = NULL;
TupleDesc ret_tupdesc;
HeapTuple ret_tuple;
MemoryContext per_query_ctx;
MemoryContext oldcontext;
-/* Function parameters */
- char *pkeyfield = GET_STR(PG_GETARG_TEXT_P(0));
- char *xmlfield = GET_STR(PG_GETARG_TEXT_P(1));
- char *relname = GET_STR(PG_GETARG_TEXT_P(2));
- char *xpathset = GET_STR(PG_GETARG_TEXT_P(3));
- char *condition = GET_STR(PG_GETARG_TEXT_P(4));
-
char **values;
xmlChar **xpaths;
xmlChar *pos;
int proc;
int i;
int j;
- int rownr; /* For issuing multiple rows from one
- * original document */
- int had_values; /* To determine end of nodeset results */
-
- StringInfo querysql;
+ int rownr; /* For issuing multiple rows from one original
+ * document */
+ bool had_values; /* To determine end of nodeset results */
+ StringInfoData query_buf;
/* We only have a valid tuple description in table function mode */
if (rsinfo->expectedDesc == NULL)
errmsg("xpath_table must be called as a table function")));
}
-/* The tuplestore must exist in a higher context than
- * this function call (per_query_ctx is used) */
-
+ /*
+ * The tuplestore must exist in a higher context than this function call
+ * (per_query_ctx is used)
+ */
per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
oldcontext = MemoryContextSwitchTo(per_query_ctx);
attinmeta = TupleDescGetAttInMetadata(ret_tupdesc);
+ /* must have at least one output column (for the pkey) */
+ if (ret_tupdesc->natts < 1)
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("xpath_table must have at least one output column")));
+
/*
* We want to materialise because it means that we don't have to carry
* libxml2 parser state between invocations of this function
rsinfo->setDesc = ret_tupdesc;
values = (char **) palloc(ret_tupdesc->natts * sizeof(char *));
-
xpaths = (xmlChar **) palloc(ret_tupdesc->natts * sizeof(xmlChar *));
- /* Split XPaths. xpathset is a writable CString. */
-
- /* Note that we stop splitting once we've done all needed for tupdesc */
-
+ /*
+ * Split XPaths. xpathset is a writable CString.
+ *
+ * Note that we stop splitting once we've done all needed for tupdesc
+ */
numpaths = 0;
pos = xpathset;
- do
+ while (numpaths < (ret_tupdesc->natts - 1))
{
- xpaths[numpaths] = pos;
+ xpaths[numpaths++] = (xmlChar *) pos;
pos = strstr(pos, pathsep);
if (pos != NULL)
{
*pos = '\0';
pos++;
}
- numpaths++;
- } while ((pos != NULL) && (numpaths < (ret_tupdesc->natts - 1)));
+ else
+ break;
+ }
/* Now build query */
-
- querysql = makeStringInfo();
+ initStringInfo(&query_buf);
/* Build initial sql statement */
- appendStringInfo(querysql, "SELECT %s, %s FROM %s WHERE %s",
+ appendStringInfo(&query_buf, "SELECT %s, %s FROM %s WHERE %s",
pkeyfield,
xmlfield,
relname,
- condition
- );
-
+ condition);
if ((ret = SPI_connect()) < 0)
elog(ERROR, "xpath_table: SPI_connect returned %d", ret);
- if ((ret = SPI_exec(querysql->data, 0)) != SPI_OK_SELECT)
- elog(ERROR, "xpath_table: SPI execution failed for query %s", querysql->data);
+ if ((ret = SPI_exec(query_buf.data, 0)) != SPI_OK_SELECT)
+ elog(ERROR, "xpath_table: SPI execution failed for query %s",
+ query_buf.data);
proc = SPI_processed;
/* elog(DEBUG1,"xpath_table: SPI returned %d rows",proc); */
tuptable = SPI_tuptable;
spi_tupdesc = tuptable->tupdesc;
-/* Switch out of SPI context */
+ /* Switch out of SPI context */
MemoryContextSwitchTo(oldcontext);
-
-/* Check that SPI returned correct result. If you put a comma into one of
- * the function parameters, this will catch it when the SPI query returns
- * e.g. 3 columns.
- */
-
+ /*
+ * Check that SPI returned correct result. If you put a comma into one of
+ * the function parameters, this will catch it when the SPI query returns
+ * e.g. 3 columns.
+ */
if (spi_tupdesc->natts != 2)
{
ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errdetail("Expected two columns in SPI result, got %d", spi_tupdesc->natts)));
}
-/* Setup the parser. Beware that this must happen in the same context as the
- * cleanup - which means that any error from here on must do cleanup to
- * ensure that the entity table doesn't get freed by being out of context.
- */
+ /*
+ * Setup the parser. Beware that this must happen in the same context as
+ * the cleanup - which means that any error from here on must do cleanup
+ * to ensure that the entity table doesn't get freed by being out of
+ * context.
+ */
pgxml_parser_init();
/* For each row i.e. document returned from SPI */
{
char *pkey;
char *xmldoc;
-
xmlDocPtr doctree;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
xmlChar *resstr;
-
-
xmlXPathCompExprPtr comppath;
/* Extract the row data as C Strings */
xmldoc = SPI_getvalue(spi_tuple, spi_tupdesc, 2);
/*
- * Clear the values array, so that not-well-formed documents
- * return NULL in all columns.
+ * Clear the values array, so that not-well-formed documents return
+ * NULL in all columns. Note that this also means that spare columns
+ * will be NULL.
*/
-
- /* Note that this also means that spare columns will be NULL. */
for (j = 0; j < ret_tupdesc->natts; j++)
values[j] = NULL;
do
{
/* Now evaluate the set of xpaths. */
- had_values = 0;
+ had_values = false;
for (j = 0; j < numpaths; j++)
{
-
ctxt = xmlXPathNewContext(doctree);
ctxt->node = xmlDocGetRootElement(doctree);
xmlSetGenericErrorFunc(ctxt, pgxml_errorHandler);
{
xmlCleanupParser();
xmlFreeDoc(doctree);
-
- elog_error(ERROR, "XPath Syntax Error", 1);
-
- PG_RETURN_NULL(); /* Keep compiler happy */
+ elog_error("XPath Syntax Error", true);
}
/* Now evaluate the path expression. */
{
case XPATH_NODESET:
/* We see if this nodeset has enough nodes */
- if ((res->nodesetval != NULL) && (rownr < res->nodesetval->nodeNr))
+ if (res->nodesetval != NULL &&
+ rownr < res->nodesetval->nodeNr)
{
resstr =
xmlXPathCastNodeToString(res->nodesetval->nodeTab[rownr]);
- had_values = 1;
+ had_values = true;
}
else
resstr = NULL;
resstr = xmlStrdup("<unsupported/>");
}
-
/*
* Insert this into the appropriate column in the
* result tuple.
}
xmlXPathFreeContext(ctxt);
}
+
/* Now add the tuple to the output, if there is one. */
if (had_values)
{
}
rownr++;
-
} while (had_values);
-
}
xmlFreeDoc(doctree);
}
xmlCleanupParser();
-/* Needed to flag completeness in 7.3.1. 7.4 defines it as a no-op. */
+
tuplestore_donestoring(tupstore);
SPI_finish();
* verify we did what it was expecting.
*/
return (Datum) 0;
-
}
projects / users / c2main / postgres.git / commitdiff