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	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 (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_xmloption (xmltype *data, XmlOptionType xmloption_arg)
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
int	xmlbinary
int	xmloption
const TableFuncRoutine	XmlTableRoutine

Macro Definition Documentation

DatumGetXmlP

#define DatumGetXmlP

(

X

)

((xmltype *) PG_DETOAST_DATUM(X))

Definition at line 50 of file xml.h.

PG_GETARG_XML_P

#define PG_GETARG_XML_P

(

n

)

DatumGetXmlP(PG_GETARG_DATUM(n))

Definition at line 53 of file xml.h.

PG_RETURN_XML_P

#define PG_RETURN_XML_P

(

x

)

PG_RETURN_POINTER(x)

Definition at line 54 of file xml.h.

XmlPGetDatum

#define XmlPGetDatum

(

X

)

PointerGetDatum(X)

Definition at line 51 of file xml.h.

Typedef Documentation

PgXmlErrorContext

typedef struct PgXmlErrorContext PgXmlErrorContext

Definition at line 1 of file xml.h.

xmltype

typedef struct varlena xmltype

Definition at line 1 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

escape_xml()

char* escape_xml

(

const char *

str

)

Definition at line 2353 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 generate_unaccent_rules::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
	)

Definition at line 2036 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(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 */
}

References appendBinaryStringInfo(), appendStringInfo(), appendStringInfoString(), Assert(), buf, 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().

map_sql_value_to_xml_value()

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

Definition at line 2134 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(), get_typlenbyvalalign(), getBaseType(), getTypeOutputInfo(), i, initStringInfo(), j2date(), 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(), generate_unaccent_rules::str, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, generate_unaccent_rules::type, type_is_array_domain, USE_XSD_DATES, value, VARDATA_ANY, VARSIZE_ANY_EXHDR, xml_ereport(), xmlbinary, and XMLBINARY_BASE64.

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

map_xml_name_to_sql_identifier()

char* map_xml_name_to_sql_identifier

(

const char *

name

)

Definition at line 2092 of file xml.c.

{
    StringInfoData buf;
    const 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) == '_')
        {
            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(p));
    }
 
    return buf.data;
}

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

Referenced by get_rule_expr().

pg_xml_done()

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().

pg_xml_error_occurred()

bool pg_xml_error_occurred

(

PgXmlErrorContext *

errcxt

)

pg_xml_init()

PgXmlErrorContext* pg_xml_init

(

PgXmlStrictness

strictness

)

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

pg_xml_init_library()

void pg_xml_init_library

(

void

)

xml_ereport()

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().

xml_is_document()

bool xml_is_document

(

xmltype *

arg

)

Definition at line 888 of file xml.c.

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

References arg, 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().

xmlconcat()

xmltype* xmlconcat

(

List *

args

)

Definition at line 512 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(), generate_unaccent_rules::args, buf, DatumGetXmlP, initStringInfo(), len, lfirst, NO_XML_SUPPORT, pfree(), PointerGetDatum, generate_unaccent_rules::str, stringinfo_to_xmltype(), text_to_cstring(), VARHDRSZ, VARSIZE, and x.

Referenced by ExecEvalXmlExpr(), and xmlconcat2().

xmlelement()

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

Definition at line 628 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");
 
        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
}

References arg, XmlExpr::arg_names, XmlExpr::args, buf, 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, generate_unaccent_rules::str, strVal, and xml_ereport().

Referenced by ExecEvalXmlExpr().

xmlparse()

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

Definition at line 752 of file xml.c.

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

References data, GetDatabaseEncoding(), and NO_XML_SUPPORT.

Referenced by ExecEvalXmlExpr(), and texttoxml().

xmlpi()

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

Definition at line 770 of file xml.c.

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

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

Referenced by ExecEvalXmlExpr().

xmlroot()

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

Definition at line 822 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, initStringInfo(), len, NO_XML_SUPPORT, generate_unaccent_rules::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_xmloption()

text* xmltotext_with_xmloption	(	xmltype *	data,
		XmlOptionType	xmloption_arg
	)

Definition at line 615 of file xml.c.

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

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

Referenced by ExecEvalXmlExpr().

Variable Documentation

xmlbinary

int xmlbinary

extern

Definition at line 97 of file xml.c.

Referenced by map_sql_type_to_xmlschema_type(), and map_sql_value_to_xml_value().

xmloption

int xmloption

extern

Definition at line 98 of file xml.c.

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

XmlTableRoutine

const TableFuncRoutine XmlTableRoutine

extern

Definition at line 207 of file xml.c.

Referenced by ExecInitTableFuncScan().