string_utils.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include "fe_utils/string_utils.h"
#include "common/keywords.h"

Include dependency graph for string_utils.c:

Go to the source code of this file.

Macros
#define	WHEREAND()

Functions
static PQExpBuffer	defaultGetLocalPQExpBuffer (void)
const char *	fmtId (const char *rawid)
const char *	fmtQualifiedId (int remoteVersion, const char *schema, const char *id)
char *	formatPGVersionNumber (int version_number, bool include_minor, char *buf, size_t buflen)
void	appendStringLiteral (PQExpBuffer buf, const char *str, int encoding, bool std_strings)
void	appendStringLiteralConn (PQExpBuffer buf, const char *str, PGconn *conn)
void	appendStringLiteralDQ (PQExpBuffer buf, const char *str, const char *dqprefix)
void	appendByteaLiteral (PQExpBuffer buf, const unsigned char *str, size_t length, bool std_strings)
void	appendShellString (PQExpBuffer buf, const char *str)
bool	appendShellStringNoError (PQExpBuffer buf, const char *str)
void	appendConnStrVal (PQExpBuffer buf, const char *str)
void	appendPsqlMetaConnect (PQExpBuffer buf, const char *dbname)
bool	parsePGArray (const char *atext, char ***itemarray, int *nitems)
bool	appendReloptionsArray (PQExpBuffer buffer, const char *reloptions, const char *prefix, int encoding, bool std_strings)
bool	processSQLNamePattern (PGconn *conn, PQExpBuffer buf, const char *pattern, bool have_where, bool force_escape, const char *schemavar, const char *namevar, const char *altnamevar, const char *visibilityrule)

Variables
int	quote_all_identifiers = 0
PQExpBuffer(*	getLocalPQExpBuffer )(void)

Macro Definition Documentation

#define WHEREAND

(

)

Value:

(appendPQExpBufferStr(buf, have_where ? "  AND " : "WHERE "), \
     have_where = true, added_clause = true)

Referenced by processSQLNamePattern().

Function Documentation

void appendByteaLiteral	(	PQExpBuffer	buf,
		const unsigned char *	str,
		size_t	length,
		bool	std_strings
	)

Definition at line 379 of file string_utils.c.

References PQExpBufferData::data, enlargePQExpBuffer(), hextbl, and PQExpBufferData::len.

{
    const unsigned char *source = str;
    char       *target;

    static const char hextbl[] = "0123456789abcdef";

    /*
     * This implementation is hard-wired to produce hex-format output. We do
     * not know the server version the output will be loaded into, so making
     * an intelligent format choice is impossible.  It might be better to
     * always use the old escaped format.
     */
    if (!enlargePQExpBuffer(buf, 2 * length + 5))
        return;

    target = buf->data + buf->len;
    *target++ = '\'';
    if (!std_strings)
        *target++ = '\\';
    *target++ = '\\';
    *target++ = 'x';

    while (length-- > 0)
    {
        unsigned char c = *source++;

        *target++ = hextbl[(c >> 4) & 0xF];
        *target++ = hextbl[c & 0xF];
    }

    /* Write the terminating quote and NUL character. */
    *target++ = '\'';
    *target = '\0';

    buf->len = target - buf->data;
}

void appendConnStrVal	(	PQExpBuffer	buf,
		const char *	str
	)

Definition at line 551 of file string_utils.c.

References appendPQExpBufferChar(), and appendPQExpBufferStr().

Referenced by _connectDB(), appendPsqlMetaConnect(), CloneArchive(), cluster_all_databases(), constructConnStr(), create_new_objects(), do_connect(), generate_old_dump(), GenerateRecoveryConf(), get_db_conn(), reindex_all_databases(), restore_toc_entry(), runPgDump(), and vacuum_all_databases().

{
    const char *s;
    bool        needquotes;

    /*
     * If the string is one or more plain ASCII characters, no need to quote
     * it. This is quite conservative, but better safe than sorry.
     */
    needquotes = true;
    for (s = str; *s; s++)
    {
        if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
              (*s >= '0' && *s <= '9') || *s == '_' || *s == '.'))
        {
            needquotes = true;
            break;
        }
        needquotes = false;
    }

    if (needquotes)
    {
        appendPQExpBufferChar(buf, '\'');
        while (*str)
        {
            /* ' and \ must be escaped by to \' and \\ */
            if (*str == '\'' || *str == '\\')
                appendPQExpBufferChar(buf, '\\');

            appendPQExpBufferChar(buf, *str);
            str++;
        }
        appendPQExpBufferChar(buf, '\'');
    }
    else
        appendPQExpBufferStr(buf, str);
}

void appendPsqlMetaConnect	(	PQExpBuffer	buf,
		const char *	dbname
	)

Definition at line 596 of file string_utils.c.

References _, appendConnStrVal(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), connstr, PQExpBufferData::data, EXIT_FAILURE, fmtId(), initPQExpBuffer(), and termPQExpBuffer().

Referenced by _reconnectToDB(), dumpCreateDB(), dumpDatabases(), new_9_0_populate_pg_largeobject_metadata(), and old_9_6_invalidate_hash_indexes().

{
    const char *s;
    bool complex;

    /*
     * If the name is plain ASCII characters, emit a trivial "\connect "foo"".
     * For other names, even many not technically requiring it, skip to the
     * general case.  No database has a zero-length name.
     */
    complex = false;

    for (s = dbname; *s; s++)
    {
        if (*s == '\n' || *s == '\r')
        {
            fprintf(stderr,
                    _("database name contains a newline or carriage return: \"%s\"\n"),
                    dbname);
            exit(EXIT_FAILURE);
        }

        if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
              (*s >= '0' && *s <= '9') || *s == '_' || *s == '.'))
        {
            complex = true;
        }
    }

    appendPQExpBufferStr(buf, "\\connect ");
    if (complex)
    {
        PQExpBufferData connstr;

        initPQExpBuffer(&connstr);
        appendPQExpBuffer(&connstr, "dbname=");
        appendConnStrVal(&connstr, dbname);

        appendPQExpBuffer(buf, "-reuse-previous=on ");

        /*
         * As long as the name does not contain a newline, SQL identifier
         * quoting satisfies the psql meta-command parser.  Prefer not to
         * involve psql-interpreted single quotes, which behaved differently
         * before PostgreSQL 9.2.
         */
        appendPQExpBufferStr(buf, fmtId(connstr.data));

        termPQExpBuffer(&connstr);
    }
    else
        appendPQExpBufferStr(buf, fmtId(dbname));
    appendPQExpBufferChar(buf, '\n');
}

bool appendReloptionsArray	(	PQExpBuffer	buffer,
		const char *	reloptions,
		const char *	prefix,
		int	encoding,
		bool	std_strings
	)

Definition at line 747 of file string_utils.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteral(), fmtId(), free, i, name, noptions, options, parsePGArray(), and value.

Referenced by appendReloptionsArrayAH(), and get_create_object_cmd().

{
    char      **options;
    int         noptions;
    int         i;

    if (!parsePGArray(reloptions, &options, &noptions))
    {
        if (options)
            free(options);
        return false;
    }

    for (i = 0; i < noptions; i++)
    {
        char       *option = options[i];
        char       *name;
        char       *separator;
        char       *value;

        /*
         * Each array element should have the form name=value.  If the "=" is
         * missing for some reason, treat it like an empty value.
         */
        name = option;
        separator = strchr(option, '=');
        if (separator)
        {
            *separator = '\0';
            value = separator + 1;
        }
        else
            value = "";

        if (i > 0)
            appendPQExpBufferStr(buffer, ", ");
        appendPQExpBuffer(buffer, "%s%s=", prefix, fmtId(name));

        /*
         * In general we need to quote the value; but to avoid unnecessary
         * clutter, do not quote if it is an identifier that would not need
         * quoting.  (We could also allow numbers, but that is a bit trickier
         * than it looks --- for example, are leading zeroes significant?  We
         * don't want to assume very much here about what custom reloptions
         * might mean.)
         */
        if (strcmp(fmtId(value), value) == 0)
            appendPQExpBufferStr(buffer, value);
        else
            appendStringLiteral(buffer, value, encoding, std_strings);
    }

    if (options)
        free(options);

    return true;
}

void appendShellString	(	PQExpBuffer	buf,
		const char *	str
	)

Definition at line 434 of file string_utils.c.

References _, appendShellStringNoError(), and EXIT_FAILURE.

Referenced by cluster_conn_opts(), create_new_objects(), create_script_for_cluster_analyze(), generate_old_dump(), main(), and runPgDump().

{
    if (!appendShellStringNoError(buf, str))
    {
        fprintf(stderr,
                _("shell command argument contains a newline or carriage return: \"%s\"\n"),
                str);
        exit(EXIT_FAILURE);
    }
}

bool appendShellStringNoError	(	PQExpBuffer	buf,
		const char *	str
	)

Definition at line 446 of file string_utils.c.

References appendPQExpBufferChar(), and appendPQExpBufferStr().

Referenced by appendShellString(), and psql_get_variable().

{
#ifdef WIN32
    int         backslash_run_length = 0;
#endif
    bool        ok = true;
    const char *p;

    /*
     * Don't bother with adding quotes if the string is nonempty and clearly
     * contains only safe characters.
     */
    if (*str != '\0' &&
        strspn(str, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_./:") == strlen(str))
    {
        appendPQExpBufferStr(buf, str);
        return ok;
    }

#ifndef WIN32
    appendPQExpBufferChar(buf, '\'');
    for (p = str; *p; p++)
    {
        if (*p == '\n' || *p == '\r')
        {
            ok = false;
            continue;
        }

        if (*p == '\'')
            appendPQExpBufferStr(buf, "'\"'\"'");
        else
            appendPQExpBufferChar(buf, *p);
    }
    appendPQExpBufferChar(buf, '\'');
#else                           /* WIN32 */

    /*
     * A Windows system() argument experiences two layers of interpretation.
     * First, cmd.exe interprets the string.  Its behavior is undocumented,
     * but a caret escapes any byte except LF or CR that would otherwise have
     * special meaning.  Handling of a caret before LF or CR differs between
     * "cmd.exe /c" and other modes, and it is unusable here.
     *
     * Second, the new process parses its command line to construct argv (see
     * https://msdn.microsoft.com/en-us/library/17w5ykft.aspx).  This treats
     * backslash-double quote sequences specially.
     */
    appendPQExpBufferStr(buf, "^\"");
    for (p = str; *p; p++)
    {
        if (*p == '\n' || *p == '\r')
        {
            ok = false;
            continue;
        }

        /* Change N backslashes before a double quote to 2N+1 backslashes. */
        if (*p == '"')
        {
            while (backslash_run_length)
            {
                appendPQExpBufferStr(buf, "^\\");
                backslash_run_length--;
            }
            appendPQExpBufferStr(buf, "^\\");
        }
        else if (*p == '\\')
            backslash_run_length++;
        else
            backslash_run_length = 0;

        /*
         * Decline to caret-escape the most mundane characters, to ease
         * debugging and lest we approach the command length limit.
         */
        if (!((*p >= 'a' && *p <= 'z') ||
              (*p >= 'A' && *p <= 'Z') ||
              (*p >= '0' && *p <= '9')))
            appendPQExpBufferChar(buf, '^');
        appendPQExpBufferChar(buf, *p);
    }

    /*
     * Change N backslashes at end of argument to 2N backslashes, because they
     * precede the double quote that terminates the argument.
     */
    while (backslash_run_length)
    {
        appendPQExpBufferStr(buf, "^\\");
        backslash_run_length--;
    }
    appendPQExpBufferStr(buf, "^\"");
#endif                          /* WIN32 */

    return ok;
}

void appendStringLiteral	(	PQExpBuffer	buf,
		const char *	str,
		int	encoding,
		bool	std_strings
	)

Definition at line 220 of file string_utils.c.

References PQExpBufferData::data, enlargePQExpBuffer(), i, IS_HIGHBIT_SET, PQExpBufferData::len, length(), PQExpBufferData::maxlen, PQmblen(), and SQL_STR_DOUBLE.

Referenced by appendReloptionsArray(), and appendStringLiteralConn().

{
    size_t      length = strlen(str);
    const char *source = str;
    char       *target;

    if (!enlargePQExpBuffer(buf, 2 * length + 2))
        return;

    target = buf->data + buf->len;
    *target++ = '\'';

    while (*source != '\0')
    {
        char        c = *source;
        int         len;
        int         i;

        /* Fast path for plain ASCII */
        if (!IS_HIGHBIT_SET(c))
        {
            /* Apply quoting if needed */
            if (SQL_STR_DOUBLE(c, !std_strings))
                *target++ = c;
            /* Copy the character */
            *target++ = c;
            source++;
            continue;
        }

        /* Slow path for possible multibyte characters */
        len = PQmblen(source, encoding);

        /* Copy the character */
        for (i = 0; i < len; i++)
        {
            if (*source == '\0')
                break;
            *target++ = *source++;
        }

        /*
         * If we hit premature end of string (ie, incomplete multibyte
         * character), try to pad out to the correct length with spaces. We
         * may not be able to pad completely, but we will always be able to
         * insert at least one pad space (since we'd not have quoted a
         * multibyte character).  This should be enough to make a string that
         * the server will error out on.
         */
        if (i < len)
        {
            char       *stop = buf->data + buf->maxlen - 2;

            for (; i < len; i++)
            {
                if (target >= stop)
                    break;
                *target++ = ' ';
            }
            break;
        }
    }

    /* Write the terminating quote and NUL character. */
    *target++ = '\'';
    *target = '\0';

    buf->len = target - buf->data;
}

void appendStringLiteralConn	(	PQExpBuffer	buf,
		const char *	str,
		PGconn *	conn
	)

Definition at line 298 of file string_utils.c.

References appendPQExpBufferChar(), appendStringLiteral(), PQExpBufferData::data, enlargePQExpBuffer(), ESCAPE_STRING_SYNTAX, PQExpBufferData::len, length(), PQclientEncoding(), PQescapeStringConn(), and PQserverVersion().

Referenced by dumpCreateDB(), dumpDatabaseConfig(), dumpRoles(), dumpTablespaces(), dumpUserConfig(), emitShSecLabels(), exec_command_password(), getTables(), lookup_object_oid(), main(), makeAlterConfigCommand(), processSQLNamePattern(), and setup_connection().

{
    size_t      length = strlen(str);

    /*
     * XXX This is a kluge to silence escape_string_warning in our utility
     * programs.  It should go away someday.
     */
    if (strchr(str, '\\') != NULL && PQserverVersion(conn) >= 80100)
    {
        /* ensure we are not adjacent to an identifier */
        if (buf->len > 0 && buf->data[buf->len - 1] != ' ')
            appendPQExpBufferChar(buf, ' ');
        appendPQExpBufferChar(buf, ESCAPE_STRING_SYNTAX);
        appendStringLiteral(buf, str, PQclientEncoding(conn), false);
        return;
    }
    /* XXX end kluge */

    if (!enlargePQExpBuffer(buf, 2 * length + 2))
        return;
    appendPQExpBufferChar(buf, '\'');
    buf->len += PQescapeStringConn(conn, buf->data + buf->len,
                                   str, length, NULL);
    appendPQExpBufferChar(buf, '\'');
}

void appendStringLiteralDQ	(	PQExpBuffer	buf,
		const char *	str,
		const char *	dqprefix
	)

Definition at line 336 of file string_utils.c.

References appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), PQExpBufferData::data, and destroyPQExpBuffer().

Referenced by dumpFunc().

{
    static const char suffixes[] = "_XXXXXXX";
    int         nextchar = 0;
    PQExpBuffer delimBuf = createPQExpBuffer();

    /* start with $ + dqprefix if not NULL */
    appendPQExpBufferChar(delimBuf, '$');
    if (dqprefix)
        appendPQExpBufferStr(delimBuf, dqprefix);

    /*
     * Make sure we choose a delimiter which (without the trailing $) is not
     * present in the string being quoted. We don't check with the trailing $
     * because a string ending in $foo must not be quoted with $foo$.
     */
    while (strstr(str, delimBuf->data) != NULL)
    {
        appendPQExpBufferChar(delimBuf, suffixes[nextchar++]);
        nextchar %= sizeof(suffixes) - 1;
    }

    /* add trailing $ */
    appendPQExpBufferChar(delimBuf, '$');

    /* quote it and we are all done */
    appendPQExpBufferStr(buf, delimBuf->data);
    appendPQExpBufferStr(buf, str);
    appendPQExpBufferStr(buf, delimBuf->data);

    destroyPQExpBuffer(delimBuf);
}

static PQExpBuffer defaultGetLocalPQExpBuffer ( void  )

static

const char* fmtId

(

const char *

rawid

)

Definition at line 66 of file string_utils.c.

References appendPQExpBufferChar(), appendPQExpBufferStr(), ScanKeyword::category, PQExpBufferData::data, getLocalPQExpBuffer, NumScanKeywords, quote_all_identifiers, ScanKeywordLookup(), ScanKeywords, and UNRESERVED_KEYWORD.

Referenced by _disableTriggersIfNecessary(), _doSetFixedOutputState(), _enableTriggersIfNecessary(), _getObjectDescription(), _printTocEntry(), _selectOutputSchema(), _selectTablespace(), appendPsqlMetaConnect(), appendReloptionsArray(), binary_upgrade_extension_member(), buildACLCommands(), buildDefaultACLCommands(), createDummyViewAsClause(), describeOneTableDetails(), dropDBs(), dropRoles(), dropTablespaces(), dumpAccessMethod(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpCreateDB(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpGroups(), dumpIndex(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationTable(), dumpRangeType(), dumpRoleMembership(), dumpRoles(), dumpRule(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpSubscription(), dumpTable(), dumpTableComment(), dumpTableConstraintComment(), dumpTableData(), dumpTableData_insert(), dumpTableSchema(), dumpTableSecLabel(), dumpTablespaces(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), emitShSecLabels(), exec_command_password(), fmtCopyColumnList(), fmtQualifiedId(), format_aggregate_signature(), format_function_arguments(), format_function_arguments_old(), format_function_signature(), get_create_object_cmd(), get_language_name(), main(), makeAlterConfigCommand(), refreshMatViewData(), reindex_one_database(), reindex_system_catalogs(), restore_toc_entry(), selectSourceSchema(), and setup_connection().

{
    PQExpBuffer id_return = getLocalPQExpBuffer();

    const char *cp;
    bool        need_quotes = false;

    /*
     * These checks need to match the identifier production in scan.l. Don't
     * use islower() etc.
     */
    if (quote_all_identifiers)
        need_quotes = true;
    /* slightly different rules for first character */
    else if (!((rawid[0] >= 'a' && rawid[0] <= 'z') || rawid[0] == '_'))
        need_quotes = true;
    else
    {
        /* otherwise check the entire string */
        for (cp = rawid; *cp; cp++)
        {
            if (!((*cp >= 'a' && *cp <= 'z')
                  || (*cp >= '0' && *cp <= '9')
                  || (*cp == '_')))
            {
                need_quotes = true;
                break;
            }
        }
    }

    if (!need_quotes)
    {
        /*
         * Check for keyword.  We quote keywords except for unreserved ones.
         * (In some cases we could avoid quoting a col_name or type_func_name
         * keyword, but it seems much harder than it's worth to tell that.)
         *
         * Note: ScanKeywordLookup() does case-insensitive comparison, but
         * that's fine, since we already know we have all-lower-case.
         */
        const ScanKeyword *keyword = ScanKeywordLookup(rawid,
                                                       ScanKeywords,
                                                       NumScanKeywords);

        if (keyword != NULL && keyword->category != UNRESERVED_KEYWORD)
            need_quotes = true;
    }

    if (!need_quotes)
    {
        /* no quoting needed */
        appendPQExpBufferStr(id_return, rawid);
    }
    else
    {
        appendPQExpBufferChar(id_return, '"');
        for (cp = rawid; *cp; cp++)
        {
            /*
             * Did we find a double-quote in the string? Then make this a
             * double double-quote per SQL99. Before, we put in a
             * backslash/double-quote pair. - thomas 2000-08-05
             */
            if (*cp == '"')
                appendPQExpBufferChar(id_return, '"');
            appendPQExpBufferChar(id_return, *cp);
        }
        appendPQExpBufferChar(id_return, '"');
    }

    return id_return->data;
}

const char* fmtQualifiedId	(	int	remoteVersion,
		const char *	schema,
		const char *	id
	)

Definition at line 150 of file string_utils.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), and getLocalPQExpBuffer.

Referenced by dumpTableData(), dumpTableData_copy(), dumpTableData_insert(), getTables(), lockTableForWorker(), and vacuum_one_database().

{
    PQExpBuffer id_return;
    PQExpBuffer lcl_pqexp = createPQExpBuffer();

    /* Suppress schema name if fetching from pre-7.3 DB */
    if (remoteVersion >= 70300 && schema && *schema)
    {
        appendPQExpBuffer(lcl_pqexp, "%s.", fmtId(schema));
    }
    appendPQExpBufferStr(lcl_pqexp, fmtId(id));

    id_return = getLocalPQExpBuffer();

    appendPQExpBufferStr(id_return, lcl_pqexp->data);
    destroyPQExpBuffer(lcl_pqexp);

    return id_return->data;
}

char* formatPGVersionNumber	(	int	version_number,
		bool	include_minor,
		char *	buf,
		size_t	buflen
	)

Definition at line 182 of file string_utils.c.

References buf, and snprintf().

Referenced by connection_warnings(), describeAccessMethods(), describeFunctions(), describePublications(), describeSubscriptions(), describeTablespaces(), exec_command_ef_ev(), exec_command_sf_sv(), listCollations(), listDbRoleSettings(), listDefaultACLs(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listPublications(), listTSConfigs(), listTSDictionaries(), listTSParsers(), listTSTemplates(), listUserMappings(), SendQuery(), and SyncVariables().

{
    if (version_number >= 100000)
    {
        /* New two-part style */
        if (include_minor)
            snprintf(buf, buflen, "%d.%d", version_number / 10000,
                     version_number % 10000);
        else
            snprintf(buf, buflen, "%d", version_number / 10000);
    }
    else
    {
        /* Old three-part style */
        if (include_minor)
            snprintf(buf, buflen, "%d.%d.%d", version_number / 10000,
                     (version_number / 100) % 100,
                     version_number % 100);
        else
            snprintf(buf, buflen, "%d.%d", version_number / 10000,
                     (version_number / 100) % 100);
    }
    return buf;
}

bool parsePGArray	(	const char *	atext,
		char ***	itemarray,
		int *	nitems
	)

Definition at line 663 of file string_utils.c.

References malloc.

Referenced by appendReloptionsArray(), buildACLCommands(), dumpFunc(), dumpSubscription(), and processExtensionTables().

{
    int         inputlen;
    char      **items;
    char       *strings;
    int         curitem;

    /*
     * We expect input in the form of "{item,item,item}" where any item is
     * either raw data, or surrounded by double quotes (in which case embedded
     * characters including backslashes and quotes are backslashed).
     *
     * We build the result as an array of pointers followed by the actual
     * string data, all in one malloc block for convenience of deallocation.
     * The worst-case storage need is not more than one pointer and one
     * character for each input character (consider "{,,,,,,,,,,}").
     */
    *itemarray = NULL;
    *nitems = 0;
    inputlen = strlen(atext);
    if (inputlen < 2 || atext[0] != '{' || atext[inputlen - 1] != '}')
        return false;           /* bad input */
    items = (char **) malloc(inputlen * (sizeof(char *) + sizeof(char)));
    if (items == NULL)
        return false;           /* out of memory */
    *itemarray = items;
    strings = (char *) (items + inputlen);

    atext++;                    /* advance over initial '{' */
    curitem = 0;
    while (*atext != '}')
    {
        if (*atext == '\0')
            return false;       /* premature end of string */
        items[curitem] = strings;
        while (*atext != '}' && *atext != ',')
        {
            if (*atext == '\0')
                return false;   /* premature end of string */
            if (*atext != '"')
                *strings++ = *atext++;  /* copy unquoted data */
            else
            {
                /* process quoted substring */
                atext++;
                while (*atext != '"')
                {
                    if (*atext == '\0')
                        return false;   /* premature end of string */
                    if (*atext == '\\')
                    {
                        atext++;
                        if (*atext == '\0')
                            return false;   /* premature end of string */
                    }
                    *strings++ = *atext++;  /* copy quoted data */
                }
                atext++;
            }
        }
        *strings++ = '\0';
        if (*atext == ',')
            atext++;
        curitem++;
    }
    if (atext[1] != '\0')
        return false;           /* bogus syntax (embedded '}') */
    *nitems = curitem;
    return true;
}

bool processSQLNamePattern	(	PGconn *	conn,
		PQExpBuffer	buf,
		const char *	pattern,
		bool	have_where,
		bool	force_escape,
		const char *	schemavar,
		const char *	namevar,
		const char *	altnamevar,
		const char *	visibilityrule
	)

Definition at line 833 of file string_utils.c.

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralConn(), PQExpBufferData::data, encoding, i, initPQExpBuffer(), PQExpBufferData::len, pg_tolower(), PQclientEncoding(), PQmblen(), resetPQExpBuffer(), termPQExpBuffer(), and WHEREAND.

Referenced by describeAccessMethods(), describeAggregates(), describeFunctions(), describeOperators(), describePublications(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), expand_schema_name_patterns(), expand_table_name_patterns(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSConfigsVerbose(), listTSDictionaries(), listTSParsers(), listTSParsersVerbose(), listTSTemplates(), listUserMappings(), objectDescription(), and permissionsList().

{
    PQExpBufferData schemabuf;
    PQExpBufferData namebuf;
    int         encoding = PQclientEncoding(conn);
    bool        inquotes;
    const char *cp;
    int         i;
    bool        added_clause = false;

#define WHEREAND() \
    (appendPQExpBufferStr(buf, have_where ? "  AND " : "WHERE "), \
     have_where = true, added_clause = true)

    if (pattern == NULL)
    {
        /* Default: select all visible objects */
        if (visibilityrule)
        {
            WHEREAND();
            appendPQExpBuffer(buf, "%s\n", visibilityrule);
        }
        return added_clause;
    }

    initPQExpBuffer(&schemabuf);
    initPQExpBuffer(&namebuf);

    /*
     * Parse the pattern, converting quotes and lower-casing unquoted letters.
     * Also, adjust shell-style wildcard characters into regexp notation.
     *
     * We surround the pattern with "^(...)$" to force it to match the whole
     * string, as per SQL practice.  We have to have parens in case the string
     * contains "|", else the "^" and "$" will be bound into the first and
     * last alternatives which is not what we want.
     *
     * Note: the result of this pass is the actual regexp pattern(s) we want
     * to execute.  Quoting/escaping into SQL literal format will be done
     * below using appendStringLiteralConn().
     */
    appendPQExpBufferStr(&namebuf, "^(");

    inquotes = false;
    cp = pattern;

    while (*cp)
    {
        char        ch = *cp;

        if (ch == '"')
        {
            if (inquotes && cp[1] == '"')
            {
                /* emit one quote, stay in inquotes mode */
                appendPQExpBufferChar(&namebuf, '"');
                cp++;
            }
            else
                inquotes = !inquotes;
            cp++;
        }
        else if (!inquotes && isupper((unsigned char) ch))
        {
            appendPQExpBufferChar(&namebuf,
                                  pg_tolower((unsigned char) ch));
            cp++;
        }
        else if (!inquotes && ch == '*')
        {
            appendPQExpBufferStr(&namebuf, ".*");
            cp++;
        }
        else if (!inquotes && ch == '?')
        {
            appendPQExpBufferChar(&namebuf, '.');
            cp++;
        }
        else if (!inquotes && ch == '.')
        {
            /* Found schema/name separator, move current pattern to schema */
            resetPQExpBuffer(&schemabuf);
            appendPQExpBufferStr(&schemabuf, namebuf.data);
            resetPQExpBuffer(&namebuf);
            appendPQExpBufferStr(&namebuf, "^(");
            cp++;
        }
        else if (ch == '$')
        {
            /*
             * Dollar is always quoted, whether inside quotes or not. The
             * reason is that it's allowed in SQL identifiers, so there's a
             * significant use-case for treating it literally, while because
             * we anchor the pattern automatically there is no use-case for
             * having it possess its regexp meaning.
             */
            appendPQExpBufferStr(&namebuf, "\\$");
            cp++;
        }
        else
        {
            /*
             * Ordinary data character, transfer to pattern
             *
             * Inside double quotes, or at all times if force_escape is true,
             * quote regexp special characters with a backslash to avoid
             * regexp errors.  Outside quotes, however, let them pass through
             * as-is; this lets knowledgeable users build regexp expressions
             * that are more powerful than shell-style patterns.
             */
            if ((inquotes || force_escape) &&
                strchr("|*+?()[]{}.^$\\", ch))
                appendPQExpBufferChar(&namebuf, '\\');
            i = PQmblen(cp, encoding);
            while (i-- && *cp)
            {
                appendPQExpBufferChar(&namebuf, *cp);
                cp++;
            }
        }
    }

    /*
     * Now decide what we need to emit.  Note there will be a leading "^(" in
     * the patterns in any case.
     */
    if (namebuf.len > 2)
    {
        /* We have a name pattern, so constrain the namevar(s) */

        appendPQExpBufferStr(&namebuf, ")$");
        /* Optimize away a "*" pattern */
        if (strcmp(namebuf.data, "^(.*)$") != 0)
        {
            WHEREAND();
            if (altnamevar)
            {
                appendPQExpBuffer(buf, "(%s ~ ", namevar);
                appendStringLiteralConn(buf, namebuf.data, conn);
                appendPQExpBuffer(buf, "\n        OR %s ~ ", altnamevar);
                appendStringLiteralConn(buf, namebuf.data, conn);
                appendPQExpBufferStr(buf, ")\n");
            }
            else
            {
                appendPQExpBuffer(buf, "%s ~ ", namevar);
                appendStringLiteralConn(buf, namebuf.data, conn);
                appendPQExpBufferChar(buf, '\n');
            }
        }
    }

    if (schemabuf.len > 2)
    {
        /* We have a schema pattern, so constrain the schemavar */

        appendPQExpBufferStr(&schemabuf, ")$");
        /* Optimize away a "*" pattern */
        if (strcmp(schemabuf.data, "^(.*)$") != 0 && schemavar)
        {
            WHEREAND();
            appendPQExpBuffer(buf, "%s ~ ", schemavar);
            appendStringLiteralConn(buf, schemabuf.data, conn);
            appendPQExpBufferChar(buf, '\n');
        }
    }
    else
    {
        /* No schema pattern given, so select only visible objects */
        if (visibilityrule)
        {
            WHEREAND();
            appendPQExpBuffer(buf, "%s\n", visibilityrule);
        }
    }

    termPQExpBuffer(&schemabuf);
    termPQExpBuffer(&namebuf);

    return added_clause;
#undef WHEREAND
}

Variable Documentation

PQExpBuffer(* getLocalPQExpBuffer)(void)

default

Definition at line 29 of file string_utils.c.

Referenced by fmtId(), fmtQualifiedId(), and ParallelBackupStart().

{
    static PQExpBuffer id_return = NULL;

    if (id_return)              /* first time through? */
    {
        /* same buffer, just wipe contents */
        resetPQExpBuffer(id_return);
    }
    else
    {
        /* new buffer */
        id_return = createPQExpBuffer();
    }

    return id_return;
}

int quote_all_identifiers = 0

Definition at line 28 of file string_utils.c.

Referenced by fmtId().