PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
string_utils.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * String-processing utility routines for frontend code
4  *
5  * Assorted utility functions that are useful in constructing SQL queries
6  * and interpreting backend output.
7  *
8  *
9  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
10  * Portions Copyright (c) 1994, Regents of the University of California
11  *
12  * src/fe_utils/string_utils.c
13  *
14  *-------------------------------------------------------------------------
15  */
16 #include "postgres_fe.h"
17 
18 #include <ctype.h>
19 
20 #include "fe_utils/string_utils.h"
21 
22 #include "common/keywords.h"
23 
24 
26 
27 /* Globals exported by this file */
30 
31 
32 /*
33  * Returns a temporary PQExpBuffer, valid until the next call to the function.
34  * This is used by fmtId and fmtQualifiedId.
35  *
36  * Non-reentrant and non-thread-safe but reduces memory leakage. You can
37  * replace this with a custom version by setting the getLocalPQExpBuffer
38  * function pointer.
39  */
40 static PQExpBuffer
42 {
43  static PQExpBuffer id_return = NULL;
44 
45  if (id_return) /* first time through? */
46  {
47  /* same buffer, just wipe contents */
48  resetPQExpBuffer(id_return);
49  }
50  else
51  {
52  /* new buffer */
53  id_return = createPQExpBuffer();
54  }
55 
56  return id_return;
57 }
58 
59 /*
60  * Quotes input string if it's not a legitimate SQL identifier as-is.
61  *
62  * Note that the returned string must be used before calling fmtId again,
63  * since we re-use the same return buffer each time.
64  */
65 const char *
66 fmtId(const char *rawid)
67 {
68  PQExpBuffer id_return = getLocalPQExpBuffer();
69 
70  const char *cp;
71  bool need_quotes = false;
72 
73  /*
74  * These checks need to match the identifier production in scan.l. Don't
75  * use islower() etc.
76  */
78  need_quotes = true;
79  /* slightly different rules for first character */
80  else if (!((rawid[0] >= 'a' && rawid[0] <= 'z') || rawid[0] == '_'))
81  need_quotes = true;
82  else
83  {
84  /* otherwise check the entire string */
85  for (cp = rawid; *cp; cp++)
86  {
87  if (!((*cp >= 'a' && *cp <= 'z')
88  || (*cp >= '0' && *cp <= '9')
89  || (*cp == '_')))
90  {
91  need_quotes = true;
92  break;
93  }
94  }
95  }
96 
97  if (!need_quotes)
98  {
99  /*
100  * Check for keyword. We quote keywords except for unreserved ones.
101  * (In some cases we could avoid quoting a col_name or type_func_name
102  * keyword, but it seems much harder than it's worth to tell that.)
103  *
104  * Note: ScanKeywordLookup() does case-insensitive comparison, but
105  * that's fine, since we already know we have all-lower-case.
106  */
107  const ScanKeyword *keyword = ScanKeywordLookup(rawid,
108  ScanKeywords,
110 
111  if (keyword != NULL && keyword->category != UNRESERVED_KEYWORD)
112  need_quotes = true;
113  }
114 
115  if (!need_quotes)
116  {
117  /* no quoting needed */
118  appendPQExpBufferStr(id_return, rawid);
119  }
120  else
121  {
122  appendPQExpBufferChar(id_return, '"');
123  for (cp = rawid; *cp; cp++)
124  {
125  /*
126  * Did we find a double-quote in the string? Then make this a
127  * double double-quote per SQL99. Before, we put in a
128  * backslash/double-quote pair. - thomas 2000-08-05
129  */
130  if (*cp == '"')
131  appendPQExpBufferChar(id_return, '"');
132  appendPQExpBufferChar(id_return, *cp);
133  }
134  appendPQExpBufferChar(id_return, '"');
135  }
136 
137  return id_return->data;
138 }
139 
140 /*
141  * fmtQualifiedId - convert a qualified name to the proper format for
142  * the source database.
143  *
144  * Like fmtId, use the result before calling again.
145  *
146  * Since we call fmtId and it also uses getLocalPQExpBuffer() we cannot
147  * use that buffer until we're finished with calling fmtId().
148  */
149 const char *
150 fmtQualifiedId(int remoteVersion, const char *schema, const char *id)
151 {
152  PQExpBuffer id_return;
153  PQExpBuffer lcl_pqexp = createPQExpBuffer();
154 
155  /* Suppress schema name if fetching from pre-7.3 DB */
156  if (remoteVersion >= 70300 && schema && *schema)
157  {
158  appendPQExpBuffer(lcl_pqexp, "%s.", fmtId(schema));
159  }
160  appendPQExpBufferStr(lcl_pqexp, fmtId(id));
161 
162  id_return = getLocalPQExpBuffer();
163 
164  appendPQExpBufferStr(id_return, lcl_pqexp->data);
165  destroyPQExpBuffer(lcl_pqexp);
166 
167  return id_return->data;
168 }
169 
170 
171 /*
172  * Format a Postgres version number (in the PG_VERSION_NUM integer format
173  * returned by PQserverVersion()) as a string. This exists mainly to
174  * encapsulate knowledge about two-part vs. three-part version numbers.
175  *
176  * For reentrancy, caller must supply the buffer the string is put in.
177  * Recommended size of the buffer is 32 bytes.
178  *
179  * Returns address of 'buf', as a notational convenience.
180  */
181 char *
182 formatPGVersionNumber(int version_number, bool include_minor,
183  char *buf, size_t buflen)
184 {
185  if (version_number >= 100000)
186  {
187  /* New two-part style */
188  if (include_minor)
189  snprintf(buf, buflen, "%d.%d", version_number / 10000,
190  version_number % 10000);
191  else
192  snprintf(buf, buflen, "%d", version_number / 10000);
193  }
194  else
195  {
196  /* Old three-part style */
197  if (include_minor)
198  snprintf(buf, buflen, "%d.%d.%d", version_number / 10000,
199  (version_number / 100) % 100,
200  version_number % 100);
201  else
202  snprintf(buf, buflen, "%d.%d", version_number / 10000,
203  (version_number / 100) % 100);
204  }
205  return buf;
206 }
207 
208 
209 /*
210  * Convert a string value to an SQL string literal and append it to
211  * the given buffer. We assume the specified client_encoding and
212  * standard_conforming_strings settings.
213  *
214  * This is essentially equivalent to libpq's PQescapeStringInternal,
215  * except for the output buffer structure. We need it in situations
216  * where we do not have a PGconn available. Where we do,
217  * appendStringLiteralConn is a better choice.
218  */
219 void
221  int encoding, bool std_strings)
222 {
223  size_t length = strlen(str);
224  const char *source = str;
225  char *target;
226 
227  if (!enlargePQExpBuffer(buf, 2 * length + 2))
228  return;
229 
230  target = buf->data + buf->len;
231  *target++ = '\'';
232 
233  while (*source != '\0')
234  {
235  char c = *source;
236  int len;
237  int i;
238 
239  /* Fast path for plain ASCII */
240  if (!IS_HIGHBIT_SET(c))
241  {
242  /* Apply quoting if needed */
243  if (SQL_STR_DOUBLE(c, !std_strings))
244  *target++ = c;
245  /* Copy the character */
246  *target++ = c;
247  source++;
248  continue;
249  }
250 
251  /* Slow path for possible multibyte characters */
252  len = PQmblen(source, encoding);
253 
254  /* Copy the character */
255  for (i = 0; i < len; i++)
256  {
257  if (*source == '\0')
258  break;
259  *target++ = *source++;
260  }
261 
262  /*
263  * If we hit premature end of string (ie, incomplete multibyte
264  * character), try to pad out to the correct length with spaces. We
265  * may not be able to pad completely, but we will always be able to
266  * insert at least one pad space (since we'd not have quoted a
267  * multibyte character). This should be enough to make a string that
268  * the server will error out on.
269  */
270  if (i < len)
271  {
272  char *stop = buf->data + buf->maxlen - 2;
273 
274  for (; i < len; i++)
275  {
276  if (target >= stop)
277  break;
278  *target++ = ' ';
279  }
280  break;
281  }
282  }
283 
284  /* Write the terminating quote and NUL character. */
285  *target++ = '\'';
286  *target = '\0';
287 
288  buf->len = target - buf->data;
289 }
290 
291 
292 /*
293  * Convert a string value to an SQL string literal and append it to
294  * the given buffer. Encoding and string syntax rules are as indicated
295  * by current settings of the PGconn.
296  */
297 void
299 {
300  size_t length = strlen(str);
301 
302  /*
303  * XXX This is a kluge to silence escape_string_warning in our utility
304  * programs. It should go away someday.
305  */
306  if (strchr(str, '\\') != NULL && PQserverVersion(conn) >= 80100)
307  {
308  /* ensure we are not adjacent to an identifier */
309  if (buf->len > 0 && buf->data[buf->len - 1] != ' ')
310  appendPQExpBufferChar(buf, ' ');
312  appendStringLiteral(buf, str, PQclientEncoding(conn), false);
313  return;
314  }
315  /* XXX end kluge */
316 
317  if (!enlargePQExpBuffer(buf, 2 * length + 2))
318  return;
319  appendPQExpBufferChar(buf, '\'');
320  buf->len += PQescapeStringConn(conn, buf->data + buf->len,
321  str, length, NULL);
322  appendPQExpBufferChar(buf, '\'');
323 }
324 
325 
326 /*
327  * Convert a string value to a dollar quoted literal and append it to
328  * the given buffer. If the dqprefix parameter is not NULL then the
329  * dollar quote delimiter will begin with that (after the opening $).
330  *
331  * No escaping is done at all on str, in compliance with the rules
332  * for parsing dollar quoted strings. Also, we need not worry about
333  * encoding issues.
334  */
335 void
336 appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
337 {
338  static const char suffixes[] = "_XXXXXXX";
339  int nextchar = 0;
340  PQExpBuffer delimBuf = createPQExpBuffer();
341 
342  /* start with $ + dqprefix if not NULL */
343  appendPQExpBufferChar(delimBuf, '$');
344  if (dqprefix)
345  appendPQExpBufferStr(delimBuf, dqprefix);
346 
347  /*
348  * Make sure we choose a delimiter which (without the trailing $) is not
349  * present in the string being quoted. We don't check with the trailing $
350  * because a string ending in $foo must not be quoted with $foo$.
351  */
352  while (strstr(str, delimBuf->data) != NULL)
353  {
354  appendPQExpBufferChar(delimBuf, suffixes[nextchar++]);
355  nextchar %= sizeof(suffixes) - 1;
356  }
357 
358  /* add trailing $ */
359  appendPQExpBufferChar(delimBuf, '$');
360 
361  /* quote it and we are all done */
362  appendPQExpBufferStr(buf, delimBuf->data);
363  appendPQExpBufferStr(buf, str);
364  appendPQExpBufferStr(buf, delimBuf->data);
365 
366  destroyPQExpBuffer(delimBuf);
367 }
368 
369 
370 /*
371  * Convert a bytea value (presented as raw bytes) to an SQL string literal
372  * and append it to the given buffer. We assume the specified
373  * standard_conforming_strings setting.
374  *
375  * This is needed in situations where we do not have a PGconn available.
376  * Where we do, PQescapeByteaConn is a better choice.
377  */
378 void
379 appendByteaLiteral(PQExpBuffer buf, const unsigned char *str, size_t length,
380  bool std_strings)
381 {
382  const unsigned char *source = str;
383  char *target;
384 
385  static const char hextbl[] = "0123456789abcdef";
386 
387  /*
388  * This implementation is hard-wired to produce hex-format output. We do
389  * not know the server version the output will be loaded into, so making
390  * an intelligent format choice is impossible. It might be better to
391  * always use the old escaped format.
392  */
393  if (!enlargePQExpBuffer(buf, 2 * length + 5))
394  return;
395 
396  target = buf->data + buf->len;
397  *target++ = '\'';
398  if (!std_strings)
399  *target++ = '\\';
400  *target++ = '\\';
401  *target++ = 'x';
402 
403  while (length-- > 0)
404  {
405  unsigned char c = *source++;
406 
407  *target++ = hextbl[(c >> 4) & 0xF];
408  *target++ = hextbl[c & 0xF];
409  }
410 
411  /* Write the terminating quote and NUL character. */
412  *target++ = '\'';
413  *target = '\0';
414 
415  buf->len = target - buf->data;
416 }
417 
418 
419 /*
420  * Append the given string to the shell command being built in the buffer,
421  * with shell-style quoting as needed to create exactly one argument.
422  *
423  * Forbid LF or CR characters, which have scant practical use beyond designing
424  * security breaches. The Windows command shell is unusable as a conduit for
425  * arguments containing LF or CR characters. A future major release should
426  * reject those characters in CREATE ROLE and CREATE DATABASE, because use
427  * there eventually leads to errors here.
428  *
429  * appendShellString() simply prints an error and dies if LF or CR appears.
430  * appendShellStringNoError() omits those characters from the result, and
431  * returns false if there were any.
432  */
433 void
435 {
436  if (!appendShellStringNoError(buf, str))
437  {
438  fprintf(stderr,
439  _("shell command argument contains a newline or carriage return: \"%s\"\n"),
440  str);
441  exit(EXIT_FAILURE);
442  }
443 }
444 
445 bool
447 {
448 #ifdef WIN32
449  int backslash_run_length = 0;
450 #endif
451  bool ok = true;
452  const char *p;
453 
454  /*
455  * Don't bother with adding quotes if the string is nonempty and clearly
456  * contains only safe characters.
457  */
458  if (*str != '\0' &&
459  strspn(str, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_./:") == strlen(str))
460  {
461  appendPQExpBufferStr(buf, str);
462  return ok;
463  }
464 
465 #ifndef WIN32
466  appendPQExpBufferChar(buf, '\'');
467  for (p = str; *p; p++)
468  {
469  if (*p == '\n' || *p == '\r')
470  {
471  ok = false;
472  continue;
473  }
474 
475  if (*p == '\'')
476  appendPQExpBufferStr(buf, "'\"'\"'");
477  else
478  appendPQExpBufferChar(buf, *p);
479  }
480  appendPQExpBufferChar(buf, '\'');
481 #else /* WIN32 */
482 
483  /*
484  * A Windows system() argument experiences two layers of interpretation.
485  * First, cmd.exe interprets the string. Its behavior is undocumented,
486  * but a caret escapes any byte except LF or CR that would otherwise have
487  * special meaning. Handling of a caret before LF or CR differs between
488  * "cmd.exe /c" and other modes, and it is unusable here.
489  *
490  * Second, the new process parses its command line to construct argv (see
491  * https://msdn.microsoft.com/en-us/library/17w5ykft.aspx). This treats
492  * backslash-double quote sequences specially.
493  */
494  appendPQExpBufferStr(buf, "^\"");
495  for (p = str; *p; p++)
496  {
497  if (*p == '\n' || *p == '\r')
498  {
499  ok = false;
500  continue;
501  }
502 
503  /* Change N backslashes before a double quote to 2N+1 backslashes. */
504  if (*p == '"')
505  {
506  while (backslash_run_length)
507  {
508  appendPQExpBufferStr(buf, "^\\");
509  backslash_run_length--;
510  }
511  appendPQExpBufferStr(buf, "^\\");
512  }
513  else if (*p == '\\')
514  backslash_run_length++;
515  else
516  backslash_run_length = 0;
517 
518  /*
519  * Decline to caret-escape the most mundane characters, to ease
520  * debugging and lest we approach the command length limit.
521  */
522  if (!((*p >= 'a' && *p <= 'z') ||
523  (*p >= 'A' && *p <= 'Z') ||
524  (*p >= '0' && *p <= '9')))
525  appendPQExpBufferChar(buf, '^');
526  appendPQExpBufferChar(buf, *p);
527  }
528 
529  /*
530  * Change N backslashes at end of argument to 2N backslashes, because they
531  * precede the double quote that terminates the argument.
532  */
533  while (backslash_run_length)
534  {
535  appendPQExpBufferStr(buf, "^\\");
536  backslash_run_length--;
537  }
538  appendPQExpBufferStr(buf, "^\"");
539 #endif /* WIN32 */
540 
541  return ok;
542 }
543 
544 
545 /*
546  * Append the given string to the buffer, with suitable quoting for passing
547  * the string as a value, in a keyword/pair value in a libpq connection
548  * string
549  */
550 void
552 {
553  const char *s;
554  bool needquotes;
555 
556  /*
557  * If the string is one or more plain ASCII characters, no need to quote
558  * it. This is quite conservative, but better safe than sorry.
559  */
560  needquotes = true;
561  for (s = str; *s; s++)
562  {
563  if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
564  (*s >= '0' && *s <= '9') || *s == '_' || *s == '.'))
565  {
566  needquotes = true;
567  break;
568  }
569  needquotes = false;
570  }
571 
572  if (needquotes)
573  {
574  appendPQExpBufferChar(buf, '\'');
575  while (*str)
576  {
577  /* ' and \ must be escaped by to \' and \\ */
578  if (*str == '\'' || *str == '\\')
579  appendPQExpBufferChar(buf, '\\');
580 
581  appendPQExpBufferChar(buf, *str);
582  str++;
583  }
584  appendPQExpBufferChar(buf, '\'');
585  }
586  else
587  appendPQExpBufferStr(buf, str);
588 }
589 
590 
591 /*
592  * Append a psql meta-command that connects to the given database with the
593  * then-current connection's user, host and port.
594  */
595 void
597 {
598  const char *s;
599  bool complex;
600 
601  /*
602  * If the name is plain ASCII characters, emit a trivial "\connect "foo"".
603  * For other names, even many not technically requiring it, skip to the
604  * general case. No database has a zero-length name.
605  */
606  complex = false;
607  for (s = dbname; *s; s++)
608  {
609  if (*s == '\n' || *s == '\r')
610  {
611  fprintf(stderr,
612  _("database name contains a newline or carriage return: \"%s\"\n"),
613  dbname);
614  exit(EXIT_FAILURE);
615  }
616 
617  if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
618  (*s >= '0' && *s <= '9') || *s == '_' || *s == '.'))
619  {
620  complex = true;
621  }
622  }
623 
624  appendPQExpBufferStr(buf, "\\connect ");
625  if (complex)
626  {
628 
629  initPQExpBuffer(&connstr);
630  appendPQExpBuffer(&connstr, "dbname=");
631  appendConnStrVal(&connstr, dbname);
632 
633  appendPQExpBuffer(buf, "-reuse-previous=on ");
634 
635  /*
636  * As long as the name does not contain a newline, SQL identifier
637  * quoting satisfies the psql meta-command parser. Prefer not to
638  * involve psql-interpreted single quotes, which behaved differently
639  * before PostgreSQL 9.2.
640  */
641  appendPQExpBufferStr(buf, fmtId(connstr.data));
642 
643  termPQExpBuffer(&connstr);
644  }
645  else
646  appendPQExpBufferStr(buf, fmtId(dbname));
647  appendPQExpBufferChar(buf, '\n');
648 }
649 
650 
651 /*
652  * Deconstruct the text representation of a 1-dimensional Postgres array
653  * into individual items.
654  *
655  * On success, returns true and sets *itemarray and *nitems to describe
656  * an array of individual strings. On parse failure, returns false;
657  * *itemarray may exist or be NULL.
658  *
659  * NOTE: free'ing itemarray is sufficient to deallocate the working storage.
660  */
661 bool
662 parsePGArray(const char *atext, char ***itemarray, int *nitems)
663 {
664  int inputlen;
665  char **items;
666  char *strings;
667  int curitem;
668 
669  /*
670  * We expect input in the form of "{item,item,item}" where any item is
671  * either raw data, or surrounded by double quotes (in which case embedded
672  * characters including backslashes and quotes are backslashed).
673  *
674  * We build the result as an array of pointers followed by the actual
675  * string data, all in one malloc block for convenience of deallocation.
676  * The worst-case storage need is not more than one pointer and one
677  * character for each input character (consider "{,,,,,,,,,,}").
678  */
679  *itemarray = NULL;
680  *nitems = 0;
681  inputlen = strlen(atext);
682  if (inputlen < 2 || atext[0] != '{' || atext[inputlen - 1] != '}')
683  return false; /* bad input */
684  items = (char **) malloc(inputlen * (sizeof(char *) + sizeof(char)));
685  if (items == NULL)
686  return false; /* out of memory */
687  *itemarray = items;
688  strings = (char *) (items + inputlen);
689 
690  atext++; /* advance over initial '{' */
691  curitem = 0;
692  while (*atext != '}')
693  {
694  if (*atext == '\0')
695  return false; /* premature end of string */
696  items[curitem] = strings;
697  while (*atext != '}' && *atext != ',')
698  {
699  if (*atext == '\0')
700  return false; /* premature end of string */
701  if (*atext != '"')
702  *strings++ = *atext++; /* copy unquoted data */
703  else
704  {
705  /* process quoted substring */
706  atext++;
707  while (*atext != '"')
708  {
709  if (*atext == '\0')
710  return false; /* premature end of string */
711  if (*atext == '\\')
712  {
713  atext++;
714  if (*atext == '\0')
715  return false; /* premature end of string */
716  }
717  *strings++ = *atext++; /* copy quoted data */
718  }
719  atext++;
720  }
721  }
722  *strings++ = '\0';
723  if (*atext == ',')
724  atext++;
725  curitem++;
726  }
727  if (atext[1] != '\0')
728  return false; /* bogus syntax (embedded '}') */
729  *nitems = curitem;
730  return true;
731 }
732 
733 
734 /*
735  * Format a reloptions array and append it to the given buffer.
736  *
737  * "prefix" is prepended to the option names; typically it's "" or "toast.".
738  *
739  * Returns false if the reloptions array could not be parsed (in which case
740  * nothing will have been appended to the buffer), or true on success.
741  *
742  * Note: this logic should generally match the backend's flatten_reloptions()
743  * (in adt/ruleutils.c).
744  */
745 bool
746 appendReloptionsArray(PQExpBuffer buffer, const char *reloptions,
747  const char *prefix, int encoding, bool std_strings)
748 {
749  char **options;
750  int noptions;
751  int i;
752 
753  if (!parsePGArray(reloptions, &options, &noptions))
754  {
755  if (options)
756  free(options);
757  return false;
758  }
759 
760  for (i = 0; i < noptions; i++)
761  {
762  char *option = options[i];
763  char *name;
764  char *separator;
765  char *value;
766 
767  /*
768  * Each array element should have the form name=value. If the "=" is
769  * missing for some reason, treat it like an empty value.
770  */
771  name = option;
772  separator = strchr(option, '=');
773  if (separator)
774  {
775  *separator = '\0';
776  value = separator + 1;
777  }
778  else
779  value = "";
780 
781  if (i > 0)
782  appendPQExpBufferStr(buffer, ", ");
783  appendPQExpBuffer(buffer, "%s%s=", prefix, fmtId(name));
784 
785  /*
786  * In general we need to quote the value; but to avoid unnecessary
787  * clutter, do not quote if it is an identifier that would not need
788  * quoting. (We could also allow numbers, but that is a bit trickier
789  * than it looks --- for example, are leading zeroes significant? We
790  * don't want to assume very much here about what custom reloptions
791  * might mean.)
792  */
793  if (strcmp(fmtId(value), value) == 0)
794  appendPQExpBufferStr(buffer, value);
795  else
796  appendStringLiteral(buffer, value, encoding, std_strings);
797  }
798 
799  if (options)
800  free(options);
801 
802  return true;
803 }
804 
805 
806 /*
807  * processSQLNamePattern
808  *
809  * Scan a wildcard-pattern string and generate appropriate WHERE clauses
810  * to limit the set of objects returned. The WHERE clauses are appended
811  * to the already-partially-constructed query in buf. Returns whether
812  * any clause was added.
813  *
814  * conn: connection query will be sent to (consulted for escaping rules).
815  * buf: output parameter.
816  * pattern: user-specified pattern option, or NULL if none ("*" is implied).
817  * have_where: true if caller already emitted "WHERE" (clauses will be ANDed
818  * onto the existing WHERE clause).
819  * force_escape: always quote regexp special characters, even outside
820  * double quotes (else they are quoted only between double quotes).
821  * schemavar: name of query variable to match against a schema-name pattern.
822  * Can be NULL if no schema.
823  * namevar: name of query variable to match against an object-name pattern.
824  * altnamevar: NULL, or name of an alternative variable to match against name.
825  * visibilityrule: clause to use if we want to restrict to visible objects
826  * (for example, "pg_catalog.pg_table_is_visible(p.oid)"). Can be NULL.
827  *
828  * Formatting note: the text already present in buf should end with a newline.
829  * The appended text, if any, will end with one too.
830  */
831 bool
833  bool have_where, bool force_escape,
834  const char *schemavar, const char *namevar,
835  const char *altnamevar, const char *visibilityrule)
836 {
837  PQExpBufferData schemabuf;
838  PQExpBufferData namebuf;
839  int encoding = PQclientEncoding(conn);
840  bool inquotes;
841  const char *cp;
842  int i;
843  bool added_clause = false;
844 
845 #define WHEREAND() \
846  (appendPQExpBufferStr(buf, have_where ? " AND " : "WHERE "), \
847  have_where = true, added_clause = true)
848 
849  if (pattern == NULL)
850  {
851  /* Default: select all visible objects */
852  if (visibilityrule)
853  {
854  WHEREAND();
855  appendPQExpBuffer(buf, "%s\n", visibilityrule);
856  }
857  return added_clause;
858  }
859 
860  initPQExpBuffer(&schemabuf);
861  initPQExpBuffer(&namebuf);
862 
863  /*
864  * Parse the pattern, converting quotes and lower-casing unquoted letters.
865  * Also, adjust shell-style wildcard characters into regexp notation.
866  *
867  * We surround the pattern with "^(...)$" to force it to match the whole
868  * string, as per SQL practice. We have to have parens in case the string
869  * contains "|", else the "^" and "$" will be bound into the first and
870  * last alternatives which is not what we want.
871  *
872  * Note: the result of this pass is the actual regexp pattern(s) we want
873  * to execute. Quoting/escaping into SQL literal format will be done
874  * below using appendStringLiteralConn().
875  */
876  appendPQExpBufferStr(&namebuf, "^(");
877 
878  inquotes = false;
879  cp = pattern;
880 
881  while (*cp)
882  {
883  char ch = *cp;
884 
885  if (ch == '"')
886  {
887  if (inquotes && cp[1] == '"')
888  {
889  /* emit one quote, stay in inquotes mode */
890  appendPQExpBufferChar(&namebuf, '"');
891  cp++;
892  }
893  else
894  inquotes = !inquotes;
895  cp++;
896  }
897  else if (!inquotes && isupper((unsigned char) ch))
898  {
899  appendPQExpBufferChar(&namebuf,
900  pg_tolower((unsigned char) ch));
901  cp++;
902  }
903  else if (!inquotes && ch == '*')
904  {
905  appendPQExpBufferStr(&namebuf, ".*");
906  cp++;
907  }
908  else if (!inquotes && ch == '?')
909  {
910  appendPQExpBufferChar(&namebuf, '.');
911  cp++;
912  }
913  else if (!inquotes && ch == '.')
914  {
915  /* Found schema/name separator, move current pattern to schema */
916  resetPQExpBuffer(&schemabuf);
917  appendPQExpBufferStr(&schemabuf, namebuf.data);
918  resetPQExpBuffer(&namebuf);
919  appendPQExpBufferStr(&namebuf, "^(");
920  cp++;
921  }
922  else if (ch == '$')
923  {
924  /*
925  * Dollar is always quoted, whether inside quotes or not. The
926  * reason is that it's allowed in SQL identifiers, so there's a
927  * significant use-case for treating it literally, while because
928  * we anchor the pattern automatically there is no use-case for
929  * having it possess its regexp meaning.
930  */
931  appendPQExpBufferStr(&namebuf, "\\$");
932  cp++;
933  }
934  else
935  {
936  /*
937  * Ordinary data character, transfer to pattern
938  *
939  * Inside double quotes, or at all times if force_escape is true,
940  * quote regexp special characters with a backslash to avoid
941  * regexp errors. Outside quotes, however, let them pass through
942  * as-is; this lets knowledgeable users build regexp expressions
943  * that are more powerful than shell-style patterns.
944  */
945  if ((inquotes || force_escape) &&
946  strchr("|*+?()[]{}.^$\\", ch))
947  appendPQExpBufferChar(&namebuf, '\\');
948  i = PQmblen(cp, encoding);
949  while (i-- && *cp)
950  {
951  appendPQExpBufferChar(&namebuf, *cp);
952  cp++;
953  }
954  }
955  }
956 
957  /*
958  * Now decide what we need to emit. Note there will be a leading "^(" in
959  * the patterns in any case.
960  */
961  if (namebuf.len > 2)
962  {
963  /* We have a name pattern, so constrain the namevar(s) */
964 
965  appendPQExpBufferStr(&namebuf, ")$");
966  /* Optimize away a "*" pattern */
967  if (strcmp(namebuf.data, "^(.*)$") != 0)
968  {
969  WHEREAND();
970  if (altnamevar)
971  {
972  appendPQExpBuffer(buf, "(%s ~ ", namevar);
973  appendStringLiteralConn(buf, namebuf.data, conn);
974  appendPQExpBuffer(buf, "\n OR %s ~ ", altnamevar);
975  appendStringLiteralConn(buf, namebuf.data, conn);
976  appendPQExpBufferStr(buf, ")\n");
977  }
978  else
979  {
980  appendPQExpBuffer(buf, "%s ~ ", namevar);
981  appendStringLiteralConn(buf, namebuf.data, conn);
982  appendPQExpBufferChar(buf, '\n');
983  }
984  }
985  }
986 
987  if (schemabuf.len > 2)
988  {
989  /* We have a schema pattern, so constrain the schemavar */
990 
991  appendPQExpBufferStr(&schemabuf, ")$");
992  /* Optimize away a "*" pattern */
993  if (strcmp(schemabuf.data, "^(.*)$") != 0 && schemavar)
994  {
995  WHEREAND();
996  appendPQExpBuffer(buf, "%s ~ ", schemavar);
997  appendStringLiteralConn(buf, schemabuf.data, conn);
998  appendPQExpBufferChar(buf, '\n');
999  }
1000  }
1001  else
1002  {
1003  /* No schema pattern given, so select only visible objects */
1004  if (visibilityrule)
1005  {
1006  WHEREAND();
1007  appendPQExpBuffer(buf, "%s\n", visibilityrule);
1008  }
1009  }
1010 
1011  termPQExpBuffer(&schemabuf);
1012  termPQExpBuffer(&namebuf);
1013 
1014  return added_clause;
1015 #undef WHEREAND
1016 }
#define WHEREAND()
int length(const List *list)
Definition: list.c:1271
PQExpBufferData * PQExpBuffer
Definition: pqexpbuffer.h:51
int quote_all_identifiers
Definition: string_utils.c:28
bool parsePGArray(const char *atext, char ***itemarray, int *nitems)
Definition: string_utils.c:662
const char * fmtId(const char *rawid)
Definition: string_utils.c:66
const ScanKeyword * ScanKeywordLookup(const char *text, const ScanKeyword *keywords, int num_keywords)
Definition: keywords.c:64
void termPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:128
bool appendShellStringNoError(PQExpBuffer buf, const char *str)
Definition: string_utils.c:446
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:385
const int NumScanKeywords
Definition: keywords.c:45
void appendConnStrVal(PQExpBuffer buf, const char *str)
Definition: string_utils.c:551
unsigned char pg_tolower(unsigned char ch)
Definition: pgstrcasecmp.c:122
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
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: string_utils.c:832
#define UNRESERVED_KEYWORD
Definition: keywords.h:18
int PQserverVersion(const PGconn *conn)
Definition: fe-connect.c:5978
#define ESCAPE_STRING_SYNTAX
Definition: c.h:510
int PQclientEncoding(const PGconn *conn)
Definition: fe-connect.c:6048
void appendPsqlMetaConnect(PQExpBuffer buf, const char *dbname)
Definition: string_utils.c:596
#define malloc(a)
Definition: header.h:50
void appendStringLiteralDQ(PQExpBuffer buf, const char *str, const char *dqprefix)
Definition: string_utils.c:336
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:113
#define IS_HIGHBIT_SET(ch)
Definition: c.h:973
PGconn * conn
Definition: streamutil.c:42
void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)
Definition: pqexpbuffer.c:262
void appendStringLiteral(PQExpBuffer buf, const char *str, int encoding, bool std_strings)
Definition: string_utils.c:220
char * c
static char * buf
Definition: pg_test_fsync.c:66
const ScanKeyword ScanKeywords[]
Definition: keywords.c:41
bool appendReloptionsArray(PQExpBuffer buffer, const char *reloptions, const char *prefix, int encoding, bool std_strings)
Definition: string_utils.c:746
size_t PQescapeStringConn(PGconn *conn, char *to, const char *from, size_t length, int *error)
Definition: fe-exec.c:3314
static PQExpBuffer defaultGetLocalPQExpBuffer(void)
static char ** options
PQExpBuffer createPQExpBuffer(void)
Definition: pqexpbuffer.c:71
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:396
void appendShellString(PQExpBuffer buf, const char *str)
Definition: string_utils.c:434
static char * encoding
Definition: initdb.c:122
#define free(a)
Definition: header.h:65
#define NULL
Definition: c.h:229
static const char hextbl[]
Definition: pgp-info.c:87
int16 category
Definition: keywords.h:28
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:211
char * dbname
Definition: streamutil.c:38
const char * name
Definition: encode.c:521
void appendStringLiteralConn(PQExpBuffer buf, const char *str, PGconn *conn)
Definition: string_utils.c:298
int i
#define EXIT_FAILURE
Definition: settings.h:151
#define SQL_STR_DOUBLE(ch, escape_backslash)
Definition: c.h:507
static struct @121 value
void resetPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:145
int PQmblen(const char *s, int encoding)
Definition: fe-misc.c:1182
static size_t noptions
#define _(x)
Definition: elog.c:84
PQExpBuffer(* getLocalPQExpBuffer)(void)
Definition: string_utils.c:29
const char * fmtQualifiedId(int remoteVersion, const char *schema, const char *id)
Definition: string_utils.c:150
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:89
void appendByteaLiteral(PQExpBuffer buf, const unsigned char *str, size_t length, bool std_strings)
Definition: string_utils.c:379
char * formatPGVersionNumber(int version_number, bool include_minor, char *buf, size_t buflen)
Definition: string_utils.c:182
static char * connstr
Definition: pg_dumpall.c:64
int enlargePQExpBuffer(PQExpBuffer str, size_t needed)
Definition: pqexpbuffer.c:171