contrib/xml2/xpath.c

   1 /*
   2  * $PostgreSQL$
   3  *
   4  * Parser interface for DOM-based parser (libxml) rather than
   5  * stream-based SAX-type parser
   6  */
   7 #include "postgres.h"
   8
   9 #include "executor/spi.h"
  10 #include "fmgr.h"
  11 #include "funcapi.h"
  12 #include "lib/stringinfo.h"
  13 #include "miscadmin.h"
  14 #include "utils/builtins.h"
  15
  16 /* libxml includes */
  17
  18 #include <libxml/xpath.h>
  19 #include <libxml/tree.h>
  20 #include <libxml/xmlmemory.h>
  21 #include <libxml/xmlerror.h>
  22 #include <libxml/parserInternals.h>
  23
  24
  25 PG_MODULE_MAGIC;
  26
  27 /* declarations */
  28
  29 static void *pgxml_palloc(size_t size);
  30 static void *pgxml_repalloc(void *ptr, size_t size);
  31 static void pgxml_pfree(void *ptr);
  32 static char *pgxml_pstrdup(const char *string);
  33 static void pgxml_errorHandler(void *ctxt, const char *msg,...);
  34
  35 void            elog_error(int level, char *explain, int force);
  36 void            pgxml_parser_init(void);
  37
  38 static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
  39                                    xmlChar *toptagname, xmlChar *septagname,
  40                                    xmlChar *plainsep);
  41
  42 text *pgxml_result_to_text(xmlXPathObjectPtr res, xmlChar *toptag,
  43                                          xmlChar *septag, xmlChar *plainsep);
  44
  45 xmlChar    *pgxml_texttoxmlchar(text *textstring);
  46
  47 static xmlXPathObjectPtr pgxml_xpath(text *document, xmlChar *xpath);
  48
  49
  50 Datum           xml_is_well_formed(PG_FUNCTION_ARGS);
  51 Datum           xml_encode_special_chars(PG_FUNCTION_ARGS);
  52 Datum           xpath_nodeset(PG_FUNCTION_ARGS);
  53 Datum           xpath_string(PG_FUNCTION_ARGS);
  54 Datum           xpath_number(PG_FUNCTION_ARGS);
  55 Datum           xpath_bool(PG_FUNCTION_ARGS);
  56 Datum           xpath_list(PG_FUNCTION_ARGS);
  57 Datum           xpath_table(PG_FUNCTION_ARGS);
  58
  59 /* Global variables */
  60 char       *errbuf;                             /* per line error buffer */
  61 char       *pgxml_errorMsg = NULL;              /* overall error message */
  62
  63 #define ERRBUF_SIZE 200
  64
  65 /* memory handling passthrough functions (e.g. palloc, pstrdup are
  66    currently macros, and the others might become so...) */
  67
  68 static void *
  69 pgxml_palloc(size_t size)
  70 {
  71 /*      elog(DEBUG1,"Alloc %d in CMC %p",size,CurrentMemoryContext); */
  72         return palloc(size);
  73 }
  74
  75 static void *
  76 pgxml_repalloc(void *ptr, size_t size)
  77 {
  78 /*      elog(DEBUG1,"ReAlloc in CMC %p",CurrentMemoryContext);*/
  79         return repalloc(ptr, size);
  80 }
  81
  82 static void
  83 pgxml_pfree(void *ptr)
  84 {
  85 /*      elog(DEBUG1,"Free in CMC %p",CurrentMemoryContext); */
  86         pfree(ptr);
  87 }
  88
  89 static char *
  90 pgxml_pstrdup(const char *string)
  91 {
  92         return pstrdup(string);
  93 }
  94
  95 /* The error handling function. This formats an error message and sets
  96  * a flag - an ereport will be issued prior to return
  97  */
  98
  99 static void
 100 pgxml_errorHandler(void *ctxt, const char *msg,...)
 101 {
 102         va_list         args;
 103
 104         va_start(args, msg);
 105         vsnprintf(errbuf, ERRBUF_SIZE, msg, args);
 106         va_end(args);
 107         /* Now copy the argument across */
 108         if (pgxml_errorMsg == NULL)
 109                 pgxml_errorMsg = pstrdup(errbuf);
 110         else
 111         {
 112                 int32           xsize = strlen(pgxml_errorMsg);
 113
 114                 pgxml_errorMsg = repalloc(pgxml_errorMsg,
 115                                                                   (size_t) (xsize + strlen(errbuf) + 1));
 116                 strncpy(&pgxml_errorMsg[xsize - 1], errbuf, strlen(errbuf));
 117                 pgxml_errorMsg[xsize + strlen(errbuf) - 1] = '\0';
 118
 119         }
 120         memset(errbuf, 0, ERRBUF_SIZE);
 121 }
 122
 123 /* This function reports the current message at the level specified */
 124 void
 125 elog_error(int level, char *explain, int force)
 126 {
 127         if (force || (pgxml_errorMsg != NULL))
 128         {
 129                 if (pgxml_errorMsg == NULL)
 130                 {
 131                         ereport(level, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
 132                                                         errmsg(explain)));
 133                 }
 134                 else
 135                 {
 136                         ereport(level, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
 137                                                         errmsg("%s:%s", explain, pgxml_errorMsg)));
 138                         pfree(pgxml_errorMsg);
 139                 }
 140         }
 141 }
 142
 143 void
 144 pgxml_parser_init()
 145 {
 146         /*
 147          * This code could also set parser settings from  user-supplied info.
 148          * Quite how these settings are made is another matter :)
 149          */
 150
 151         xmlMemSetup(pgxml_pfree, pgxml_palloc, pgxml_repalloc, pgxml_pstrdup);
 152         xmlInitParser();
 153
 154         xmlSetGenericErrorFunc(NULL, pgxml_errorHandler);
 155
 156         xmlSubstituteEntitiesDefault(1);
 157         xmlLoadExtDtdDefaultValue = 1;
 158
 159         pgxml_errorMsg = NULL;
 160
 161         errbuf = palloc(200);
 162         memset(errbuf, 0, 200);
 163
 164 }
 165
 166
 167 /* Returns true if document is well-formed */
 168
 169 PG_FUNCTION_INFO_V1(xml_is_well_formed);
 170
 171 Datum
 172 xml_is_well_formed(PG_FUNCTION_ARGS)
 173 {
 174         /* called as xml_is_well_formed(document) */
 175         xmlDocPtr       doctree;
 176         text       *t = PG_GETARG_TEXT_P(0);            /* document buffer */
 177         int32           docsize = VARSIZE(t) - VARHDRSZ;
 178
 179         pgxml_parser_init();
 180
 181         doctree = xmlParseMemory((char *) VARDATA(t), docsize);
 182         if (doctree == NULL)
 183         {
 184                 xmlCleanupParser();
 185                 PG_RETURN_BOOL(false);  /* i.e. not well-formed */
 186         }
 187         xmlCleanupParser();
 188         xmlFreeDoc(doctree);
 189         PG_RETURN_BOOL(true);
 190 }
 191
 192
 193 /* Encodes special characters (<, >, &, " and \r) as XML entities */
 194
 195 PG_FUNCTION_INFO_V1(xml_encode_special_chars);
 196
 197 Datum
 198 xml_encode_special_chars(PG_FUNCTION_ARGS)
 199 {
 200         text       *tin = PG_GETARG_TEXT_P(0);
 201         text       *tout;
 202         xmlChar    *ts,
 203                            *tt;
 204
 205         ts = pgxml_texttoxmlchar(tin);
 206
 207         tt = xmlEncodeSpecialChars(NULL, ts);
 208
 209         pfree(ts);
 210
 211         tout = cstring_to_text((char *) tt);
 212
 213         xmlFree(tt);
 214
 215         PG_RETURN_TEXT_P(tout);
 216 }
 217
 218 static xmlChar
 219                    *
 220 pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
 221                                    xmlChar *toptagname,
 222                                    xmlChar *septagname,
 223                                    xmlChar *plainsep)
 224 {
 225         /* Function translates a nodeset into a text representation */
 226
 227         /*
 228          * iterates over each node in the set and calls xmlNodeDump to write it to
 229          * an xmlBuffer -from which an xmlChar * string is returned.
 230          */
 231
 232         /* each representation is surrounded by <tagname> ... </tagname> */
 233
 234         /*
 235          * plainsep is an ordinary (not tag) seperator - if used, then nodes are
 236          * cast to string as output method
 237          */
 238
 239
 240         xmlBufferPtr buf;
 241         xmlChar    *result;
 242         int                     i;
 243
 244         buf = xmlBufferCreate();
 245
 246         if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
 247         {
 248                 xmlBufferWriteChar(buf, "<");
 249                 xmlBufferWriteCHAR(buf, toptagname);
 250                 xmlBufferWriteChar(buf, ">");
 251         }
 252         if (nodeset != NULL)
 253         {
 254                 for (i = 0; i < nodeset->nodeNr; i++)
 255                 {
 256
 257                         if (plainsep != NULL)
 258                         {
 259                                 xmlBufferWriteCHAR(buf,
 260                                                           xmlXPathCastNodeToString(nodeset->nodeTab[i]));
 261
 262                                 /* If this isn't the last entry, write the plain sep. */
 263                                 if (i < (nodeset->nodeNr) - 1)
 264                                         xmlBufferWriteChar(buf, (char *) plainsep);
 265                         }
 266                         else
 267                         {
 268
 269
 270                                 if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
 271                                 {
 272                                         xmlBufferWriteChar(buf, "<");
 273                                         xmlBufferWriteCHAR(buf, septagname);
 274                                         xmlBufferWriteChar(buf, ">");
 275                                 }
 276                                 xmlNodeDump(buf,
 277                                                         nodeset->nodeTab[i]->doc,
 278                                                         nodeset->nodeTab[i],
 279                                                         1, 0);
 280
 281                                 if ((septagname != NULL) && (xmlStrlen(septagname) > 0))
 282                                 {
 283                                         xmlBufferWriteChar(buf, "</");
 284                                         xmlBufferWriteCHAR(buf, septagname);
 285                                         xmlBufferWriteChar(buf, ">");
 286                                 }
 287                         }
 288                 }
 289         }
 290
 291         if ((toptagname != NULL) && (xmlStrlen(toptagname) > 0))
 292         {
 293                 xmlBufferWriteChar(buf, "</");
 294                 xmlBufferWriteCHAR(buf, toptagname);
 295                 xmlBufferWriteChar(buf, ">");
 296         }
 297         result = xmlStrdup(buf->content);
 298         xmlBufferFree(buf);
 299         return result;
 300 }
 301
 302
 303 /* Translate a PostgreSQL "varlena" -i.e. a variable length parameter
 304  * into the libxml2 representation
 305  */
 306
 307 xmlChar *
 308 pgxml_texttoxmlchar(text *textstring)
 309 {
 310         return (xmlChar *) text_to_cstring(textstring);
 311 }
 312
 313 /* Public visible XPath functions */
 314
 315 /* This is a "raw" xpath function. Check that it returns child elements
 316  * properly
 317  */
 318
 319 PG_FUNCTION_INFO_V1(xpath_nodeset);
 320
 321 Datum
 322 xpath_nodeset(PG_FUNCTION_ARGS)
 323 {
 324         xmlChar    *xpath,
 325                            *toptag,
 326                            *septag;
 327         int32           pathsize;
 328         text
 329                            *xpathsupp,
 330                            *xpres;
 331
 332         /* PG_GETARG_TEXT_P(0) is document buffer */
 333         xpathsupp = PG_GETARG_TEXT_P(1);        /* XPath expression */
 334
 335         toptag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2));
 336         septag = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(3));
 337
 338         pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 339
 340         xpath = pgxml_texttoxmlchar(xpathsupp);
 341
 342         xpres = pgxml_result_to_text(
 343                                                                  pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
 344                                                                  toptag, septag, NULL);
 345
 346         /* xmlCleanupParser(); done by result_to_text routine */
 347         pfree(xpath);
 348
 349         if (xpres == NULL)
 350                 PG_RETURN_NULL();
 351         PG_RETURN_TEXT_P(xpres);
 352 }
 353
 354 /*      The following function is almost identical, but returns the elements in */
 355 /*      a list. */
 356
 357 PG_FUNCTION_INFO_V1(xpath_list);
 358
 359 Datum
 360 xpath_list(PG_FUNCTION_ARGS)
 361 {
 362         xmlChar    *xpath,
 363                            *plainsep;
 364         int32           pathsize;
 365         text
 366                            *xpathsupp,
 367                            *xpres;
 368
 369         /* PG_GETARG_TEXT_P(0) is document buffer */
 370         xpathsupp = PG_GETARG_TEXT_P(1);        /* XPath expression */
 371
 372         plainsep = pgxml_texttoxmlchar(PG_GETARG_TEXT_P(2));
 373
 374         pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 375
 376         xpath = pgxml_texttoxmlchar(xpathsupp);
 377
 378         xpres = pgxml_result_to_text(
 379                                                                  pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
 380                                                                  NULL, NULL, plainsep);
 381
 382         /* xmlCleanupParser(); done by result_to_text routine */
 383         pfree(xpath);
 384
 385         if (xpres == NULL)
 386                 PG_RETURN_NULL();
 387         PG_RETURN_TEXT_P(xpres);
 388 }
 389
 390
 391 PG_FUNCTION_INFO_V1(xpath_string);
 392
 393 Datum
 394 xpath_string(PG_FUNCTION_ARGS)
 395 {
 396         xmlChar    *xpath;
 397         int32           pathsize;
 398         text
 399                            *xpathsupp,
 400                            *xpres;
 401
 402         /* PG_GETARG_TEXT_P(0) is document buffer */
 403         xpathsupp = PG_GETARG_TEXT_P(1);        /* XPath expression */
 404
 405         pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 406
 407         /*
 408          * We encapsulate the supplied path with "string()" = 8 chars + 1 for NUL
 409          * at end
 410          */
 411         /* We could try casting to string using the libxml function? */
 412
 413         xpath = (xmlChar *) palloc(pathsize + 9);
 414         memcpy((char *) (xpath + 7), VARDATA(xpathsupp), pathsize);
 415         strncpy((char *) xpath, "string(", 7);
 416         xpath[pathsize + 7] = ')';
 417         xpath[pathsize + 8] = '\0';
 418
 419         xpres = pgxml_result_to_text(
 420                                                                  pgxml_xpath(PG_GETARG_TEXT_P(0), xpath),
 421                                                                  NULL, NULL, NULL);
 422
 423         xmlCleanupParser();
 424         pfree(xpath);
 425
 426         if (xpres == NULL)
 427                 PG_RETURN_NULL();
 428         PG_RETURN_TEXT_P(xpres);
 429 }
 430
 431
 432 PG_FUNCTION_INFO_V1(xpath_number);
 433
 434 Datum
 435 xpath_number(PG_FUNCTION_ARGS)
 436 {
 437         xmlChar    *xpath;
 438         int32           pathsize;
 439         text
 440                            *xpathsupp;
 441
 442         float4          fRes;
 443
 444         xmlXPathObjectPtr res;
 445
 446         /* PG_GETARG_TEXT_P(0) is document buffer */
 447         xpathsupp = PG_GETARG_TEXT_P(1);        /* XPath expression */
 448
 449         pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 450
 451         xpath = pgxml_texttoxmlchar(xpathsupp);
 452
 453         res = pgxml_xpath(PG_GETARG_TEXT_P(0), xpath);
 454         pfree(xpath);
 455
 456         if (res == NULL)
 457         {
 458                 xmlCleanupParser();
 459                 PG_RETURN_NULL();
 460         }
 461
 462         fRes = xmlXPathCastToNumber(res);
 463         xmlCleanupParser();
 464         if (xmlXPathIsNaN(fRes))
 465                 PG_RETURN_NULL();
 466
 467         PG_RETURN_FLOAT4(fRes);
 468
 469 }
 470
 471
 472 PG_FUNCTION_INFO_V1(xpath_bool);
 473
 474 Datum
 475 xpath_bool(PG_FUNCTION_ARGS)
 476 {
 477         xmlChar    *xpath;
 478         int32           pathsize;
 479         text
 480                            *xpathsupp;
 481
 482         int                     bRes;
 483
 484         xmlXPathObjectPtr res;
 485
 486         /* PG_GETARG_TEXT_P(0) is document buffer */
 487         xpathsupp = PG_GETARG_TEXT_P(1);        /* XPath expression */
 488
 489         pathsize = VARSIZE(xpathsupp) - VARHDRSZ;
 490
 491         xpath = pgxml_texttoxmlchar(xpathsupp);
 492
 493         res = pgxml_xpath(PG_GETARG_TEXT_P(0), xpath);
 494         pfree(xpath);
 495
 496         if (res == NULL)
 497         {
 498                 xmlCleanupParser();
 499                 PG_RETURN_BOOL(false);
 500         }
 501
 502         bRes = xmlXPathCastToBoolean(res);
 503         xmlCleanupParser();
 504         PG_RETURN_BOOL(bRes);
 505
 506 }
 507
 508
 509
 510 /* Core function to evaluate XPath query */
 511
 512 xmlXPathObjectPtr
 513 pgxml_xpath(text *document, xmlChar *xpath)
 514 {
 515
 516         xmlDocPtr       doctree;
 517         xmlXPathContextPtr ctxt;
 518         xmlXPathObjectPtr res;
 519
 520         xmlXPathCompExprPtr comppath;
 521
 522         int32           docsize;
 523
 524
 525         docsize = VARSIZE(document) - VARHDRSZ;
 526
 527         pgxml_parser_init();
 528
 529         doctree = xmlParseMemory((char *) VARDATA(document), docsize);
 530         if (doctree == NULL)
 531         {                                                       /* not well-formed */
 532                 return NULL;
 533         }
 534
 535         ctxt = xmlXPathNewContext(doctree);
 536         ctxt->node = xmlDocGetRootElement(doctree);
 537
 538
 539         /* compile the path */
 540         comppath = xmlXPathCompile(xpath);
 541         if (comppath == NULL)
 542         {
 543                 xmlCleanupParser();
 544                 xmlFreeDoc(doctree);
 545                 elog_error(ERROR, "XPath Syntax Error", 1);
 546
 547                 return NULL;
 548         }
 549
 550         /* Now evaluate the path expression. */
 551         res = xmlXPathCompiledEval(comppath, ctxt);
 552         xmlXPathFreeCompExpr(comppath);
 553
 554         if (res == NULL)
 555         {
 556                 xmlXPathFreeContext(ctxt);
 557                 /* xmlCleanupParser(); */
 558                 xmlFreeDoc(doctree);
 559
 560                 return NULL;
 561         }
 562         /* xmlFreeDoc(doctree); */
 563         return res;
 564 }
 565
 566 text
 567                    *
 568 pgxml_result_to_text(xmlXPathObjectPtr res,
 569                                          xmlChar *toptag,
 570                                          xmlChar *septag,
 571                                          xmlChar *plainsep)
 572 {
 573         xmlChar    *xpresstr;
 574         text       *xpres;
 575
 576         if (res == NULL)
 577         {
 578                 xmlCleanupParser();
 579                 return NULL;
 580         }
 581         switch (res->type)
 582         {
 583                 case XPATH_NODESET:
 584                         xpresstr = pgxmlNodeSetToText(res->nodesetval,
 585                                                                                   toptag,
 586                                                                                   septag, plainsep);
 587                         break;
 588
 589                 case XPATH_STRING:
 590                         xpresstr = xmlStrdup(res->stringval);
 591                         break;
 592
 593                 default:
 594                         elog(NOTICE, "unsupported XQuery result: %d", res->type);
 595                         xpresstr = xmlStrdup((const xmlChar *) "<unsupported/>");
 596         }
 597
 598
 599         /* Now convert this result back to text */
 600         xpres = cstring_to_text((char *) xpresstr);
 601
 602         /* Free various storage */
 603         xmlCleanupParser();
 604         /* xmlFreeDoc(doctree);  -- will die at end of tuple anyway */
 605
 606         xmlFree(xpresstr);
 607
 608         elog_error(ERROR, "XPath error", 0);
 609
 610
 611         return xpres;
 612 }
 613
 614 /* xpath_table is a table function. It needs some tidying (as do the
 615  * other functions here!
 616  */
 617
 618 PG_FUNCTION_INFO_V1(xpath_table);
 619
 620 Datum
 621 xpath_table(PG_FUNCTION_ARGS)
 622 {
 623 /* SPI (input tuple) support */
 624         SPITupleTable *tuptable;
 625         HeapTuple       spi_tuple;
 626         TupleDesc       spi_tupdesc;
 627
 628 /* Output tuple (tuplestore) support */
 629         Tuplestorestate *tupstore = NULL;
 630         TupleDesc       ret_tupdesc;
 631         HeapTuple       ret_tuple;
 632
 633         ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
 634         AttInMetadata *attinmeta;
 635         MemoryContext per_query_ctx;
 636         MemoryContext oldcontext;
 637
 638 /* Function parameters */
 639         char       *pkeyfield = text_to_cstring(PG_GETARG_TEXT_PP(0));
 640         char       *xmlfield = text_to_cstring(PG_GETARG_TEXT_PP(1));
 641         char       *relname = text_to_cstring(PG_GETARG_TEXT_PP(2));
 642         char       *xpathset = text_to_cstring(PG_GETARG_TEXT_PP(3));
 643         char       *condition = text_to_cstring(PG_GETARG_TEXT_PP(4));
 644
 645         char      **values;
 646         xmlChar   **xpaths;
 647         char       *pos;
 648         const char *pathsep = "|";
 649
 650         int                     numpaths;
 651         int                     ret;
 652         int                     proc;
 653         int                     i;
 654         int                     j;
 655         int                     rownr;                  /* For issuing multiple rows from one original
 656                                                                  * document */
 657         int                     had_values;             /* To determine end of nodeset results */
 658
 659         StringInfoData query_buf;
 660
 661         /* We only have a valid tuple description in table function mode */
 662         if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
 663                 ereport(ERROR,
 664                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 665                                  errmsg("set-valued function called in context that cannot accept a set")));
 666         if (rsinfo->expectedDesc == NULL)
 667                 ereport(ERROR,
 668                                 (errcode(ERRCODE_SYNTAX_ERROR),
 669                                  errmsg("xpath_table must be called as a table function")));
 670
 671         /*
 672          * We want to materialise because it means that we don't have to carry
 673          * libxml2 parser state between invocations of this function
 674          */
 675         if (!(rsinfo->allowedModes & SFRM_Materialize))
 676                 ereport(ERROR,
 677                                 (errcode(ERRCODE_SYNTAX_ERROR),
 678                            errmsg("xpath_table requires Materialize mode, but it is not "
 679                                           "allowed in this context")));
 680
 681         /*
 682          * The tuplestore must exist in a higher context than this function call
 683          * (per_query_ctx is used)
 684          */
 685
 686         per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
 687         oldcontext = MemoryContextSwitchTo(per_query_ctx);
 688
 689         /*
 690          * Create the tuplestore - work_mem is the max in-memory size before a
 691          * file is created on disk to hold it.
 692          */
 693         tupstore =
 694                 tuplestore_begin_heap(rsinfo->allowedModes & SFRM_Materialize_Random,
 695                                                           false, work_mem);
 696
 697         MemoryContextSwitchTo(oldcontext);
 698
 699         /* get the requested return tuple description */
 700         ret_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
 701
 702         /*
 703          * At the moment we assume that the returned attributes make sense for the
 704          * XPath specififed (i.e. we trust the caller). It's not fatal if they get
 705          * it wrong - the input function for the column type will raise an error
 706          * if the path result can't be converted into the correct binary
 707          * representation.
 708          */
 709
 710         attinmeta = TupleDescGetAttInMetadata(ret_tupdesc);
 711
 712         /* Set return mode and allocate value space. */
 713         rsinfo->returnMode = SFRM_Materialize;
 714         rsinfo->setDesc = ret_tupdesc;
 715
 716         values = (char **) palloc(ret_tupdesc->natts * sizeof(char *));
 717
 718         xpaths = (xmlChar **) palloc(ret_tupdesc->natts * sizeof(xmlChar *));
 719
 720         /* Split XPaths. xpathset is a writable CString. */
 721
 722         /* Note that we stop splitting once we've done all needed for tupdesc */
 723
 724         numpaths = 0;
 725         pos = xpathset;
 726         do
 727         {
 728                 xpaths[numpaths] = (xmlChar *) pos;
 729                 pos = strstr(pos, pathsep);
 730                 if (pos != NULL)
 731                 {
 732                         *pos = '\0';
 733                         pos++;
 734                 }
 735                 numpaths++;
 736         } while ((pos != NULL) && (numpaths < (ret_tupdesc->natts - 1)));
 737
 738         /* Now build query */
 739         initStringInfo(&query_buf);
 740
 741         /* Build initial sql statement */
 742         appendStringInfo(&query_buf, "SELECT %s, %s FROM %s WHERE %s",
 743                                          pkeyfield,
 744                                          xmlfield,
 745                                          relname,
 746                                          condition
 747                 );
 748
 749
 750         if ((ret = SPI_connect()) < 0)
 751                 elog(ERROR, "xpath_table: SPI_connect returned %d", ret);
 752
 753         if ((ret = SPI_exec(query_buf.data, 0)) != SPI_OK_SELECT)
 754                 elog(ERROR, "xpath_table: SPI execution failed for query %s", query_buf.data);
 755
 756         proc = SPI_processed;
 757         /* elog(DEBUG1,"xpath_table: SPI returned %d rows",proc); */
 758         tuptable = SPI_tuptable;
 759         spi_tupdesc = tuptable->tupdesc;
 760
 761 /* Switch out of SPI context */
 762         MemoryContextSwitchTo(oldcontext);
 763
 764
 765 /* Check that SPI returned correct result. If you put a comma into one of
 766  * the function parameters, this will catch it when the SPI query returns
 767  * e.g. 3 columns.
 768  */
 769
 770         if (spi_tupdesc->natts != 2)
 771         {
 772                 ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 773                                                 errmsg("expression returning multiple columns is not valid in parameter list"),
 774                                                 errdetail("Expected two columns in SPI result, got %d.", spi_tupdesc->natts)));
 775         }
 776
 777 /* Setup the parser. Beware that this must happen in the same context as the
 778  * cleanup - which means that any error from here on must do cleanup to
 779  * ensure that the entity table doesn't get freed by being out of context.
 780  */
 781         pgxml_parser_init();
 782
 783         /* For each row i.e. document returned from SPI */
 784         for (i = 0; i < proc; i++)
 785         {
 786                 char       *pkey;
 787                 char       *xmldoc;
 788
 789                 xmlDocPtr       doctree;
 790                 xmlXPathContextPtr ctxt;
 791                 xmlXPathObjectPtr res;
 792                 xmlChar    *resstr;
 793
 794
 795                 xmlXPathCompExprPtr comppath;
 796
 797                 /* Extract the row data as C Strings */
 798                 spi_tuple = tuptable->vals[i];
 799                 pkey = SPI_getvalue(spi_tuple, spi_tupdesc, 1);
 800                 xmldoc = SPI_getvalue(spi_tuple, spi_tupdesc, 2);
 801
 802                 /*
 803                  * Clear the values array, so that not-well-formed documents return
 804                  * NULL in all columns.
 805                  */
 806
 807                 /* Note that this also means that spare columns will be NULL. */
 808                 for (j = 0; j < ret_tupdesc->natts; j++)
 809                         values[j] = NULL;
 810
 811                 /* Insert primary key */
 812                 values[0] = pkey;
 813
 814                 /* Parse the document */
 815                 if (xmldoc)
 816                         doctree = xmlParseMemory(xmldoc, strlen(xmldoc));
 817                 else    /* treat NULL as not well-formed */
 818                         doctree = NULL;
 819
 820                 if (doctree == NULL)
 821                 {
 822                         /* not well-formed, so output all-NULL tuple */
 823                         ret_tuple = BuildTupleFromCStrings(attinmeta, values);
 824                         oldcontext = MemoryContextSwitchTo(per_query_ctx);
 825                         tuplestore_puttuple(tupstore, ret_tuple);
 826                         MemoryContextSwitchTo(oldcontext);
 827                         heap_freetuple(ret_tuple);
 828                 }
 829                 else
 830                 {
 831                         /* New loop here - we have to deal with nodeset results */
 832                         rownr = 0;
 833
 834                         do
 835                         {
 836                                 /* Now evaluate the set of xpaths. */
 837                                 had_values = 0;
 838                                 for (j = 0; j < numpaths; j++)
 839                                 {
 840
 841                                         ctxt = xmlXPathNewContext(doctree);
 842                                         ctxt->node = xmlDocGetRootElement(doctree);
 843                                         xmlSetGenericErrorFunc(ctxt, pgxml_errorHandler);
 844
 845                                         /* compile the path */
 846                                         comppath = xmlXPathCompile(xpaths[j]);
 847                                         if (comppath == NULL)
 848                                         {
 849                                                 xmlCleanupParser();
 850                                                 xmlFreeDoc(doctree);
 851
 852                                                 elog_error(ERROR, "XPath Syntax Error", 1);
 853
 854                                                 PG_RETURN_NULL();               /* Keep compiler happy */
 855                                         }
 856
 857                                         /* Now evaluate the path expression. */
 858                                         res = xmlXPathCompiledEval(comppath, ctxt);
 859                                         xmlXPathFreeCompExpr(comppath);
 860
 861                                         if (res != NULL)
 862                                         {
 863                                                 switch (res->type)
 864                                                 {
 865                                                         case XPATH_NODESET:
 866                                                                 /* We see if this nodeset has enough nodes */
 867                                                                 if ((res->nodesetval != NULL) && (rownr < res->nodesetval->nodeNr))
 868                                                                 {
 869                                                                         resstr =
 870                                                                                 xmlXPathCastNodeToString(res->nodesetval->nodeTab[rownr]);
 871                                                                         had_values = 1;
 872                                                                 }
 873                                                                 else
 874                                                                         resstr = NULL;
 875
 876                                                                 break;
 877
 878                                                         case XPATH_STRING:
 879                                                                 resstr = xmlStrdup(res->stringval);
 880                                                                 break;
 881
 882                                                         default:
 883                                                                 elog(NOTICE, "unsupported XQuery result: %d", res->type);
 884                                                                 resstr = xmlStrdup((const xmlChar *) "<unsupported/>");
 885                                                 }
 886
 887
 888                                                 /*
 889                                                  * Insert this into the appropriate column in the
 890                                                  * result tuple.
 891                                                  */
 892                                                 values[j + 1] = (char *) resstr;
 893                                         }
 894                                         xmlXPathFreeContext(ctxt);
 895                                 }
 896                                 /* Now add the tuple to the output, if there is one. */
 897                                 if (had_values)
 898                                 {
 899                                         ret_tuple = BuildTupleFromCStrings(attinmeta, values);
 900                                         oldcontext = MemoryContextSwitchTo(per_query_ctx);
 901                                         tuplestore_puttuple(tupstore, ret_tuple);
 902                                         MemoryContextSwitchTo(oldcontext);
 903                                         heap_freetuple(ret_tuple);
 904                                 }
 905
 906                                 rownr++;
 907
 908                         } while (had_values);
 909
 910                 }
 911
 912                 xmlFreeDoc(doctree);
 913
 914                 if (pkey)
 915                         pfree(pkey);
 916                 if (xmldoc)
 917                         pfree(xmldoc);
 918         }
 919
 920         xmlCleanupParser();
 921 /* Needed to flag completeness in 7.3.1. 7.4 defines it as a no-op. */
 922         tuplestore_donestoring(tupstore);
 923
 924         SPI_finish();
 925
 926         rsinfo->setResult = tupstore;
 927
 928         /*
 929          * SFRM_Materialize mode expects us to return a NULL Datum. The actual
 930          * tuples are in our tuplestore and passed back through rsinfo->setResult.
 931          * rsinfo->setDesc is set to the tuple description that we actually used
 932          * to build our tuples with, so the caller can verify we did what it was
 933          * expecting.
 934          */
 935         return (Datum) 0;
 936
 937 }