mirror of https://github.com/postgres/postgres
Per discussion, we want to create a static library and put the stuff into it that until now has been shared across src/bin/ directories by ad-hoc methods like symlinking a source file. This commit creates the library and populates it with a couple of files that contain the widely-useful portions of pg_dump's dumputils.c file. dumputils.c survives, because it has some stuff that didn't seem appropriate for fe_utils, but it's significantly smaller and is no longer referenced from any other directory. Follow-on patches will move more stuff into fe_utils. The Mkvcbuild.pm hacking here is just a best guess; we'll see how the buildfarm likes it.pull/11/head
Tom Lane
10 years ago
parent
a596db332b
commit
588d963b00
@ -0,0 +1,39 @@ |
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
# Makefile
|
||||
# Makefile for src/fe_utils
|
||||
#
|
||||
# This makefile generates a static library, libpgfeutils.a,
|
||||
# for use by client applications
|
||||
#
|
||||
# IDENTIFICATION
|
||||
# src/fe_utils/Makefile
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
subdir = src/fe_utils
|
||||
top_builddir = ../..
|
||||
include $(top_builddir)/src/Makefile.global |
||||
|
||||
override CPPFLAGS := -DFRONTEND -I$(libpq_srcdir) $(CPPFLAGS) |
||||
|
||||
OBJS = simple_list.o string_utils.o
|
||||
|
||||
all: libpgfeutils.a |
||||
|
||||
libpgfeutils.a: $(OBJS) |
||||
rm -f $@
|
||||
$(AR) $(AROPT) $@ $^
|
||||
|
||||
# libpgfeutils could be useful to contrib, so install it
|
||||
install: all installdirs |
||||
$(INSTALL_STLIB) libpgfeutils.a '$(DESTDIR)$(libdir)/libpgfeutils.a'
|
||||
|
||||
installdirs: |
||||
$(MKDIR_P) '$(DESTDIR)$(libdir)'
|
||||
|
||||
uninstall: |
||||
rm -f '$(DESTDIR)$(libdir)/libpgfeutils.a'
|
||||
|
||||
clean distclean maintainer-clean: |
||||
rm -f libpgfeutils.a $(OBJS)
|
||||
@ -0,0 +1,116 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* Simple list facilities for frontend code |
||||
* |
||||
* Data structures for simple lists of OIDs and strings. The support for |
||||
* these is very primitive compared to the backend's List facilities, but |
||||
* it's all we need in, eg, pg_dump. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* src/fe_utils/simple_list.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres_fe.h" |
||||
|
||||
#include "fe_utils/simple_list.h" |
||||
|
||||
|
||||
/*
|
||||
* Append an OID to the list. |
||||
*/ |
||||
void |
||||
simple_oid_list_append(SimpleOidList *list, Oid val) |
||||
{ |
||||
SimpleOidListCell *cell; |
||||
|
||||
cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell)); |
||||
cell->next = NULL; |
||||
cell->val = val; |
||||
|
||||
if (list->tail) |
||||
list->tail->next = cell; |
||||
else |
||||
list->head = cell; |
||||
list->tail = cell; |
||||
} |
||||
|
||||
/*
|
||||
* Is OID present in the list? |
||||
*/ |
||||
bool |
||||
simple_oid_list_member(SimpleOidList *list, Oid val) |
||||
{ |
||||
SimpleOidListCell *cell; |
||||
|
||||
for (cell = list->head; cell; cell = cell->next) |
||||
{ |
||||
if (cell->val == val) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/*
|
||||
* Append a string to the list. |
||||
* |
||||
* The given string is copied, so it need not survive past the call. |
||||
*/ |
||||
void |
||||
simple_string_list_append(SimpleStringList *list, const char *val) |
||||
{ |
||||
SimpleStringListCell *cell; |
||||
|
||||
cell = (SimpleStringListCell *) |
||||
pg_malloc(offsetof(SimpleStringListCell, val) +strlen(val) + 1); |
||||
|
||||
cell->next = NULL; |
||||
cell->touched = false; |
||||
strcpy(cell->val, val); |
||||
|
||||
if (list->tail) |
||||
list->tail->next = cell; |
||||
else |
||||
list->head = cell; |
||||
list->tail = cell; |
||||
} |
||||
|
||||
/*
|
||||
* Is string present in the list? |
||||
* |
||||
* If found, the "touched" field of the first match is set true. |
||||
*/ |
||||
bool |
||||
simple_string_list_member(SimpleStringList *list, const char *val) |
||||
{ |
||||
SimpleStringListCell *cell; |
||||
|
||||
for (cell = list->head; cell; cell = cell->next) |
||||
{ |
||||
if (strcmp(cell->val, val) == 0) |
||||
{ |
||||
cell->touched = true; |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
/*
|
||||
* Find first not-touched list entry, if there is one. |
||||
*/ |
||||
const char * |
||||
simple_string_list_not_touched(SimpleStringList *list) |
||||
{ |
||||
SimpleStringListCell *cell; |
||||
|
||||
for (cell = list->head; cell; cell = cell->next) |
||||
{ |
||||
if (!cell->touched) |
||||
return cell->val; |
||||
} |
||||
return NULL; |
||||
} |
||||
@ -0,0 +1,674 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* String-processing utility routines for frontend code |
||||
* |
||||
* Assorted utility functions that are useful in constructing SQL queries |
||||
* and interpreting backend output. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* src/fe_utils/string_utils.c |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#include "postgres_fe.h" |
||||
|
||||
#include <ctype.h> |
||||
|
||||
#include "fe_utils/string_utils.h" |
||||
|
||||
#include "common/keywords.h" |
||||
|
||||
|
||||
static PQExpBuffer defaultGetLocalPQExpBuffer(void); |
||||
|
||||
/* Globals exported by this file */ |
||||
int quote_all_identifiers = 0; |
||||
PQExpBuffer (*getLocalPQExpBuffer) (void) = defaultGetLocalPQExpBuffer; |
||||
|
||||
|
||||
/*
|
||||
* Returns a temporary PQExpBuffer, valid until the next call to the function. |
||||
* This is used by fmtId and fmtQualifiedId. |
||||
* |
||||
* Non-reentrant and non-thread-safe but reduces memory leakage. You can |
||||
* replace this with a custom version by setting the getLocalPQExpBuffer |
||||
* function pointer. |
||||
*/ |
||||
static PQExpBuffer |
||||
defaultGetLocalPQExpBuffer(void) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
/*
|
||||
* Quotes input string if it's not a legitimate SQL identifier as-is. |
||||
* |
||||
* Note that the returned string must be used before calling fmtId again, |
||||
* since we re-use the same return buffer each time. |
||||
*/ |
||||
const char * |
||||
fmtId(const char *rawid) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
/*
|
||||
* fmtQualifiedId - convert a qualified name to the proper format for |
||||
* the source database. |
||||
* |
||||
* Like fmtId, use the result before calling again. |
||||
* |
||||
* Since we call fmtId and it also uses getThreadLocalPQExpBuffer() we cannot |
||||
* use it until we're finished with calling fmtId(). |
||||
*/ |
||||
const char * |
||||
fmtQualifiedId(int remoteVersion, const char *schema, const char *id) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Convert a string value to an SQL string literal and append it to |
||||
* the given buffer. We assume the specified client_encoding and |
||||
* standard_conforming_strings settings. |
||||
* |
||||
* This is essentially equivalent to libpq's PQescapeStringInternal, |
||||
* except for the output buffer structure. We need it in situations |
||||
* where we do not have a PGconn available. Where we do, |
||||
* appendStringLiteralConn is a better choice. |
||||
*/ |
||||
void |
||||
appendStringLiteral(PQExpBuffer buf, const char *str, |
||||
int encoding, bool std_strings) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Convert a string value to an SQL string literal and append it to |
||||
* the given buffer. Encoding and string syntax rules are as indicated |
||||
* by current settings of the PGconn. |
||||
*/ |
||||
void |
||||
appendStringLiteralConn(PQExpBuffer buf, const char *str, PGconn *conn) |
||||
{ |
||||
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, '\''); |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Convert a string value to a dollar quoted literal and append it to |
||||
* the given buffer. If the dqprefix parameter is not NULL then the |
||||
* dollar quote delimiter will begin with that (after the opening $). |
||||
* |
||||
* No escaping is done at all on str, in compliance with the rules |
||||
* for parsing dollar quoted strings. Also, we need not worry about |
||||
* encoding issues. |
||||
*/ |
||||
void |
||||
appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix) |
||||
{ |
||||
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); |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Convert a bytea value (presented as raw bytes) to an SQL string literal |
||||
* and append it to the given buffer. We assume the specified |
||||
* standard_conforming_strings setting. |
||||
* |
||||
* This is needed in situations where we do not have a PGconn available. |
||||
* Where we do, PQescapeByteaConn is a better choice. |
||||
*/ |
||||
void |
||||
appendByteaLiteral(PQExpBuffer buf, const unsigned char *str, size_t length, |
||||
bool std_strings) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* Deconstruct the text representation of a 1-dimensional Postgres array |
||||
* into individual items. |
||||
* |
||||
* On success, returns true and sets *itemarray and *nitems to describe |
||||
* an array of individual strings. On parse failure, returns false; |
||||
* *itemarray may exist or be NULL. |
||||
* |
||||
* NOTE: free'ing itemarray is sufficient to deallocate the working storage. |
||||
*/ |
||||
bool |
||||
parsePGArray(const char *atext, char ***itemarray, int *nitems) |
||||
{ |
||||
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; |
||||
} |
||||
|
||||
|
||||
/*
|
||||
* processSQLNamePattern |
||||
* |
||||
* Scan a wildcard-pattern string and generate appropriate WHERE clauses |
||||
* to limit the set of objects returned. The WHERE clauses are appended |
||||
* to the already-partially-constructed query in buf. Returns whether |
||||
* any clause was added. |
||||
* |
||||
* conn: connection query will be sent to (consulted for escaping rules). |
||||
* buf: output parameter. |
||||
* pattern: user-specified pattern option, or NULL if none ("*" is implied). |
||||
* have_where: true if caller already emitted "WHERE" (clauses will be ANDed |
||||
* onto the existing WHERE clause). |
||||
* force_escape: always quote regexp special characters, even outside |
||||
* double quotes (else they are quoted only between double quotes). |
||||
* schemavar: name of query variable to match against a schema-name pattern. |
||||
* Can be NULL if no schema. |
||||
* namevar: name of query variable to match against an object-name pattern. |
||||
* altnamevar: NULL, or name of an alternative variable to match against name. |
||||
* visibilityrule: clause to use if we want to restrict to visible objects |
||||
* (for example, "pg_catalog.pg_table_is_visible(p.oid)"). Can be NULL. |
||||
* |
||||
* Formatting note: the text already present in buf should end with a newline. |
||||
* The appended text, if any, will end with one too. |
||||
*/ |
||||
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) |
||||
{ |
||||
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 |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* Simple list facilities for frontend code |
||||
* |
||||
* Data structures for simple lists of OIDs and strings. The support for |
||||
* these is very primitive compared to the backend's List facilities, but |
||||
* it's all we need in, eg, pg_dump. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* src/include/fe_utils/simple_list.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef SIMPLE_LIST_H |
||||
#define SIMPLE_LIST_H |
||||
|
||||
typedef struct SimpleOidListCell |
||||
{ |
||||
struct SimpleOidListCell *next; |
||||
Oid val; |
||||
} SimpleOidListCell; |
||||
|
||||
typedef struct SimpleOidList |
||||
{ |
||||
SimpleOidListCell *head; |
||||
SimpleOidListCell *tail; |
||||
} SimpleOidList; |
||||
|
||||
typedef struct SimpleStringListCell |
||||
{ |
||||
struct SimpleStringListCell *next; |
||||
bool touched; /* true, when this string was searched and
|
||||
* touched */ |
||||
char val[FLEXIBLE_ARRAY_MEMBER]; /* null-terminated string here */ |
||||
} SimpleStringListCell; |
||||
|
||||
typedef struct SimpleStringList |
||||
{ |
||||
SimpleStringListCell *head; |
||||
SimpleStringListCell *tail; |
||||
} SimpleStringList; |
||||
|
||||
|
||||
extern void simple_oid_list_append(SimpleOidList *list, Oid val); |
||||
extern bool simple_oid_list_member(SimpleOidList *list, Oid val); |
||||
|
||||
extern void simple_string_list_append(SimpleStringList *list, const char *val); |
||||
extern bool simple_string_list_member(SimpleStringList *list, const char *val); |
||||
|
||||
extern const char *simple_string_list_not_touched(SimpleStringList *list); |
||||
|
||||
#endif /* SIMPLE_LIST_H */ |
||||
@ -0,0 +1,51 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* String-processing utility routines for frontend code |
||||
* |
||||
* Assorted utility functions that are useful in constructing SQL queries |
||||
* and interpreting backend output. |
||||
* |
||||
* |
||||
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* src/include/fe_utils/string_utils.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef STRING_UTILS_H |
||||
#define STRING_UTILS_H |
||||
|
||||
#include "libpq-fe.h" |
||||
#include "pqexpbuffer.h" |
||||
|
||||
#define atooid(x) ((Oid) strtoul((x), NULL, 10)) |
||||
|
||||
/* Global variables controlling behavior of fmtId() and fmtQualifiedId() */ |
||||
extern int quote_all_identifiers; |
||||
extern PQExpBuffer (*getLocalPQExpBuffer) (void); |
||||
|
||||
/* Functions */ |
||||
extern const char *fmtId(const char *identifier); |
||||
extern const char *fmtQualifiedId(int remoteVersion, |
||||
const char *schema, const char *id); |
||||
|
||||
extern void appendStringLiteral(PQExpBuffer buf, const char *str, |
||||
int encoding, bool std_strings); |
||||
extern void appendStringLiteralConn(PQExpBuffer buf, const char *str, |
||||
PGconn *conn); |
||||
extern void appendStringLiteralDQ(PQExpBuffer buf, const char *str, |
||||
const char *dqprefix); |
||||
extern void appendByteaLiteral(PQExpBuffer buf, |
||||
const unsigned char *str, size_t length, |
||||
bool std_strings); |
||||
|
||||
extern bool parsePGArray(const char *atext, char ***itemarray, int *nitems); |
||||
|
||||
extern 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); |
||||
|
||||
#endif /* STRING_UTILS_H */ |
||||
Loading…
Reference in new issue