xml.h File Reference

#include "fmgr.h"
#include "nodes/execnodes.h"
#include "nodes/primnodes.h"
#include "executor/tablefunc.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	DatumGetXmlP(X)   ((xmltype *) PG_DETOAST_DATUM(X))
#define	XmlPGetDatum(X)   PointerGetDatum(X)
#define	PG_GETARG_XML_P(n)   DatumGetXmlP(PG_GETARG_DATUM(n))
#define	PG_RETURN_XML_P(x)   PG_RETURN_POINTER(x)

Typedefs
typedef struct 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
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, Datum *named_argvalue, bool *named_argnull, Datum *argvalue, bool *argnull)
xmltype *	xmlparse (text *data, XmlOptionType xmloption, bool preserve_whitespace)
xmltype *	xmlpi (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_xmloption (xmltype *data, XmlOptionType xmloption_arg)
char *	escape_xml (const char *str)
char *	map_sql_identifier_to_xml_name (char *ident, bool fully_escaped, bool escape_period)
char *	map_xml_name_to_sql_identifier (char *name)
char *	map_sql_value_to_xml_value (Datum value, Oid type, bool xml_escape_strings)

Variables
int	xmlbinary
int	xmloption
const TableFuncRoutine	XmlTableRoutine

Macro Definition Documentation

#define DatumGetXmlP

(

X

)

((xmltype *) PG_DETOAST_DATUM(X))

Definition at line 50 of file xml.h.

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

#define PG_GETARG_XML_P

(

n

)

DatumGetXmlP(PG_GETARG_DATUM(n))

Definition at line 53 of file xml.h.

Referenced by xml_out(), xml_send(), xmlconcat2(), xmlexists(), xmltotext(), xpath(), and xpath_exists().

#define PG_RETURN_XML_P

(

x

)

PG_RETURN_POINTER(x)

Definition at line 54 of file xml.h.

Referenced by cursor_to_xml(), cursor_to_xmlschema(), database_to_xml(), database_to_xml_and_xmlschema(), database_to_xmlschema(), query_to_xml(), query_to_xml_and_xmlschema(), query_to_xmlschema(), schema_to_xml(), schema_to_xml_and_xmlschema(), schema_to_xmlschema(), table_to_xml(), table_to_xml_and_xmlschema(), table_to_xmlschema(), texttoxml(), xml_in(), xml_recv(), xmlcomment(), and xmlconcat2().

#define XmlPGetDatum

(

X

)

PointerGetDatum(X)

Definition at line 51 of file xml.h.

Typedef Documentation

typedef struct PgXmlErrorContext PgXmlErrorContext

Definition at line 48 of file xml.h.

typedef struct varlena xmltype

Definition at line 23 of file xml.h.

Enumeration Type Documentation

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;

enum XmlBinaryType

Enumerator
XMLBINARY_BASE64
XMLBINARY_HEX

Definition at line 33 of file xml.h.

{
    XMLBINARY_BASE64,
    XMLBINARY_HEX
}           XmlBinaryType;

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

char* escape_xml

(

const char *

str

)

Definition at line 2232 of file xml.c.

References appendStringInfoCharMacro, appendStringInfoString(), buf, StringInfoData::data, and initStringInfo().

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

{
    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;
}

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

Definition at line 1897 of file xml.c.

References appendBinaryStringInfo(), appendStringInfo(), appendStringInfoString(), Assert, buf, StringInfoData::data, initStringInfo(), NO_XML_SUPPORT, pg_mblen(), 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().

{
#ifdef USE_LIBXML
    StringInfoData buf;
    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(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(p));
        }
    }

    return buf.data;
#else                           /* not USE_LIBXML */
    NO_XML_SUPPORT();
    return NULL;
#endif                          /* not USE_LIBXML */
}

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

Definition at line 2013 of file xml.c.

References appendStringInfoString(), ARR_ELEMTYPE, BOOLOID, buf, BYTEAOID, StringInfoData::data, DATE_NOT_FINITE, DATEOID, DatumGetArrayTypeP, DatumGetBool, DatumGetByteaPP, DatumGetDateADT, DatumGetTimestamp, deconstruct_array(), EncodeDateOnly(), EncodeDateTime(), ereport, errcode(), errdetail(), errmsg(), ERROR, escape_xml(), 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(), timestamp2tm(), TIMESTAMP_NOT_FINITE, TIMESTAMPOID, TIMESTAMPTZOID, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, type_is_array_domain, USE_XSD_DATES, VARDATA_ANY, VARSIZE_ANY_EXHDR, xml_ereport(), xmlbinary, XMLBINARY_BASE64, and XMLOID.

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

{
    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);
    }
}

char* map_xml_name_to_sql_identifier

(

char *

name

)

Definition at line 1973 of file xml.c.

References appendBinaryStringInfo(), appendStringInfoString(), buf, StringInfoData::data, initStringInfo(), pg_mblen(), and unicode_to_sqlchar().

Referenced by get_rule_expr().

{
    StringInfoData buf;
    char       *p;

    initStringInfo(&buf);

    for (p = name; *p; p += pg_mblen(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) == '_')
        {
            unsigned int u;

            sscanf(p + 2, "%X", &u);
            appendStringInfoString(&buf, unicode_to_sqlchar(u));
            p += 6;
        }
        else
            appendBinaryStringInfo(&buf, p, pg_mblen(p));
    }

    return buf.data;
}

void pg_xml_done	(	PgXmlErrorContext *	errcxt,
		bool	isError
	)

Referenced by map_sql_value_to_xml_value(), pgxml_xpath(), xml_is_well_formed(), xmlelement(), XmlTableDestroyOpaque(), XmlTableInitOpaque(), xpath_table(), and xslt_process().

bool pg_xml_error_occurred

(

PgXmlErrorContext *

errcxt

)

PgXmlErrorContext* pg_xml_init

(

PgXmlStrictness

strictness

)

Referenced by map_sql_value_to_xml_value(), pgxml_parser_init(), xmlelement(), and XmlTableInitOpaque().

void pg_xml_init_library

(

void

)

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

Referenced by map_sql_value_to_xml_value(), pgxml_xpath(), xmlelement(), XmlTableFetchRow(), XmlTableGetValue(), XmlTableInitOpaque(), XmlTableSetColumnFilter(), XmlTableSetDocument(), XmlTableSetNamespace(), XmlTableSetRowFilter(), xpath_table(), and xslt_process().

bool xml_is_document

(

xmltype *

arg

)

Definition at line 886 of file xml.c.

References CopyErrorData(), CurrentMemoryContext, FlushErrorState(), GetDatabaseEncoding(), MemoryContextSwitchTo(), NO_XML_SUPPORT, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, ErrorData::sqlerrcode, and XMLOPTION_DOCUMENT.

Referenced by ExecEvalXmlExpr(), and xmltotext_with_xmloption().

{
#ifdef USE_LIBXML
    bool        result;
    volatile xmlDocPtr doc = NULL;
    MemoryContext ccxt = CurrentMemoryContext;

    /* We want to catch ereport(INVALID_XML_DOCUMENT) and return false */
    PG_TRY();
    {
        doc = xml_parse((text *) arg, XMLOPTION_DOCUMENT, true,
                        GetDatabaseEncoding());
        result = true;
    }
    PG_CATCH();
    {
        ErrorData  *errdata;
        MemoryContext ecxt;

        ecxt = MemoryContextSwitchTo(ccxt);
        errdata = CopyErrorData();
        if (errdata->sqlerrcode == ERRCODE_INVALID_XML_DOCUMENT)
        {
            FlushErrorState();
            result = false;
        }
        else
        {
            MemoryContextSwitchTo(ecxt);
            PG_RE_THROW();
        }
    }
    PG_END_TRY();

    if (doc)
        xmlFreeDoc(doc);

    return result;
#else                           /* not USE_LIBXML */
    NO_XML_SUPPORT();
    return false;
#endif                          /* not USE_LIBXML */
}

xmltype* xmlconcat

(

List *

args

)

Definition at line 510 of file xml.c.

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

Referenced by ExecEvalXmlExpr(), and xmlconcat2().

{
#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);

        appendStringInfoString(&buf2, buf.data);
        buf = buf2;
    }

    return stringinfo_to_xmltype(&buf);
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

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

Definition at line 626 of file xml.c.

References arg, XmlExpr::arg_names, XmlExpr::args, ERROR, exprType(), forboth, i, lappend(), lfirst, map_sql_value_to_xml_value(), XmlExpr::name, 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, strVal, and xml_ereport().

Referenced by ExecEvalXmlExpr().

{
#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");

        xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name);

        forboth(arg, named_arg_strings, narg, xexpr->arg_names)
        {
            char       *str = (char *) lfirst(arg);
            char       *argname = strVal(lfirst(narg));

            if (str)
                xmlTextWriterWriteAttribute(writer,
                                            (xmlChar *) argname,
                                            (xmlChar *) str);
        }

        foreach(arg, arg_strings)
        {
            char       *str = (char *) lfirst(arg);

            xmlTextWriterWriteRaw(writer, (xmlChar *) str);
        }

        xmlTextWriterEndElement(writer);

        /* 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
}

xmltype* xmlparse	(	text *	data,
		XmlOptionType	xmloption,
		bool	preserve_whitespace
	)

Definition at line 750 of file xml.c.

References GetDatabaseEncoding(), and NO_XML_SUPPORT.

Referenced by ExecEvalXmlExpr(), and texttoxml().

{
#ifdef USE_LIBXML
    xmlDocPtr   doc;

    doc = xml_parse(data, xmloption_arg, preserve_whitespace,
                    GetDatabaseEncoding());
    xmlFreeDoc(doc);

    return (xmltype *) data;
#else
    NO_XML_SUPPORT();
    return NULL;
#endif
}

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

Definition at line 768 of file xml.c.

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), buf, StringInfoData::data, ereport, errcode(), errdetail(), errmsg(), ERROR, initStringInfo(), NO_XML_SUPPORT, pfree(), pg_strcasecmp(), stringinfo_to_xmltype(), and text_to_cstring().

Referenced by ExecEvalXmlExpr().

{
#ifdef USE_LIBXML
    xmltype    *result;
    StringInfoData buf;

    if (pg_strcasecmp(target, "xml") == 0)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR), /* really */
                 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
}

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

Definition at line 820 of file xml.c.

References appendStringInfoString(), buf, initStringInfo(), NO_XML_SUPPORT, 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().

{
#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
}

text* xmltotext_with_xmloption	(	xmltype *	data,
		XmlOptionType	xmloption_arg
	)

Definition at line 613 of file xml.c.

References ereport, errcode(), errmsg(), ERROR, xml_is_document(), and XMLOPTION_DOCUMENT.

Referenced by ExecEvalXmlExpr().

{
    if (xmloption_arg == XMLOPTION_DOCUMENT && !xml_is_document(data))
        ereport(ERROR,
                (errcode(ERRCODE_NOT_AN_XML_DOCUMENT),
                 errmsg("not an XML document")));

    /* It's actually binary compatible, save for the above check. */
    return (text *) data;
}

Variable Documentation

int xmlbinary

Definition at line 96 of file xml.c.

Referenced by map_sql_type_to_xmlschema_type(), and map_sql_value_to_xml_value().

int xmloption

Definition at line 97 of file xml.c.

Referenced by _copyXmlExpr(), _copyXmlSerialize(), _equalXmlExpr(), _equalXmlSerialize(), _outXmlExpr(), _outXmlSerialize(), _readXmlExpr(), texttoxml(), xml_in(), xml_is_well_formed(), and xml_recv().

const TableFuncRoutine XmlTableRoutine

Definition at line 205 of file xml.c.

Referenced by ExecInitTableFuncScan().