--------+---------
(0 rows)
-set escape_string_warning=off;
--hstore;
select ''::hstore;
hstore
FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod
WHERE opc.oid >= 16384 AND NOT amvalidate(opc.oid);
-set escape_string_warning=off;
-
--hstore;
select ''::hstore;
&ScanKeywords,
ScanKeywordTokens);
- /* we don't want to re-emit any escape string warnings */
- yyextra.escape_string_warning = false;
-
/* Search for each constant, in sequence */
for (int i = 0; i < jstate->clocations_count; i++)
{
--------+---------
(0 rows)
---backslash is used in tests below, installcheck will fail if
---standard_conforming_string is off
-set standard_conforming_strings=on;
-- reduce noise
set extra_float_digits = 0;
select show_trgm('');
FROM pg_opclass opc LEFT JOIN pg_am am ON am.oid = opcmethod
WHERE opc.oid >= 16384 AND NOT amvalidate(opc.oid);
---backslash is used in tests below, installcheck will fail if
---standard_conforming_string is off
-set standard_conforming_strings=on;
-
-- reduce noise
set extra_float_digits = 0;
* Print literal `outputstr' already represented as string of type `typid'
* into stringbuf `s'.
*
- * Some builtin types aren't quoted, the rest is quoted. Escaping is done as
- * if standard_conforming_strings were enabled.
+ * Some builtin types aren't quoted, the rest is quoted. Escaping is done
+ * per standard SQL rules.
*/
static void
print_literal(StringInfo s, Oid typid, char *outputstr)
</term>
<listitem>
<para>
- This controls whether a quote mark can be represented by
- <literal>\'</literal> in a string literal. The preferred, SQL-standard way
+ This parameter controls whether a quote mark can be represented by
+ <literal>\'</literal> in the escape string syntax
+ (<literal>E'...'</literal>). The preferred, SQL-standard way
to represent a quote mark is by doubling it (<literal>''</literal>) but
<productname>PostgreSQL</productname> has historically also accepted
<literal>\'</literal>. However, use of <literal>\'</literal> creates security risks
</para>
<para>
- Note that in a standard-conforming string literal, <literal>\</literal> just
- means <literal>\</literal> anyway. This parameter only affects the handling of
- non-standard-conforming literals, including
- escape string syntax (<literal>E'...'</literal>).
- </para>
- </listitem>
- </varlistentry>
-
- <varlistentry id="guc-escape-string-warning" xreflabel="escape_string_warning">
- <term><varname>escape_string_warning</varname> (<type>boolean</type>)
- <indexterm><primary>strings</primary><secondary>escape warning</secondary></indexterm>
- <indexterm>
- <primary><varname>escape_string_warning</varname> configuration parameter</primary>
- </indexterm>
- </term>
- <listitem>
- <para>
- When on, a warning is issued if a backslash (<literal>\</literal>)
- appears in an ordinary string literal (<literal>'...'</literal>
- syntax) and <varname>standard_conforming_strings</varname> is off.
- The default is <literal>on</literal>.
- </para>
- <para>
- Applications that wish to use backslash as escape should be
- modified to use escape string syntax (<literal>E'...'</literal>),
- because the default behavior of ordinary strings is now to treat
- backslash as an ordinary character, per SQL standard. This variable
- can be enabled to help locate code that needs to be changed.
+ Note that in an ordinary string literal, <literal>\</literal> just
+ means <literal>\</literal> anyway. This parameter only affects
+ the handling of escape string syntax.
</para>
</listitem>
</varlistentry>
</term>
<listitem>
<para>
- This controls whether ordinary string literals
- (<literal>'...'</literal>) treat backslashes literally, as specified in
- the SQL standard.
- Beginning in <productname>PostgreSQL</productname> 9.1, the default is
- <literal>on</literal> (prior releases defaulted to <literal>off</literal>).
- Applications can check this
- parameter to determine how string literals will be processed.
- The presence of this parameter can also be taken as an indication
- that the escape string syntax (<literal>E'...'</literal>) is supported.
+ Beginning in <productname>PostgreSQL</productname> 19, this
+ parameter is always <literal>on</literal>. String literals are
+ always parsed as specified in the SQL standard (that is,
+ backslashes are ordinary characters within a string literal).
+ This parameter continues to exist because applications may consult
+ it; but it cannot be set to <literal>off</literal>.
Escape string syntax (<xref linkend="sql-syntax-strings-escape"/>)
should be used if an application desires
backslashes to be treated as escape characters.
Embedded <acronym>SQL</acronym> statements likewise use SQL rules, not
C rules, for parsing quoted strings and identifiers.
(See <xref linkend="sql-syntax-strings"/> and
- <xref linkend="sql-syntax-identifiers"/> respectively. Note that
- ECPG assumes that <varname>standard_conforming_strings</varname>
- is <literal>on</literal>.)
+ <xref linkend="sql-syntax-identifiers"/> respectively.)
Of course, the C part of the program follows C quoting rules.
</para>
character itself, write two escape characters.
</para>
- <note>
- <para>
- If you have <xref linkend="guc-standard-conforming-strings"/> turned off,
- any backslashes you write in literal string constants will need to be
- doubled. See <xref linkend="sql-syntax-strings"/> for more information.
- </para>
- </note>
-
<para>
It's also possible to select no escape character by writing
<literal>ESCAPE ''</literal>. This effectively disables the
An RE cannot end with a backslash (<literal>\</literal>).
</para>
- <note>
- <para>
- If you have <xref linkend="guc-standard-conforming-strings"/> turned off,
- any backslashes you write in literal string constants will need to be
- doubled. See <xref linkend="sql-syntax-strings"/> for more information.
- </para>
- </note>
-
<table id="posix-quantifiers-table">
<title>Regular Expression Quantifiers</title>
applies <emphasis>before</emphasis> any required quoting or escaping. If you are
passing an <type>hstore</type> literal via a parameter, then no additional
processing is needed. But if you're passing it as a quoted literal
- constant, then any single-quote characters and (depending on the setting of
- the <varname>standard_conforming_strings</varname> configuration parameter)
- backslash characters need to be escaped correctly. See
+ constant, then any single-quote characters need to be escaped correctly. See
<xref linkend="sql-syntax-strings"/> for more on the handling of string
constants.
</para>
before 16; <varname>search_path</varname> was not reported by releases
before 18.)
Note that
- <varname>server_version</varname>,
- <varname>server_encoding</varname> and
- <varname>integer_datetimes</varname>
+ <varname>server_version</varname> and
+ <varname>server_encoding</varname>
cannot change after startup.
- </para>
-
- <para>
- If no value for <varname>standard_conforming_strings</varname> is reported,
- applications can assume it is <literal>off</literal>, that is, backslashes
- are treated as escapes in string literals. Also, the presence of
- this parameter can be taken as an indication that the escape string
- syntax (<literal>E'...'</literal>) is accepted.
+ Also, <varname>integer_datetimes</varname> is
+ always <literal>on</literal> in releases 9.5 and later,
+ and <varname>standard_conforming_strings</varname> is
+ always <literal>on</literal> in releases 19 and later.
</para>
<para>
*
* CREATE SCHEMA testlibpq3;
* SET search_path = testlibpq3;
- * SET standard_conforming_strings = ON;
* CREATE TABLE test1 (i int4, t text, b bytea);
* INSERT INTO test1 values (1, 'joe''s place', '\000\001\002\003\004');
* INSERT INTO test1 values (2, 'ho there', '\004\003\002\001\000');
<para>
Sets the label of the backup. If none is specified, a backup label
of <literal>base backup</literal> will be used. The quoting rules
- for the label are the same as a standard SQL string with
- <xref linkend="guc-standard-conforming-strings"/> turned on.
+ for the label are the same as for a standard SQL string.
</para>
</listitem>
</varlistentry>
will check that the character conversion is possible.
</para>
- <caution>
- <para>
- If the configuration parameter
- <xref linkend="guc-standard-conforming-strings"/> is <literal>off</literal>,
- then <productname>PostgreSQL</productname> recognizes backslash escapes
- in both regular and escape string constants. However, as of
- <productname>PostgreSQL</productname> 9.1, the default is <literal>on</literal>, meaning
- that backslash escapes are recognized only in escape string constants.
- This behavior is more standards-compliant, but might break applications
- which rely on the historical behavior, where backslash escapes
- were always recognized. As a workaround, you can set this parameter
- to <literal>off</literal>, but it is better to migrate away from using backslash
- escapes. If you need to use a backslash escape to represent a special
- character, write the string constant with an <literal>E</literal>.
- </para>
-
- <para>
- In addition to <varname>standard_conforming_strings</varname>, the configuration
- parameters <xref linkend="guc-escape-string-warning"/> and
- <xref linkend="guc-backslash-quote"/> govern treatment of backslashes
- in string constants.
- </para>
- </caution>
-
<para>
The character with the code zero cannot be in a string constant.
</para>
by one of these escape sequences is converted to the actual server
encoding; an error is reported if that's not possible.
</para>
-
- <para>
- Also, the Unicode escape syntax for string constants only works
- when the configuration
- parameter <xref linkend="guc-standard-conforming-strings"/> is
- turned on. This is because otherwise this syntax could confuse
- clients that parse the SQL statements to the point that it could
- lead to SQL injections and similar security issues. If the
- parameter is set to off, this syntax will be rejected with an
- error message.
- </para>
</sect3>
<sect3 id="sql-syntax-dollar-quoting">
#endif
return true;
}
+
+bool
+check_standard_conforming_strings(bool *newval, void **extra, GucSource source)
+{
+ if (!*newval)
+ {
+ /* check the GUC's definition for an explanation */
+ GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
+ GUC_check_errmsg("non-standard string literals are not supported");
+
+ return false;
+ }
+
+ return true;
+}
}
/*
- * GUC variables. This is a DIRECT violation of the warning given at the
+ * GUC variable. This is a DIRECT violation of the warning given at the
* head of gram.y, ie flex/bison code must not depend on any GUC variables;
- * as such, changing their values can induce very unintuitive behavior.
- * But we shall have to live with it until we can remove these variables.
+ * as such, changing its value can induce very unintuitive behavior.
+ * In practice, backslash_quote is not too awful since it only controls
+ * whether to throw an error: it cannot change non-error results.
*/
int backslash_quote = BACKSLASH_QUOTE_SAFE_ENCODING;
-bool escape_string_warning = true;
-bool standard_conforming_strings = true;
/*
* Constant data exported from this file. This array maps from the
#define lexer_errposition() scanner_errposition(*(yylloc), yyscanner)
-static void check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner);
-static void check_escape_warning(core_yyscan_t yyscanner);
-
%}
%option reentrant
}
{xqstart} {
- yyextra->warn_on_first_escape = true;
yyextra->saw_non_ascii = false;
SET_YYLLOC();
- if (yyextra->standard_conforming_strings)
- BEGIN(xq);
- else
- BEGIN(xe);
+ BEGIN(xq);
startlit();
}
{xestart} {
- yyextra->warn_on_first_escape = false;
yyextra->saw_non_ascii = false;
SET_YYLLOC();
BEGIN(xe);
}
{xusstart} {
SET_YYLLOC();
- if (!yyextra->standard_conforming_strings)
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("unsafe use of string constant with Unicode escapes"),
- errdetail("String constants with Unicode escapes cannot be used when \"standard_conforming_strings\" is off."),
- lexer_errposition()));
BEGIN(xus);
startlit();
}
<xe>{xeunicode} {
char32_t c = strtoul(yytext + 2, NULL, 16);
- /*
- * For consistency with other productions, issue any
- * escape warning with cursor pointing to start of string.
- * We might want to change that, someday.
- */
- check_escape_warning(yyscanner);
-
/* Remember start of overall string token ... */
PUSH_YYLLOC();
/* ... and set the error cursor to point at this esc seq */
errhint("Use '' to write quotes in strings. \\' is insecure in client-only encodings."),
lexer_errposition()));
}
- check_string_escape_warning(yytext[1], yyscanner);
addlitchar(unescape_single_char(yytext[1], yyscanner),
yyscanner);
}
<xe>{xeoctesc} {
unsigned char c = strtoul(yytext + 1, NULL, 8);
- check_escape_warning(yyscanner);
addlitchar(c, yyscanner);
if (c == '\0' || IS_HIGHBIT_SET(c))
yyextra->saw_non_ascii = true;
<xe>{xehexesc} {
unsigned char c = strtoul(yytext + 2, NULL, 16);
- check_escape_warning(yyscanner);
addlitchar(c, yyscanner);
if (c == '\0' || IS_HIGHBIT_SET(c))
yyextra->saw_non_ascii = true;
yyext->keyword_tokens = keyword_tokens;
yyext->backslash_quote = backslash_quote;
- yyext->escape_string_warning = escape_string_warning;
- yyext->standard_conforming_strings = standard_conforming_strings;
/*
* Make a scan buffer with special termination needed by flex.
}
}
-static void
-check_string_escape_warning(unsigned char ychar, core_yyscan_t yyscanner)
-{
- if (ychar == '\'')
- {
- if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
- ereport(WARNING,
- (errcode(ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
- errmsg("nonstandard use of \\' in a string literal"),
- errhint("Use '' to write quotes in strings, or use the escape string syntax (E'...')."),
- lexer_errposition()));
- yyextra->warn_on_first_escape = false; /* warn only once per string */
- }
- else if (ychar == '\\')
- {
- if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
- ereport(WARNING,
- (errcode(ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
- errmsg("nonstandard use of \\\\ in a string literal"),
- errhint("Use the escape string syntax for backslashes, e.g., E'\\\\'."),
- lexer_errposition()));
- yyextra->warn_on_first_escape = false; /* warn only once per string */
- }
- else
- check_escape_warning(yyscanner);
-}
-
-static void
-check_escape_warning(core_yyscan_t yyscanner)
-{
- if (yyextra->warn_on_first_escape && yyextra->escape_string_warning)
- ereport(WARNING,
- (errcode(ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
- errmsg("nonstandard use of escape in a string literal"),
- errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
- lexer_errposition()));
- yyextra->warn_on_first_escape = false; /* warn only once per string */
-}
-
/*
* Interface functions to make flex use palloc() instead of malloc().
* It'd be better to make these static, but flex insists otherwise.
* quote_literal_internal -
* helper function for quote_literal and quote_literal_cstr
*
- * NOTE: think not to make this function's behavior change with
- * standard_conforming_strings. We don't know where the result
- * literal will be used, and so we must generate a result that
- * will work with either setting. Take a look at what dblink
- * uses this for before thinking you know better.
+ * NOTE: This must produce output that will work in old servers with
+ * standard_conforming_strings = off. It's used for example by
+ * dblink, which may send the result to another server.
*/
static size_t
quote_literal_internal(char *dst, const char *src, size_t len)
const char *valptr;
/*
- * We form the string literal according to the prevailing setting of
- * standard_conforming_strings; we never use E''. User is responsible for
- * making sure result is used correctly.
+ * We always form the string literal according to standard SQL rules.
*/
appendStringInfoChar(buf, '\'');
for (valptr = val; *valptr; valptr++)
{
char ch = *valptr;
- if (SQL_STR_DOUBLE(ch, !standard_conforming_strings))
+ if (SQL_STR_DOUBLE(ch, false))
appendStringInfoChar(buf, ch);
appendStringInfoChar(buf, ch);
}
boot_val => 'true',
},
-{ name => 'escape_string_warning', type => 'bool', context => 'PGC_USERSET', group => 'COMPAT_OPTIONS_PREVIOUS',
- short_desc => 'Warn about backslash escapes in ordinary string literals.',
- variable => 'escape_string_warning',
- boot_val => 'true',
-},
-
{ name => 'event_source', type => 'string', context => 'PGC_POSTMASTER', group => 'LOGGING_WHERE',
short_desc => 'Sets the application name used to identify PostgreSQL messages in the event log.',
variable => 'event_source',
boot_val => '""',
},
+# We removed support for non-conforming string literals in PostgreSQL 19,
+# but this parameter must be kept indefinitely, since client code might
+# consult it or attempt to set it. We allow it to be explicitly set to true.
{ name => 'standard_conforming_strings', type => 'bool', context => 'PGC_USERSET', group => 'COMPAT_OPTIONS_PREVIOUS',
- short_desc => 'Causes \'...\' strings to treat backslashes literally.',
- flags => 'GUC_REPORT',
+ short_desc => 'Nonstandard strings are no longer supported; this can only be true.',
+ flags => 'GUC_REPORT | GUC_NOT_IN_SAMPLE',
variable => 'standard_conforming_strings',
boot_val => 'true',
+ check_hook => 'check_standard_conforming_strings',
},
{ name => 'statement_timeout', type => 'int', context => 'PGC_USERSET', group => 'CLIENT_CONN_STATEMENT',
bool check_function_bodies = true;
/*
- * This GUC exists solely for backward compatibility, check its definition for
- * details.
+ * These GUCs exist solely for backward compatibility.
*/
static bool default_with_oids = false;
+static bool standard_conforming_strings = true;
bool current_role_is_superuser;
#array_nulls = on
#backslash_quote = safe_encoding # on, off, or safe_encoding
-#escape_string_warning = on
#lo_compat_privileges = off
#quote_all_identifiers = off
-#standard_conforming_strings = on
#synchronize_seqscans = on
# - Other Platforms and Clients -
/* Avoid annoying notices etc */
ahprintf(AH, "SET client_min_messages = warning;\n");
- if (!AH->public.std_strings)
- ahprintf(AH, "SET escape_string_warning = off;\n");
/* Adjust row-security state */
if (ropt && ropt->enable_row_security)
{
DumpOptions *dopt = AH->dopt;
PGconn *conn = GetConnection(AH);
- const char *std_strings;
PQclear(ExecuteSqlQueryForSingleRow(AH, ALWAYS_SECURE_SEARCH_PATH_SQL));
}
/*
- * Get the active encoding and the standard_conforming_strings setting, so
- * we know how to escape strings.
+ * Force standard_conforming_strings on, just in case we are dumping from
+ * an old server that has it disabled. Without this, literals in views,
+ * expressions, etc, would be incorrect for modern servers.
+ */
+ ExecuteSqlStatement(AH, "SET standard_conforming_strings = on");
+
+ /*
+ * And reflect that to AH->std_strings. You might think that we should
+ * just delete that variable and the code that checks it, but that would
+ * be problematic for pg_restore, which at least for now should still cope
+ * with archives containing the other setting (cf. processStdStringsEntry
+ * in pg_backup_archiver.c).
+ */
+ AH->std_strings = true;
+
+ /*
+ * Get the active encoding, so we know how to escape strings.
*/
AH->encoding = PQclientEncoding(conn);
setFmtEncoding(AH->encoding);
- std_strings = PQparameterStatus(conn, "standard_conforming_strings");
- AH->std_strings = (std_strings && strcmp(std_strings, "on") == 0);
-
/*
* Set the role if requested. In a parallel dump worker, we'll be passed
* use_role == NULL, but AH->use_role is already set (if user specified it
bool tablespaces_only = false;
PGconn *conn;
int encoding;
- const char *std_strings;
int c,
ret;
int optindex;
}
/*
- * Get the active encoding and the standard_conforming_strings setting, so
- * we know how to escape strings.
+ * Force standard_conforming_strings on, just in case we are dumping from
+ * an old server that has it disabled. Without this, literals in views,
+ * expressions, etc, would be incorrect for modern servers.
+ */
+ executeCommand(conn, "SET standard_conforming_strings = on");
+
+ /*
+ * Get the active encoding, so we know how to escape strings.
*/
encoding = PQclientEncoding(conn);
setFmtEncoding(encoding);
- std_strings = PQparameterStatus(conn, "standard_conforming_strings");
- if (!std_strings)
- std_strings = "off";
/* Set the role if requested */
if (use_role)
/* Restore will need to write to the target cluster */
fprintf(OPF, "SET default_transaction_read_only = off;\n\n");
- /* Replicate encoding and std_strings in output */
+ /* Replicate encoding and standard_conforming_strings in output */
fprintf(OPF, "SET client_encoding = '%s';\n",
pg_encoding_to_char(encoding));
- fprintf(OPF, "SET standard_conforming_strings = %s;\n", std_strings);
- if (strcmp(std_strings, "off") == 0)
- fprintf(OPF, "SET escape_string_warning = off;\n");
+ fprintf(OPF, "SET standard_conforming_strings = on;\n");
fprintf(OPF, "\n");
if (!data_only && !statistics_only && !no_schema)
/*
* XXX This is a kluge to silence escape_string_warning in our utility
- * programs. It should go away someday.
+ * programs. It can go away once pre-v19 servers are out of support.
*/
- if (strchr(str, '\\') != NULL && PQserverVersion(conn) >= 80100)
+ if (strchr(str, '\\') != NULL && PQserverVersion(conn) < 190000)
{
/* ensure we are not adjacent to an identifier */
if (buf->len > 0 && buf->data[buf->len - 1] != ' ')
BACKSLASH_QUOTE_SAFE_ENCODING,
} BackslashQuoteType;
-/* GUC variables in scan.l (every one of these is a bad idea :-() */
+/* GUC variable in scan.l */
extern PGDLLIMPORT int backslash_quote;
-extern PGDLLIMPORT bool escape_string_warning;
-extern PGDLLIMPORT bool standard_conforming_strings;
/* Primary entry point for the raw parsing functions */
* prevailing GUC settings.
*/
int backslash_quote;
- bool escape_string_warning;
- bool standard_conforming_strings;
/*
* literalbuf is used to accumulate literal values when multiple rules are
/* first part of UTF16 surrogate pair for Unicode escapes */
int32 utf16_first_part;
- /* state variables for literal-lexing warnings */
- bool warn_on_first_escape;
+ /* true if we need to verify valid encoding of current literal string */
bool saw_non_ascii;
} core_yy_extra_type;
extern void assign_stats_fetch_consistency(int newval, void *extra);
extern bool check_ssl(bool *newval, void **extra, GucSource source);
extern bool check_stage_log_stats(bool *newval, void **extra, GucSource source);
+extern bool check_standard_conforming_strings(bool *newval, void **extra,
+ GucSource source);
extern bool check_subtrans_buffers(int *newval, void **extra,
GucSource source);
extern bool check_synchronous_standby_names(char **newval, void **extra,
#line 20 "quote.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set standard_conforming_strings to off", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set standard_conforming_strings to on", ECPGt_EOIT, ECPGt_EORT);
#line 22 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
printf("Standard conforming strings: %s\n", var);
- /* this is a\\b actually */
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 1 , 'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
+ /* this is a\\\\b actually */
+ { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 2 , 'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
#line 28 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
#line 28 "quote.pgc"
/* this is a\\b */
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 1 , E'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 2 , E'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
#line 30 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
#line 30 "quote.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set standard_conforming_strings to on", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGtrans(__LINE__, NULL, "begin");
#line 32 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
if (sqlca.sqlcode < 0) exit (1);}
#line 32 "quote.pgc"
-
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "show standard_conforming_strings", ECPGt_EOIT,
- ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char),
- ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
-#line 34 "quote.pgc"
-
-if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 34 "quote.pgc"
-
-if (sqlca.sqlcode < 0) exit (1);}
-#line 34 "quote.pgc"
-
- printf("Standard conforming strings: %s\n", var);
-
- /* this is a\\\\b actually */
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 2 , 'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
-#line 38 "quote.pgc"
-
-if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 38 "quote.pgc"
-
-if (sqlca.sqlcode < 0) exit (1);}
-#line 38 "quote.pgc"
-
- /* this is a\\b */
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into \"My_Table\" values ( 2 , E'a\\\\\\\\b' )", ECPGt_EOIT, ECPGt_EORT);
-#line 40 "quote.pgc"
-
-if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 40 "quote.pgc"
-
-if (sqlca.sqlcode < 0) exit (1);}
-#line 40 "quote.pgc"
-
-
- { ECPGtrans(__LINE__, NULL, "begin");
-#line 42 "quote.pgc"
-
-if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 42 "quote.pgc"
-
-if (sqlca.sqlcode < 0) exit (1);}
-#line 42 "quote.pgc"
-
/* declare C cursor for select * from \"My_Table\" */
-#line 43 "quote.pgc"
+#line 33 "quote.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "declare C cursor for select * from \"My_Table\"", ECPGt_EOIT, ECPGt_EORT);
-#line 45 "quote.pgc"
+#line 35 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 45 "quote.pgc"
+#line 35 "quote.pgc"
if (sqlca.sqlcode < 0) exit (1);}
-#line 45 "quote.pgc"
+#line 35 "quote.pgc"
/* exec sql whenever not found break ; */
-#line 47 "quote.pgc"
+#line 37 "quote.pgc"
for (loopcount = 0; loopcount < 100; loopcount++)
ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L,
ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char),
ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
-#line 51 "quote.pgc"
+#line 41 "quote.pgc"
if (sqlca.sqlcode == ECPG_NOT_FOUND) break;
-#line 51 "quote.pgc"
+#line 41 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 51 "quote.pgc"
+#line 41 "quote.pgc"
if (sqlca.sqlcode < 0) exit (1);}
-#line 51 "quote.pgc"
+#line 41 "quote.pgc"
printf("value: %d %s\n", i, var);
}
{ ECPGtrans(__LINE__, NULL, "rollback");
-#line 55 "quote.pgc"
+#line 45 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 55 "quote.pgc"
+#line 45 "quote.pgc"
if (sqlca.sqlcode < 0) exit (1);}
-#line 55 "quote.pgc"
+#line 45 "quote.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table \"My_Table\"", ECPGt_EOIT, ECPGt_EORT);
-#line 56 "quote.pgc"
+#line 46 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 56 "quote.pgc"
+#line 46 "quote.pgc"
if (sqlca.sqlcode < 0) exit (1);}
-#line 56 "quote.pgc"
+#line 46 "quote.pgc"
{ ECPGdisconnect(__LINE__, "ALL");
-#line 58 "quote.pgc"
+#line 48 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 58 "quote.pgc"
+#line 48 "quote.pgc"
if (sqlca.sqlcode < 0) exit (1);}
-#line 58 "quote.pgc"
+#line 48 "quote.pgc"
return 0;
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_process_output on line 20: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 22: query: set standard_conforming_strings to off; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 22: query: set standard_conforming_strings to on; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_process_output on line 24: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 24: RESULT: off offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 24: RESULT: on offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 28: query: insert into "My_Table" values ( 1 , 'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 28: query: insert into "My_Table" values ( 2 , 'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGnoticeReceiver: nonstandard use of \\ in a string literal
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 0
-[NO_PID]: sqlca: code: 0, state: 22P06
[NO_PID]: ecpg_execute on line 28: using PQexec
-[NO_PID]: sqlca: code: 0, state: 22P06
+[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_process_output on line 28: OK: INSERT 0 1
-[NO_PID]: sqlca: code: 0, state: 22P06
-SQL error: nonstandard use of \\ in a string literal
-[NO_PID]: ecpg_execute on line 30: query: insert into "My_Table" values ( 1 , E'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ecpg_execute on line 30: query: insert into "My_Table" values ( 2 , E'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_process_output on line 30: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 32: query: set standard_conforming_strings to on; with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 32: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 32: OK: SET
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 34: query: show standard_conforming_strings; with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 34: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 34: correctly got 1 tuples with 1 fields
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 34: RESULT: on offset: -1; array: no
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 38: query: insert into "My_Table" values ( 2 , 'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 38: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 38: OK: INSERT 0 1
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 40: query: insert into "My_Table" values ( 2 , E'a\\\\b' ); with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 40: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 40: OK: INSERT 0 1
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans on line 42: action "begin"; connection "ecpg1_regression"
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 45: query: declare C cursor for select * from "My_Table"; with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 45: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 45: OK: DECLARE CURSOR
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: using PQexec
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 51: correctly got 1 tuples with 2 fields
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: 1 offset: -1; array: no
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: a\\b offset: -1; array: no
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
-[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: using PQexec
+[NO_PID]: ECPGtrans on line 32: action "begin"; connection "ecpg1_regression"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 51: correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 35: query: declare C cursor for select * from "My_Table"; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: 1 offset: -1; array: no
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: a\\b offset: -1; array: no
+[NO_PID]: ecpg_process_output on line 35: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 41: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: using PQexec
+[NO_PID]: ecpg_execute on line 41: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 51: correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_process_output on line 41: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: 2 offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 41: RESULT: 2 offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: a\\\\b offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 41: RESULT: a\\\\b offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 41: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: using PQexec
+[NO_PID]: ecpg_execute on line 41: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 51: correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_process_output on line 41: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: 2 offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 41: RESULT: 2 offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 51: RESULT: a\\b offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 41: RESULT: a\\b offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 41: query: fetch C; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 51: using PQexec
+[NO_PID]: ecpg_execute on line 41: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 51: correctly got 0 tuples with 2 fields
+[NO_PID]: ecpg_process_output on line 41: correctly got 0 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 on line 51: no data found on line 51
+[NO_PID]: raising sqlcode 100 on line 41: no data found on line 41
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGtrans on line 55: action "rollback"; connection "ecpg1_regression"
+[NO_PID]: ECPGtrans on line 45: action "rollback"; connection "ecpg1_regression"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 56: query: drop table "My_Table"; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 46: query: drop table "My_Table"; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 56: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_process_output on line 56: OK: DROP TABLE
+[NO_PID]: ecpg_process_output on line 46: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_finish: connection ecpg1_regression closed
[NO_PID]: sqlca: code: 0, state: 00000
-Standard conforming strings: off
Standard conforming strings: on
-value: 1 a\\b
-value: 1 a\\b
value: 2 a\\\\b
value: 2 a\\b
printf("Var: Search path: %s\n", var);
- { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set standard_conforming_strings to off", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set standard_conforming_strings to on", ECPGt_EOIT, ECPGt_EORT);
#line 26 "show.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_get_data on line 23: RESULT: public offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute on line 26: query: set standard_conforming_strings to off; with 0 parameter(s) on connection ecpg1_regression
+[NO_PID]: ecpg_execute on line 26: query: set standard_conforming_strings to on; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_process_output on line 27: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data on line 27: RESULT: off offset: -1; array: no
+[NO_PID]: ecpg_get_data on line 27: RESULT: on offset: -1; array: no
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ecpg_execute on line 30: query: set time zone PST8PDT; with 0 parameter(s) on connection ecpg1_regression
[NO_PID]: sqlca: code: 0, state: 00000
Var: Search path: public
Var: Search path: public
-Var: Standard conforming strings: off
+Var: Standard conforming strings: on
Time Zone: PST8PDT
Transaction isolation level: read committed
EXEC SQL CREATE TABLE "My_Table" ( Item1 int, Item2 text );
- EXEC SQL SET standard_conforming_strings TO off;
-
- EXEC SQL SHOW standard_conforming_strings INTO :var;
- printf("Standard conforming strings: %s\n", var);
-
- /* this is a\\b actually */
- EXEC SQL INSERT INTO "My_Table" VALUES ( 1, 'a\\\\b' );
- /* this is a\\b */
- EXEC SQL INSERT INTO "My_Table" VALUES ( 1, E'a\\\\b' );
-
EXEC SQL SET standard_conforming_strings TO on;
EXEC SQL SHOW standard_conforming_strings INTO :var;
EXEC SQL SHOW search_path INTO :var;
printf("Var: Search path: %s\n", var);
- EXEC SQL SET standard_conforming_strings TO off;
+ EXEC SQL SET standard_conforming_strings TO on;
EXEC SQL SHOW standard_conforming_strings INTO :var;
printf("Var: Standard conforming strings: %s\n", var);
*
* CREATE SCHEMA testlibpq3;
* SET search_path = testlibpq3;
- * SET standard_conforming_strings = ON;
* CREATE TABLE test1 (i int4, t text, b bytea);
* INSERT INTO test1 values (1, 'joe''s place', '\000\001\002\003\004');
* INSERT INTO test1 values (2, 'ho there', '\004\003\002\001\000');
CREATE SCHEMA testlibpq3;
SET search_path = testlibpq3;
-SET standard_conforming_strings = ON;
CREATE TABLE test1 (i int4, t text, b bytea);
INSERT INTO test1 values (1, 'joe''s place', '\000\001\002\003\004');
INSERT INTO test1 values (2, 'ho there', '\004\003\002\001\000');
-- Most commented lines below are copied from reg.test. Each
-- test case is followed by an equivalent test using test_regex().
create extension test_regex;
-set standard_conforming_strings = on;
-- # support functions and preliminary misc.
-- # This is sensitive to changes in message wording, but we really have to
-- # test the code->message expansion at least once.
\quit
\endif
set client_encoding = utf8;
-set standard_conforming_strings = on;
-- Run the Tcl test cases that require Unicode
-- expectMatch 9.44 EMP* {a[\u00fe-\u0507][\u00ff-\u0300]b} \
-- "a\u0102\u02ffb" "a\u0102\u02ffb"
create extension test_regex;
-set standard_conforming_strings = on;
-
-- # support functions and preliminary misc.
-- # This is sensitive to changes in message wording, but we really have to
-- # test the code->message expansion at least once.
set client_encoding = utf8;
-set standard_conforming_strings = on;
-
-- Run the Tcl test cases that require Unicode
PL/pgSQL function fail() line 3 at RETURN
drop function fail();
-- Test handling of string literals.
-set standard_conforming_strings = off;
-create or replace function strtest() returns text as $$
-begin
- raise notice 'foo\\bar\041baz';
- return 'foo\\bar\041baz';
-end
-$$ language plpgsql;
-WARNING: nonstandard use of \\ in a string literal
-LINE 3: raise notice 'foo\\bar\041baz';
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 4: return 'foo\\bar\041baz';
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 4: return 'foo\\bar\041baz';
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-select strtest();
-NOTICE: foo\bar!baz
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: 'foo\\bar\041baz'
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-QUERY: 'foo\\bar\041baz'
- strtest
--------------
- foo\bar!baz
-(1 row)
-
-create or replace function strtest() returns text as $$
-begin
- raise notice E'foo\\bar\041baz';
- return E'foo\\bar\041baz';
-end
-$$ language plpgsql;
-select strtest();
-NOTICE: foo\bar!baz
- strtest
--------------
- foo\bar!baz
-(1 row)
-
-set standard_conforming_strings = on;
create or replace function strtest() returns text as $$
begin
raise notice 'foo\\bar\041baz\';
--
-- Regular expression tests
--
--- Don't want to have to double backslashes in regexes
-set standard_conforming_strings = on;
-- Test simple quantified backrefs
select 'bbbbb' ~ '^([bc])\1*$' as t;
t
LINE 3: ' - third line'
^
-- Unicode escapes
-SET standard_conforming_strings TO on;
SELECT U&'d\0061t\+000061' AS U&"d\0061t\+000061";
data
------
ERROR: invalid Unicode escape value at or near "\U002FFFFF"
LINE 1: SELECT E'wrong: \U002FFFFF';
^
+-- this is no longer allowed:
SET standard_conforming_strings TO off;
-SELECT U&'d\0061t\+000061' AS U&"d\0061t\+000061";
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&'d\0061t\+000061' AS U&"d\0061t\+000061";
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
-SELECT U&'d!0061t\+000061' UESCAPE '!' AS U&"d*0061t\+000061" UESCAPE '*';
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&'d!0061t\+000061' UESCAPE '!' AS U&"d*0061t\+000061...
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
-SELECT U&' \' UESCAPE '!' AS "tricky";
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&' \' UESCAPE '!' AS "tricky";
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
-SELECT 'tricky' AS U&"\" UESCAPE '!';
- \
---------
- tricky
-(1 row)
-
-SELECT U&'wrong: \061';
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&'wrong: \061';
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
-SELECT U&'wrong: \+0061';
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&'wrong: \+0061';
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
-SELECT U&'wrong: +0061' UESCAPE '+';
-ERROR: unsafe use of string constant with Unicode escapes
-LINE 1: SELECT U&'wrong: +0061' UESCAPE '+';
- ^
-DETAIL: String constants with Unicode escapes cannot be used when "standard_conforming_strings" is off.
+ERROR: non-standard string literals are not supported
+-- but this should be acceptable:
+SET standard_conforming_strings TO on;
+-- or this:
RESET standard_conforming_strings;
-- bytea
SET bytea_output TO hex;
-9223372036854775808 | 9223372036854775807
(1 row)
---
--- test behavior of escape_string_warning and standard_conforming_strings options
---
-set escape_string_warning = off;
-set standard_conforming_strings = off;
-show escape_string_warning;
- escape_string_warning
------------------------
- off
-(1 row)
-
-show standard_conforming_strings;
- standard_conforming_strings
------------------------------
- off
-(1 row)
-
-set escape_string_warning = on;
-set standard_conforming_strings = on;
-show escape_string_warning;
- escape_string_warning
------------------------
- on
-(1 row)
-
-show standard_conforming_strings;
- standard_conforming_strings
------------------------------
- on
-(1 row)
-
-select 'a\bcd' as f1, 'a\b''cd' as f2, 'a\b''''cd' as f3, 'abcd\' as f4, 'ab\''cd' as f5, '\\' as f6;
- f1 | f2 | f3 | f4 | f5 | f6
--------+--------+---------+-------+--------+----
- a\bcd | a\b'cd | a\b''cd | abcd\ | ab\'cd | \\
-(1 row)
-
-set standard_conforming_strings = off;
-select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd' as f5, '\\\\' as f6;
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3,...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3,...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3,...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: ...bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' ...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: ...'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd'...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
-WARNING: nonstandard use of \\ in a string literal
-LINE 1: ...'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd' as f5, '\\\\' as ...
- ^
-HINT: Use the escape string syntax for backslashes, e.g., E'\\'.
- f1 | f2 | f3 | f4 | f5 | f6
--------+--------+---------+-------+--------+----
- a\bcd | a\b'cd | a\b''cd | abcd\ | ab\'cd | \\
-(1 row)
-
-set escape_string_warning = off;
-set standard_conforming_strings = on;
-select 'a\bcd' as f1, 'a\b''cd' as f2, 'a\b''''cd' as f3, 'abcd\' as f4, 'ab\''cd' as f5, '\\' as f6;
- f1 | f2 | f3 | f4 | f5 | f6
--------+--------+---------+-------+--------+----
- a\bcd | a\b'cd | a\b''cd | abcd\ | ab\'cd | \\
-(1 row)
-
-set standard_conforming_strings = off;
-select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd' as f5, '\\\\' as f6;
- f1 | f2 | f3 | f4 | f5 | f6
--------+--------+---------+-------+--------+----
- a\bcd | a\b'cd | a\b''cd | abcd\ | ab\'cd | \\
-(1 row)
-
-reset standard_conforming_strings;
--
-- Additional string functions
--
-- Test handling of string literals.
-set standard_conforming_strings = off;
-
-create or replace function strtest() returns text as $$
-begin
- raise notice 'foo\\bar\041baz';
- return 'foo\\bar\041baz';
-end
-$$ language plpgsql;
-
-select strtest();
-
-create or replace function strtest() returns text as $$
-begin
- raise notice E'foo\\bar\041baz';
- return E'foo\\bar\041baz';
-end
-$$ language plpgsql;
-
-select strtest();
-
-set standard_conforming_strings = on;
-
create or replace function strtest() returns text as $$
begin
raise notice 'foo\\bar\041baz\';
-- Regular expression tests
--
--- Don't want to have to double backslashes in regexes
-set standard_conforming_strings = on;
-
-- Test simple quantified backrefs
select 'bbbbb' ~ '^([bc])\1*$' as t;
select 'ccc' ~ '^([bc])\1*$' as t;
AS "Illegal comment within continuation";
-- Unicode escapes
-SET standard_conforming_strings TO on;
-
SELECT U&'d\0061t\+000061' AS U&"d\0061t\+000061";
SELECT U&'d!0061t\+000061' UESCAPE '!' AS U&"d*0061t\+000061" UESCAPE '*';
SELECT U&'a\\b' AS "a\b";
SELECT E'wrong: \U0000db99\U00000061';
SELECT E'wrong: \U002FFFFF';
+-- this is no longer allowed:
SET standard_conforming_strings TO off;
-
-SELECT U&'d\0061t\+000061' AS U&"d\0061t\+000061";
-SELECT U&'d!0061t\+000061' UESCAPE '!' AS U&"d*0061t\+000061" UESCAPE '*';
-
-SELECT U&' \' UESCAPE '!' AS "tricky";
-SELECT 'tricky' AS U&"\" UESCAPE '!';
-
-SELECT U&'wrong: \061';
-SELECT U&'wrong: \+0061';
-SELECT U&'wrong: +0061' UESCAPE '+';
-
+-- but this should be acceptable:
+SET standard_conforming_strings TO on;
+-- or this:
RESET standard_conforming_strings;
-- bytea
SELECT '\x8000000000000000'::bytea::int8 AS "-9223372036854775808",
'\x7FFFFFFFFFFFFFFF'::bytea::int8 AS "9223372036854775807";
---
--- test behavior of escape_string_warning and standard_conforming_strings options
---
-set escape_string_warning = off;
-set standard_conforming_strings = off;
-
-show escape_string_warning;
-show standard_conforming_strings;
-
-set escape_string_warning = on;
-set standard_conforming_strings = on;
-
-show escape_string_warning;
-show standard_conforming_strings;
-
-select 'a\bcd' as f1, 'a\b''cd' as f2, 'a\b''''cd' as f3, 'abcd\' as f4, 'ab\''cd' as f5, '\\' as f6;
-
-set standard_conforming_strings = off;
-
-select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd' as f5, '\\\\' as f6;
-
-set escape_string_warning = off;
-set standard_conforming_strings = on;
-
-select 'a\bcd' as f1, 'a\b''cd' as f2, 'a\b''''cd' as f3, 'abcd\' as f4, 'ab\''cd' as f5, '\\' as f6;
-
-set standard_conforming_strings = off;
-
-select 'a\\bcd' as f1, 'a\\b\'cd' as f2, 'a\\b\'''cd' as f3, 'abcd\\' as f4, 'ab\\\'cd' as f5, '\\\\' as f6;
-
-reset standard_conforming_strings;
-
-
--
-- Additional string functions
--
--
SET search_path TO pg_catalog;
--- The LIKE pattern language requires underscores to be escaped, so make
--- sure the backslashes are not misinterpreted.
-SET standard_conforming_strings TO on;
-
--
-- lists the names of all database owners and the name of their database(s)
--
ORDER BY nspname, amname, opfname, oprname;
--
--- Reset the search path and standard_conforming_strings to their defaults
+-- Reset the search path to default
--
RESET search_path;
-RESET standard_conforming_strings;
projects / users / rhaas / postgres.git / commitdiff