xml.h File Reference

#include "executor/tablefunc.h"
#include "fmgr.h"
#include "nodes/execnodes.h"
#include "nodes/primnodes.h"

Include dependency graph for xml.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PG_GETARG_XML_P(n)   DatumGetXmlP(PG_GETARG_DATUM(n))
#define	PG_RETURN_XML_P(x)   PG_RETURN_POINTER(x)

Typedefs
typedef varlena	xmltype
typedef struct PgXmlErrorContext	PgXmlErrorContext

Enumerations
enum	XmlStandaloneType { XML_STANDALONE_YES , XML_STANDALONE_NO , XML_STANDALONE_NO_VALUE , XML_STANDALONE_OMITTED }
enum	XmlBinaryType { XMLBINARY_BASE64 , XMLBINARY_HEX }
enum	PgXmlStrictness { PG_XML_STRICTNESS_LEGACY , PG_XML_STRICTNESS_WELLFORMED , PG_XML_STRICTNESS_ALL }

Functions
static xmltype *	DatumGetXmlP (Datum X)
static Datum	XmlPGetDatum (const xmltype *X)
void	pg_xml_init_library (void)
PgXmlErrorContext *	pg_xml_init (PgXmlStrictness strictness)
void	pg_xml_done (PgXmlErrorContext *errcxt, bool isError)
bool	pg_xml_error_occurred (PgXmlErrorContext *errcxt)
void	xml_ereport (PgXmlErrorContext *errcxt, int level, int sqlcode, const char *msg)
xmltype *	xmlconcat (List *args)
xmltype *	xmlelement (XmlExpr *xexpr, const Datum *named_argvalue, const bool *named_argnull, const Datum *argvalue, const bool *argnull)
xmltype *	xmlparse (text *data, XmlOptionType xmloption_arg, bool preserve_whitespace, Node *escontext)
xmltype *	xmlpi (const char *target, text *arg, bool arg_is_null, bool *result_is_null)
xmltype *	xmlroot (xmltype *data, text *version, int standalone)
bool	xml_is_document (xmltype *arg)
text *	xmltotext_with_options (xmltype *data, XmlOptionType xmloption_arg, bool indent)
char *	escape_xml (const char *str)
char *	map_sql_identifier_to_xml_name (const char *ident, bool fully_escaped, bool escape_period)
char *	map_xml_name_to_sql_identifier (const char *name)
char *	map_sql_value_to_xml_value (Datum value, Oid type, bool xml_escape_strings)

Variables
PGDLLIMPORT int	xmlbinary
PGDLLIMPORT int	xmloption
PGDLLIMPORT const TableFuncRoutine	XmlTableRoutine

Macro Definition Documentation

PG_GETARG_XML_P

#define PG_GETARG_XML_P

(

n

)

DatumGetXmlP(PG_GETARG_DATUM(n))

Definition at line 62 of file xml.h.

PG_RETURN_XML_P

#define PG_RETURN_XML_P

(

x

)

PG_RETURN_POINTER(x)

Definition at line 63 of file xml.h.

Typedef Documentation

PgXmlErrorContext

typedef struct PgXmlErrorContext PgXmlErrorContext

Definition at line 48 of file xml.h.

xmltype

typedef varlena xmltype

Definition at line 23 of file xml.h.

Enumeration Type Documentation

PgXmlStrictness

enum PgXmlStrictness

Enumerator
PG_XML_STRICTNESS_LEGACY
PG_XML_STRICTNESS_WELLFORMED
PG_XML_STRICTNESS_ALL

Definition at line 39 of file xml.h.

{
    PG_XML_STRICTNESS_LEGACY,   /* ignore errors unless function result
                                 * indicates error condition */
    PG_XML_STRICTNESS_WELLFORMED,   /* ignore non-parser messages */
    PG_XML_STRICTNESS_ALL,      /* report all notices/warnings/errors */
} PgXmlStrictness;

XmlBinaryType

enum XmlBinaryType

Enumerator
XMLBINARY_BASE64
XMLBINARY_HEX

Definition at line 33 of file xml.h.

{
    XMLBINARY_BASE64,
    XMLBINARY_HEX,
}           XmlBinaryType;

XmlStandaloneType

enum XmlStandaloneType

Enumerator
XML_STANDALONE_YES
XML_STANDALONE_NO
XML_STANDALONE_NO_VALUE
XML_STANDALONE_OMITTED

Definition at line 25 of file xml.h.

{
    XML_STANDALONE_YES,
    XML_STANDALONE_NO,
    XML_STANDALONE_NO_VALUE,
    XML_STANDALONE_OMITTED,
}           XmlStandaloneType;

Function Documentation

DatumGetXmlP()

static xmltype * DatumGetXmlP ( Datum  X )

inlinestatic

Definition at line 51 of file xml.h.

{
    return (xmltype *) PG_DETOAST_DATUM(X);
}

References fb(), and PG_DETOAST_DATUM.

Referenced by ExecEvalXmlExpr(), xmlconcat(), and XmlTableSetDocument().

escape_xml()

char * escape_xml ( const char *  str )

extern

Definition at line 2739 of file xml.c.

{
    StringInfoData buf;
    const char *p;
 
    initStringInfo(&buf);
    for (p = str; *p; p++)
    {
        switch (*p)
        {
            case '&':
                appendStringInfoString(&buf, "&");
                break;
            case '<':
                appendStringInfoString(&buf, "&lt;");
                break;
            case '>':
                appendStringInfoString(&buf, "&gt;");
                break;
            case '\r':
                appendStringInfoString(&buf, "&#x0d;");
                break;
            default:
                appendStringInfoCharMacro(&buf, *p);
                break;
        }
    }
    return buf.data;
}

References appendStringInfoCharMacro, appendStringInfoString(), buf, initStringInfo(), and str.

Referenced by ExplainProperty(), ExplainPropertyList(), map_sql_value_to_xml_value(), and XmlTableGetValue().

map_sql_identifier_to_xml_name()

char * map_sql_identifier_to_xml_name ( const char *  ident, bool  fully_escaped, bool  escape_period  )

extern

Definition at line 2422 of file xml.c.

{
#ifdef USE_LIBXML
    StringInfoData buf;
    const char *p;
 
    /*
     * SQL/XML doesn't make use of this case anywhere, so it's probably a
     * mistake.
     */
    Assert(fully_escaped || !escape_period);
 
    initStringInfo(&buf);
 
    for (p = ident; *p; p += pg_mblen_cstr(p))
    {
        if (*p == ':' && (p == ident || fully_escaped))
            appendStringInfoString(&buf, "_x003A_");
        else if (*p == '_' && *(p + 1) == 'x')
            appendStringInfoString(&buf, "_x005F_");
        else if (fully_escaped && p == ident &&
                 pg_strncasecmp(p, "xml", 3) == 0)
        {
            if (*p == 'x')
                appendStringInfoString(&buf, "_x0078_");
            else
                appendStringInfoString(&buf, "_x0058_");
        }
        else if (escape_period && *p == '.')
            appendStringInfoString(&buf, "_x002E_");
        else
        {
            pg_wchar    u = sqlchar_to_unicode(p);
 
            if ((p == ident)
                ? !is_valid_xml_namefirst(u)
                : !is_valid_xml_namechar(u))
                appendStringInfo(&buf, "_x%04X_", (unsigned int) u);
            else
                appendBinaryStringInfo(&buf, p, pg_mblen_cstr(p));
        }
    }
 
    return buf.data;
#else                           /* not USE_LIBXML */
    NO_XML_SUPPORT();
    return NULL;
#endif                          /* not USE_LIBXML */
}

References appendBinaryStringInfo(), appendStringInfo(), appendStringInfoString(), Assert, buf, fb(), ident, initStringInfo(), NO_XML_SUPPORT, pg_mblen_cstr(), and pg_strncasecmp().

Referenced by database_to_xml_internal(), map_multipart_sql_identifier_to_xml_name(), map_sql_catalog_to_xmlschema_types(), map_sql_schema_to_xmlschema_types(), map_sql_table_to_xmlschema(), query_to_xml_internal(), schema_to_xml_internal(), SPI_sql_row_to_xmlelement(), and transformXmlExpr().

map_sql_value_to_xml_value()

char * map_sql_value_to_xml_value ( Datum  value, Oid  type, bool  xml_escape_strings  )

extern

Definition at line 2520 of file xml.c.

{
    if (type_is_array_domain(type))
    {
        ArrayType  *array;
        Oid         elmtype;
        int16       elmlen;
        bool        elmbyval;
        char        elmalign;
        int         num_elems;
        Datum      *elem_values;
        bool       *elem_nulls;
        StringInfoData buf;
        int         i;
 
        array = DatumGetArrayTypeP(value);
        elmtype = ARR_ELEMTYPE(array);
        get_typlenbyvalalign(elmtype, &elmlen, &elmbyval, &elmalign);
 
        deconstruct_array(array, elmtype,
                          elmlen, elmbyval, elmalign,
                          &elem_values, &elem_nulls,
                          &num_elems);
 
        initStringInfo(&buf);
 
        for (i = 0; i < num_elems; i++)
        {
            if (elem_nulls[i])
                continue;
            appendStringInfoString(&buf, "<element>");
            appendStringInfoString(&buf,
                                   map_sql_value_to_xml_value(elem_values[i],
                                                              elmtype, true));
            appendStringInfoString(&buf, "</element>");
        }
 
        pfree(elem_values);
        pfree(elem_nulls);
 
        return buf.data;
    }
    else
    {
        Oid         typeOut;
        bool        isvarlena;
        char       *str;
 
        /*
         * Flatten domains; the special-case treatments below should apply to,
         * eg, domains over boolean not just boolean.
         */
        type = getBaseType(type);
 
        /*
         * Special XSD formatting for some data types
         */
        switch (type)
        {
            case BOOLOID:
                if (DatumGetBool(value))
                    return "true";
                else
                    return "false";
 
            case DATEOID:
                {
                    DateADT     date;
                    struct pg_tm tm;
                    char        buf[MAXDATELEN + 1];
 
                    date = DatumGetDateADT(value);
                    /* XSD doesn't support infinite values */
                    if (DATE_NOT_FINITE(date))
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("date out of range"),
                                 errdetail("XML does not support infinite date values.")));
                    j2date(date + POSTGRES_EPOCH_JDATE,
                           &(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
                    EncodeDateOnly(&tm, USE_XSD_DATES, buf);
 
                    return pstrdup(buf);
                }
 
            case TIMESTAMPOID:
                {
                    Timestamp   timestamp;
                    struct pg_tm tm;
                    fsec_t      fsec;
                    char        buf[MAXDATELEN + 1];
 
                    timestamp = DatumGetTimestamp(value);
 
                    /* XSD doesn't support infinite values */
                    if (TIMESTAMP_NOT_FINITE(timestamp))
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("timestamp out of range"),
                                 errdetail("XML does not support infinite timestamp values.")));
                    else if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, NULL) == 0)
                        EncodeDateTime(&tm, fsec, false, 0, NULL, USE_XSD_DATES, buf);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("timestamp out of range")));
 
                    return pstrdup(buf);
                }
 
            case TIMESTAMPTZOID:
                {
                    TimestampTz timestamp;
                    struct pg_tm tm;
                    int         tz;
                    fsec_t      fsec;
                    const char *tzn = NULL;
                    char        buf[MAXDATELEN + 1];
 
                    timestamp = DatumGetTimestamp(value);
 
                    /* XSD doesn't support infinite values */
                    if (TIMESTAMP_NOT_FINITE(timestamp))
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("timestamp out of range"),
                                 errdetail("XML does not support infinite timestamp values.")));
                    else if (timestamp2tm(timestamp, &tz, &tm, &fsec, &tzn, NULL) == 0)
                        EncodeDateTime(&tm, fsec, true, tz, tzn, USE_XSD_DATES, buf);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("timestamp out of range")));
 
                    return pstrdup(buf);
                }
 
#ifdef USE_LIBXML
            case BYTEAOID:
                {
                    bytea      *bstr = DatumGetByteaPP(value);
                    PgXmlErrorContext *xmlerrcxt;
                    volatile xmlBufferPtr buf = NULL;
                    volatile xmlTextWriterPtr writer = NULL;
                    char       *result;
 
                    xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
 
                    PG_TRY();
                    {
                        buf = xmlBufferCreate();
                        if (buf == NULL || xmlerrcxt->err_occurred)
                            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                                        "could not allocate xmlBuffer");
                        writer = xmlNewTextWriterMemory(buf, 0);
                        if (writer == NULL || xmlerrcxt->err_occurred)
                            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                                        "could not allocate xmlTextWriter");
 
                        if (xmlbinary == XMLBINARY_BASE64)
                            xmlTextWriterWriteBase64(writer, VARDATA_ANY(bstr),
                                                     0, VARSIZE_ANY_EXHDR(bstr));
                        else
                            xmlTextWriterWriteBinHex(writer, VARDATA_ANY(bstr),
                                                     0, VARSIZE_ANY_EXHDR(bstr));
 
                        /* we MUST do this now to flush data out to the buffer */
                        xmlFreeTextWriter(writer);
                        writer = NULL;
 
                        result = pstrdup((const char *) xmlBufferContent(buf));
                    }
                    PG_CATCH();
                    {
                        if (writer)
                            xmlFreeTextWriter(writer);
                        if (buf)
                            xmlBufferFree(buf);
 
                        pg_xml_done(xmlerrcxt, true);
 
                        PG_RE_THROW();
                    }
                    PG_END_TRY();
 
                    xmlBufferFree(buf);
 
                    pg_xml_done(xmlerrcxt, false);
 
                    return result;
                }
#endif                          /* USE_LIBXML */
 
        }
 
        /*
         * otherwise, just use the type's native text representation
         */
        getTypeOutputInfo(type, &typeOut, &isvarlena);
        str = OidOutputFunctionCall(typeOut, value);
 
        /* ... exactly as-is for XML, and when escaping is not wanted */
        if (type == XMLOID || !xml_escape_strings)
            return str;
 
        /* otherwise, translate special characters as needed */
        return escape_xml(str);
    }
}

References appendStringInfoString(), ARR_ELEMTYPE, buf, DATE_NOT_FINITE, DatumGetArrayTypeP, DatumGetBool(), DatumGetByteaPP, DatumGetDateADT(), DatumGetTimestamp(), deconstruct_array(), EncodeDateOnly(), EncodeDateTime(), ereport, errcode(), errdetail(), errmsg, ERROR, escape_xml(), fb(), get_typlenbyvalalign(), getBaseType(), getTypeOutputInfo(), i, initStringInfo(), j2date(), map_sql_value_to_xml_value(), MAXDATELEN, OidOutputFunctionCall(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pg_xml_done(), pg_xml_init(), PG_XML_STRICTNESS_ALL, POSTGRES_EPOCH_JDATE, pstrdup(), result, str, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, type, type_is_array_domain, USE_XSD_DATES, value, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), xml_ereport(), xmlbinary, and XMLBINARY_BASE64.

Referenced by ExecEvalXmlExpr(), map_sql_value_to_xml_value(), SPI_sql_row_to_xmlelement(), and xmlelement().

map_xml_name_to_sql_identifier()

char * map_xml_name_to_sql_identifier ( const char *  name )

extern

Definition at line 2478 of file xml.c.

{
    StringInfoData buf;
    const char *p;
 
    initStringInfo(&buf);
 
    for (p = name; *p; p += pg_mblen_cstr(p))
    {
        if (*p == '_' && *(p + 1) == 'x'
            && isxdigit((unsigned char) *(p + 2))
            && isxdigit((unsigned char) *(p + 3))
            && isxdigit((unsigned char) *(p + 4))
            && isxdigit((unsigned char) *(p + 5))
            && *(p + 6) == '_')
        {
            char        cbuf[MAX_UNICODE_EQUIVALENT_STRING + 1];
            unsigned int u;
 
            sscanf(p + 2, "%X", &u);
            pg_unicode_to_server(u, (unsigned char *) cbuf);
            appendStringInfoString(&buf, cbuf);
            p += 6;
        }
        else
            appendBinaryStringInfo(&buf, p, pg_mblen_cstr(p));
    }
 
    return buf.data;
}

References appendBinaryStringInfo(), appendStringInfoString(), buf, fb(), initStringInfo(), MAX_UNICODE_EQUIVALENT_STRING, name, pg_mblen_cstr(), and pg_unicode_to_server().

Referenced by get_rule_expr().

pg_xml_done()

void pg_xml_done ( PgXmlErrorContext *  errcxt, bool  isError  )

extern

Referenced by map_sql_value_to_xml_value(), pgxml_result_to_text(), pgxmlNodeSetToText(), xml_encode_special_chars(), xmlelement(), XmlTableDestroyOpaque(), XmlTableInitOpaque(), xmltext(), xmltotext_with_options(), xpath_bool(), xpath_list(), xpath_nodeset(), xpath_number(), xpath_string(), xpath_table(), and xslt_process().

pg_xml_error_occurred()

bool pg_xml_error_occurred ( PgXmlErrorContext *  errcxt )

extern

Referenced by pgxml_result_to_text(), pgxml_xpath(), pgxmlNodeSetToText(), xml_encode_special_chars(), xpath_table(), and xslt_process().

pg_xml_init()

PgXmlErrorContext * pg_xml_init ( PgXmlStrictness  strictness )

extern

Referenced by map_sql_value_to_xml_value(), pgxml_parser_init(), pgxml_result_to_text(), pgxmlNodeSetToText(), xml_encode_special_chars(), xmlelement(), XmlTableInitOpaque(), xmltext(), and xmltotext_with_options().

pg_xml_init_library()

void pg_xml_init_library ( void  )

extern

xml_ereport()

void xml_ereport ( PgXmlErrorContext *  errcxt, int  level, int  sqlcode, const char *  msg  )

extern

Referenced by map_sql_value_to_xml_value(), pgxml_result_to_text(), pgxml_xpath(), pgxmlNodeSetToText(), xml_encode_special_chars(), xmlelement(), XmlTableFetchRow(), XmlTableGetValue(), XmlTableInitOpaque(), XmlTableSetColumnFilter(), XmlTableSetDocument(), XmlTableSetNamespace(), XmlTableSetRowFilter(), xmltext(), xmltotext_with_options(), xpath_table(), and xslt_process().

xml_is_document()

bool xml_is_document ( xmltype *  arg )

extern

Definition at line 1172 of file xml.c.

{
#ifdef USE_LIBXML
    xmlDocPtr   doc;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    /*
     * We'll report "true" if no soft error is reported by xml_parse().
     */
    doc = xml_parse((text *) arg, XMLOPTION_DOCUMENT, true,
                    GetDatabaseEncoding(), NULL, NULL, (Node *) &escontext);
    if (doc)
        xmlFreeDoc(doc);
 
    return !escontext.error_occurred;
#else                           /* not USE_LIBXML */
    NO_XML_SUPPORT();
    return false;
#endif                          /* not USE_LIBXML */
}

References arg, ErrorSaveContext::error_occurred, fb(), GetDatabaseEncoding(), NO_XML_SUPPORT, and XMLOPTION_DOCUMENT.

Referenced by ExecEvalXmlExpr().

xmlconcat()

xmltype * xmlconcat ( List *  args )

extern

Definition at line 575 of file xml.c.

{
#ifdef USE_LIBXML
    int         global_standalone = 1;
    xmlChar    *global_version = NULL;
    bool        global_version_no_value = false;
    StringInfoData buf;
    ListCell   *v;
 
    initStringInfo(&buf);
    foreach(v, args)
    {
        xmltype    *x = DatumGetXmlP(PointerGetDatum(lfirst(v)));
        size_t      len;
        xmlChar    *version;
        int         standalone;
        char       *str;
 
        len = VARSIZE(x) - VARHDRSZ;
        str = text_to_cstring((text *) x);
 
        parse_xml_decl((xmlChar *) str, &len, &version, NULL, &standalone);
 
        if (standalone == 0 && global_standalone == 1)
            global_standalone = 0;
        if (standalone < 0)
            global_standalone = -1;
 
        if (!version)
            global_version_no_value = true;
        else if (!global_version)
            global_version = version;
        else if (xmlStrcmp(version, global_version) != 0)
            global_version_no_value = true;
 
        appendStringInfoString(&buf, str + len);
        pfree(str);
    }
 
    if (!global_version_no_value || global_standalone >= 0)
    {
        StringInfoData buf2;
 
        initStringInfo(&buf2);
 
        print_xml_decl(&buf2,
                       (!global_version_no_value) ? global_version : NULL,
                       0,
                       global_standalone);
 
        appendBinaryStringInfo(&buf2, buf.data, buf.len);
        buf = buf2;
    }
 
    return stringinfo_to_xmltype(&buf);
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References appendBinaryStringInfo(), appendStringInfoString(), buf, StringInfoData::data, DatumGetXmlP(), fb(), initStringInfo(), len, lfirst, NO_XML_SUPPORT, pfree(), PointerGetDatum(), str, stringinfo_to_xmltype(), text_to_cstring(), VARHDRSZ, VARSIZE(), and x.

Referenced by ExecEvalXmlExpr(), and xmlconcat2().

xmlelement()

xmltype * xmlelement ( XmlExpr *  xexpr, const Datum *  named_argvalue, const bool *  named_argnull, const Datum *  argvalue, const bool *  argnull  )

extern

Definition at line 894 of file xml.c.

{
#ifdef USE_LIBXML
    xmltype    *result;
    List       *named_arg_strings;
    List       *arg_strings;
    int         i;
    ListCell   *arg;
    ListCell   *narg;
    PgXmlErrorContext *xmlerrcxt;
    volatile xmlBufferPtr buf = NULL;
    volatile xmlTextWriterPtr writer = NULL;
 
    /*
     * All arguments are already evaluated, and their values are passed in the
     * named_argvalue/named_argnull or argvalue/argnull arrays.  This avoids
     * issues if one of the arguments involves a call to some other function
     * or subsystem that wants to use libxml on its own terms.  We examine the
     * original XmlExpr to identify the numbers and types of the arguments.
     */
    named_arg_strings = NIL;
    i = 0;
    foreach(arg, xexpr->named_args)
    {
        Expr       *e = (Expr *) lfirst(arg);
        char       *str;
 
        if (named_argnull[i])
            str = NULL;
        else
            str = map_sql_value_to_xml_value(named_argvalue[i],
                                             exprType((Node *) e),
                                             false);
        named_arg_strings = lappend(named_arg_strings, str);
        i++;
    }
 
    arg_strings = NIL;
    i = 0;
    foreach(arg, xexpr->args)
    {
        Expr       *e = (Expr *) lfirst(arg);
        char       *str;
 
        /* here we can just forget NULL elements immediately */
        if (!argnull[i])
        {
            str = map_sql_value_to_xml_value(argvalue[i],
                                             exprType((Node *) e),
                                             true);
            arg_strings = lappend(arg_strings, str);
        }
        i++;
    }
 
    xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
 
    PG_TRY();
    {
        buf = xmlBufferCreate();
        if (buf == NULL || xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                        "could not allocate xmlBuffer");
        writer = xmlNewTextWriterMemory(buf, 0);
        if (writer == NULL || xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                        "could not allocate xmlTextWriter");
 
        if (xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name) < 0 ||
            xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                        "could not start xml element");
 
        forboth(arg, named_arg_strings, narg, xexpr->arg_names)
        {
            char       *str = (char *) lfirst(arg);
            char       *argname = strVal(lfirst(narg));
 
            if (str)
            {
                if (xmlTextWriterWriteAttribute(writer,
                                                (xmlChar *) argname,
                                                (xmlChar *) str) < 0 ||
                    xmlerrcxt->err_occurred)
                    xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                                "could not write xml attribute");
            }
        }
 
        foreach(arg, arg_strings)
        {
            char       *str = (char *) lfirst(arg);
 
            if (xmlTextWriterWriteRaw(writer, (xmlChar *) str) < 0 ||
                xmlerrcxt->err_occurred)
                xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                            "could not write raw xml text");
        }
 
        if (xmlTextWriterEndElement(writer) < 0 ||
            xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                        "could not end xml element");
 
        /* we MUST do this now to flush data out to the buffer ... */
        xmlFreeTextWriter(writer);
        writer = NULL;
 
        result = xmlBuffer_to_xmltype(buf);
    }
    PG_CATCH();
    {
        if (writer)
            xmlFreeTextWriter(writer);
        if (buf)
            xmlBufferFree(buf);
 
        pg_xml_done(xmlerrcxt, true);
 
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    xmlBufferFree(buf);
 
    pg_xml_done(xmlerrcxt, false);
 
    return result;
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References arg, XmlExpr::args, buf, ERROR, exprType(), fb(), forboth, i, lappend(), lfirst, map_sql_value_to_xml_value(), XmlExpr::named_args, NIL, NO_XML_SUPPORT, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pg_xml_done(), pg_xml_init(), PG_XML_STRICTNESS_ALL, result, str, strVal, and xml_ereport().

Referenced by ExecEvalXmlExpr().

xmlparse()

xmltype * xmlparse ( text *  data, XmlOptionType  xmloption_arg, bool  preserve_whitespace, Node *  escontext  )

extern

Definition at line 1032 of file xml.c.

{
#ifdef USE_LIBXML
    xmlDocPtr   doc;
 
    doc = xml_parse(data, xmloption_arg, preserve_whitespace,
                    GetDatabaseEncoding(), NULL, NULL, escontext);
    if (doc)
        xmlFreeDoc(doc);
 
    if (SOFT_ERROR_OCCURRED(escontext))
        return NULL;
 
    return (xmltype *) data;
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References data, fb(), GetDatabaseEncoding(), NO_XML_SUPPORT, and SOFT_ERROR_OCCURRED.

Referenced by ExecEvalXmlExpr(), and texttoxml().

XmlPGetDatum()

static Datum XmlPGetDatum ( const xmltype *  X )

inlinestatic

Definition at line 57 of file xml.h.

{
    return PointerGetDatum(X);
}

References fb(), and PointerGetDatum().

xmlpi()

xmltype * xmlpi ( const char *  target, text *  arg, bool  arg_is_null, bool *  result_is_null  )

extern

Definition at line 1054 of file xml.c.

{
#ifdef USE_LIBXML
    xmltype    *result;
    StringInfoData buf;
 
    if (pg_strcasecmp(target, "xml") == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION),
                 errmsg("invalid XML processing instruction"),
                 errdetail("XML processing instruction target name cannot be \"%s\".", target)));
 
    /*
     * Following the SQL standard, the null check comes after the syntax check
     * above.
     */
    *result_is_null = arg_is_null;
    if (*result_is_null)
        return NULL;
 
    initStringInfo(&buf);
 
    appendStringInfo(&buf, "<?%s", target);
 
    if (arg != NULL)
    {
        char       *string;
 
        string = text_to_cstring(arg);
        if (strstr(string, "?>") != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION),
                     errmsg("invalid XML processing instruction"),
                     errdetail("XML processing instruction cannot contain \"?>\".")));
 
        appendStringInfoChar(&buf, ' ');
        appendStringInfoString(&buf, string + strspn(string, " "));
        pfree(string);
    }
    appendStringInfoString(&buf, "?>");
 
    result = stringinfo_to_xmltype(&buf);
    pfree(buf.data);
    return result;
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, buf, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), initStringInfo(), NO_XML_SUPPORT, pfree(), pg_strcasecmp(), result, stringinfo_to_xmltype(), and text_to_cstring().

Referenced by ExecEvalXmlExpr().

xmlroot()

xmltype * xmlroot ( xmltype *  data, text *  version, int  standalone  )

extern

Definition at line 1106 of file xml.c.

{
#ifdef USE_LIBXML
    char       *str;
    size_t      len;
    xmlChar    *orig_version;
    int         orig_standalone;
    StringInfoData buf;
 
    len = VARSIZE(data) - VARHDRSZ;
    str = text_to_cstring((text *) data);
 
    parse_xml_decl((xmlChar *) str, &len, &orig_version, NULL, &orig_standalone);
 
    if (version)
        orig_version = xml_text2xmlChar(version);
    else
        orig_version = NULL;
 
    switch (standalone)
    {
        case XML_STANDALONE_YES:
            orig_standalone = 1;
            break;
        case XML_STANDALONE_NO:
            orig_standalone = 0;
            break;
        case XML_STANDALONE_NO_VALUE:
            orig_standalone = -1;
            break;
        case XML_STANDALONE_OMITTED:
            /* leave original value */
            break;
    }
 
    initStringInfo(&buf);
    print_xml_decl(&buf, orig_version, 0, orig_standalone);
    appendStringInfoString(&buf, str + len);
 
    return stringinfo_to_xmltype(&buf);
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References appendStringInfoString(), buf, data, fb(), initStringInfo(), len, NO_XML_SUPPORT, str, stringinfo_to_xmltype(), text_to_cstring(), VARHDRSZ, VARSIZE(), XML_STANDALONE_NO, XML_STANDALONE_NO_VALUE, XML_STANDALONE_OMITTED, and XML_STANDALONE_YES.

Referenced by ExecEvalXmlExpr().

xmltotext_with_options()

text * xmltotext_with_options ( xmltype *  data, XmlOptionType  xmloption_arg, bool  indent  )

extern

Definition at line 678 of file xml.c.

{
#ifdef USE_LIBXML
    text       *volatile result;
    xmlDocPtr   doc;
    XmlOptionType parsed_xmloptiontype;
    xmlNodePtr  content_nodes;
    volatile xmlBufferPtr buf = NULL;
    volatile xmlSaveCtxtPtr ctxt = NULL;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
    PgXmlErrorContext *volatile xmlerrcxt = NULL;
#endif
 
    if (xmloption_arg != XMLOPTION_DOCUMENT && !indent)
    {
        /*
         * We don't actually need to do anything, so just return the
         * binary-compatible input.  For backwards-compatibility reasons,
         * allow such cases to succeed even without USE_LIBXML.
         */
        return (text *) data;
    }
 
#ifdef USE_LIBXML
 
    /*
     * Parse the input according to the xmloption.
     *
     * preserve_whitespace is set to false in case we are indenting, otherwise
     * libxml2 will fail to indent elements that have whitespace between them.
     */
    doc = xml_parse(data, xmloption_arg, !indent, GetDatabaseEncoding(),
                    &parsed_xmloptiontype, &content_nodes,
                    (Node *) &escontext);
    if (doc == NULL || escontext.error_occurred)
    {
        if (doc)
            xmlFreeDoc(doc);
        /* A soft error must be failure to conform to XMLOPTION_DOCUMENT */
        ereport(ERROR,
                (errcode(ERRCODE_NOT_AN_XML_DOCUMENT),
                 errmsg("not an XML document")));
    }
 
    /* If we weren't asked to indent, we're done. */
    if (!indent)
    {
        xmlFreeDoc(doc);
        return (text *) data;
    }
 
    /*
     * Otherwise, we gotta spin up some error handling.  Unlike most other
     * routines in this module, we already have a libxml "doc" structure to
     * free, so we need to call pg_xml_init() inside the PG_TRY and be
     * prepared for it to fail (typically due to palloc OOM).
     */
    PG_TRY();
    {
        size_t      decl_len = 0;
 
        xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
 
        /* The serialized data will go into this buffer. */
        buf = xmlBufferCreate();
 
        if (buf == NULL || xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                        "could not allocate xmlBuffer");
 
        /* Detect whether there's an XML declaration */
        parse_xml_decl(xml_text2xmlChar(data), &decl_len, NULL, NULL, NULL);
 
        /*
         * Emit declaration only if the input had one.  Note: some versions of
         * xmlSaveToBuffer leak memory if a non-null encoding argument is
         * passed, so don't do that.  We don't want any encoding conversion
         * anyway.
         */
        if (decl_len == 0)
            ctxt = xmlSaveToBuffer(buf, NULL,
                                   XML_SAVE_NO_DECL | XML_SAVE_FORMAT);
        else
            ctxt = xmlSaveToBuffer(buf, NULL,
                                   XML_SAVE_FORMAT);
 
        if (ctxt == NULL || xmlerrcxt->err_occurred)
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                        "could not allocate xmlSaveCtxt");
 
        if (parsed_xmloptiontype == XMLOPTION_DOCUMENT)
        {
            /* If it's a document, saving is easy. */
            if (xmlSaveDoc(ctxt, doc) == -1 || xmlerrcxt->err_occurred)
                xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                            "could not save document to xmlBuffer");
        }
        else if (content_nodes != NULL)
        {
            /*
             * Deal with the case where we have non-singly-rooted XML.
             * libxml's dump functions don't work well for that without help.
             * We build a fake root node that serves as a container for the
             * content nodes, and then iterate over the nodes.
             */
            xmlNodePtr  root;
            xmlNodePtr  oldroot;
            xmlNodePtr  newline;
 
            root = xmlNewNode(NULL, (const xmlChar *) "content-root");
            if (root == NULL || xmlerrcxt->err_occurred)
                xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                            "could not allocate xml node");
 
            /*
             * This attaches root to doc, so we need not free it separately...
             * but instead, we have to free the old root if there was one.
             */
            oldroot = xmlDocSetRootElement(doc, root);
            if (oldroot != NULL)
                xmlFreeNode(oldroot);
 
            if (xmlAddChildList(root, content_nodes) == NULL ||
                xmlerrcxt->err_occurred)
                xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                            "could not append xml node list");
 
            /*
             * We use this node to insert newlines in the dump.  Note: in at
             * least some libxml versions, xmlNewDocText would not attach the
             * node to the document even if we passed it.  Therefore, manage
             * freeing of this node manually, and pass NULL here to make sure
             * there's not a dangling link.
             */
            newline = xmlNewDocText(NULL, (const xmlChar *) "\n");
            if (newline == NULL || xmlerrcxt->err_occurred)
                xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                            "could not allocate xml node");
 
            for (xmlNodePtr node = root->children; node; node = node->next)
            {
                /* insert newlines between nodes */
                if (node->type != XML_TEXT_NODE && node->prev != NULL)
                {
                    if (xmlSaveTree(ctxt, newline) == -1 || xmlerrcxt->err_occurred)
                    {
                        xmlFreeNode(newline);
                        xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                                    "could not save newline to xmlBuffer");
                    }
                }
 
                if (xmlSaveTree(ctxt, node) == -1 || xmlerrcxt->err_occurred)
                {
                    xmlFreeNode(newline);
                    xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
                                "could not save content to xmlBuffer");
                }
            }
 
            xmlFreeNode(newline);
        }
 
        if (xmlSaveClose(ctxt) == -1 || xmlerrcxt->err_occurred)
        {
            ctxt = NULL;        /* don't try to close it again */
            xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
                        "could not close xmlSaveCtxtPtr");
        }
 
        /*
         * xmlDocContentDumpOutput may add a trailing newline, so remove that.
         */
        if (xmloption_arg == XMLOPTION_DOCUMENT)
        {
            const char *str = (const char *) xmlBufferContent(buf);
            int         len = xmlBufferLength(buf);
 
            while (len > 0 && (str[len - 1] == '\n' ||
                               str[len - 1] == '\r'))
                len--;
 
            result = cstring_to_text_with_len(str, len);
        }
        else
            result = (text *) xmlBuffer_to_xmltype(buf);
    }
    PG_CATCH();
    {
        if (ctxt)
            xmlSaveClose(ctxt);
        if (buf)
            xmlBufferFree(buf);
        xmlFreeDoc(doc);
 
        if (xmlerrcxt)
            pg_xml_done(xmlerrcxt, true);
 
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    xmlBufferFree(buf);
    xmlFreeDoc(doc);
 
    pg_xml_done(xmlerrcxt, false);
 
    return result;
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

References buf, cstring_to_text_with_len(), data, ereport, errcode(), errmsg, ERROR, ErrorSaveContext::error_occurred, fb(), GetDatabaseEncoding(), len, newline, NO_XML_SUPPORT, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pg_xml_done(), pg_xml_init(), PG_XML_STRICTNESS_ALL, result, root, str, xml_ereport(), and XMLOPTION_DOCUMENT.

Referenced by ExecEvalXmlExpr().

Variable Documentation

xmlbinary

PGDLLIMPORT int xmlbinary

extern

Definition at line 108 of file xml.c.

Referenced by map_sql_type_to_xmlschema_type(), and map_sql_value_to_xml_value().

xmloption

PGDLLIMPORT int xmloption

extern

Definition at line 109 of file xml.c.

Referenced by texttoxml(), xml_in(), xml_is_well_formed(), and xml_recv().

XmlTableRoutine

PGDLLIMPORT const TableFuncRoutine XmlTableRoutine

extern

Definition at line 222 of file xml.c.

{
    .InitOpaque = XmlTableInitOpaque,
    .SetDocument = XmlTableSetDocument,
    .SetNamespace = XmlTableSetNamespace,
    .SetRowFilter = XmlTableSetRowFilter,
    .SetColumnFilter = XmlTableSetColumnFilter,
    .FetchRow = XmlTableFetchRow,
    .GetValue = XmlTableGetValue,
    .DestroyOpaque = XmlTableDestroyOpaque
};

Referenced by ExecInitTableFuncScan().