-
+
Arrays
- As shown previously, when writing an array value you may write double
+ As shown previously, when writing an array value you can write double
quotes around any individual array element. You must do so
if the element value would otherwise confuse the array-value parser.
For example, elements containing curly braces, commas (or whatever the
delimiter character is), double quotes, backslashes, or leading or trailing
whitespace must be double-quoted. Empty strings and strings matching the
word NULL must be quoted, too. To put a double quote or
- backslash in a
- quoted array element value, precede it with a backslash. Alternatively, you
- can use backslash-escaping to protect all data characters that would
- otherwise be taken as array syntax.
+ backslash in a quoted array element value, use escape string syntax
+ and precede it with a backslash. Alternatively, you can use
+ backslash-escaping to protect all data characters that would otherwise
+ be taken as array syntax.
backslashes you need. For example, to insert a text array
value containing a backslash and a double quote, you'd need to write
-INSERT ... VALUES ('{"\\\\","\\""}');
+INSERT ... VALUES (E'{"\\\\","\\""}');
- The string-literal processor removes one level of backslashes, so that
+ The escape string processor removes one level of backslashes, so that
what arrives at the array-value parser looks like {"\\","\""}.
In turn, the strings fed to the text data type's input routine
become \ and " respectively. (If we were working
with a data type whose input routine also treated backslashes specially,
bytea for example, we might need as many as eight backslashes
in the command to get one backslash into the stored array element.)
- Dollar quoting (see ) may be
+ Dollar quoting (see ) can be
used to avoid the need to double backslashes.
-
+
Data Types
of a string literal in an
SQL statement. In
general, to escape an octet, it is converted into the three-digit
octal number equivalent of its decimal octet value, and preceded
- by two backslashes (or one backslash if
- standard_conforming_strings is off).
- shows the characters
- that must be escaped, and gives the alternate escape sequences
- where applicable.
+ by two backslashes.
+ shows the characters that must be escaped, and gives the alternate
+ escape sequences where applicable.
|
0
zero octet
- '\\000'
- SELECT '\\000'::bytea;
+ E'\\000'
+ SELECT E'\\000'::bytea;
\000
|
39
single quote
- '\'' or '\\047'
- SELECT '\''::bytea;
+ '''' or E'\\047'
+ SELECT E'\''::bytea;
'
|
92
backslash
- '\\\\' or '\\134'
- SELECT '\\\\'::bytea;
+ E'\\\\' or E'\\134'
+ SELECT E'\\\\'::bytea;
\\
|
0 to 31 and 127 to 255
non-printable
octets
- '\\xxx' (octal value)
- SELECT '\\001'::bytea;
+ E'\\xxx' (octal value)
+ SELECT E'\\001'::bytea;
\001
string written as a string literal must pass through two parse
phases in the
PostgreSQL server.
The first backslash of each pair is interpreted as an escape
- character by the string-literal parser (assuming
- standard_conforming_strings is off)
- and is therefore consumed, leaving the second backslash of the
- pair. The remaining backslash is then recognized by the
+ character by the string-literal parser (assuming escape string
+ syntax is used) and is therefore consumed, leaving the second backslash of the
+ pair. (Dollar-quoted strings can be used to avoid this level
+ of escaping.) The remaining backslash is then recognized by the
bytea input function as starting either a three
digit octal value or escaping another backslash. For example,
- a string literal passed to the server as '\\001'
+ a string literal passed to the server as E'\\001'
becomes \001 after passing through the
- string-literal parser. The \001 is then sent
+ escape string parser. The \001 is then sent
to the bytea input function, where it is converted
to a single octet with a decimal value of 1. Note that the
- apostrophe character is not treated specially by bytea,
+ single-quote character is not treated specially by bytea,
so it follows the normal rules for string literals. (See also
.)
92
backslash
\\
- SELECT '\\134'::bytea;
+ SELECT E'\\134'::bytea;
\\
0 to 31 and 127 to 255
non-printable
octets
\xxx (octal value)
- SELECT '\\001'::bytea;
+ SELECT E'\\001'::bytea;
\001
32 to 126
printable
octets
client character set representation
- SELECT '\\176'::bytea;
+ SELECT E'\\176'::bytea;
~
-
+
Functions and Operators
Encode binary data to
ASCII-only representation. Supported
types are: base64, hex, escape.
- encode( '123\\000\\001', 'base64')
+ encode( E'123\\000\\001', 'base64')
MTIzAAE=
Return the given string suitably quoted to be used as a string literal
in an
SQL statement string.
- Embedded quotes and backslashes are properly doubled.
+ Embedded single-quotes and backslashes are properly doubled.
quote_literal( 'O\'Reilly')
'O''Reilly'
concatenation
- '\\\\Post'::bytea || '\\047gres\\000'::bytea
+ E'\\\\Post'::bytea || E'\\047gres\\000'::bytea
\\Post'gres\000
- get_bit('Th\\000omas'::bytea, 45)
+ get_bit(E'Th\\000omas'::bytea, 45)
1
- get_byte('Th\\000omas'::bytea, 4)
+ get_byte(E'Th\\000omas'::bytea, 4)
109
int
Number of bytes in binary string
- octet_length( 'jo\\000se'::bytea)
+ octet_length( E'jo\\000se'::bytea)
5
position(substring in string)
int
Location of specified substring
- position('\\000om'::bytea in 'Th\\000omas'::bytea)
+ position(E'\\000om'::bytea in E'Th\\000omas'::bytea)
3
- set_bit('Th\\000omas'::bytea, 45, 0)
+ set_bit(E'Th\\000omas'::bytea, 45, 0)
Th\000omAs
- set_byte('Th\\000omas'::bytea, 4, 64)
+ set_byte(E'Th\\000omas'::bytea, 4, 64)
Th\000o@as
- substring('Th\\000omas'::bytea from 2 for 3)
+ substring(E'Th\\000omas'::bytea from 2 for 3)
h\000o
- trim('\\000'::bytea from '\\000Tom\\000'::bytea)
+ trim(E'\\000'::bytea from E'\\000Tom\\000'::bytea)
Tom
in
bytes from the start and end of
- btrim('\\000trim\\000'::bytea, '\\000'::bytea)
+ btrim(E'\\000trim\\000'::bytea, E'\\000'::bytea)
trim
Decode binary string from
string previously
encoded with encode. Parameter type is same as in encode.
- decode('123\\000456', 'escape')
+ decode(E'123\\000456', 'escape')
123\000456
Encode binary string to
ASCII-only representation. Supported
types are: base64, hex, escape.
- encode('123\\000456'::bytea, 'escape')
+ encode(E'123\\000456'::bytea, 'escape')
123\000456
binary strings, length
- length('jo\\000se'::bytea)
+ length(E'jo\\000se'::bytea)
5
Calculates the MD5 hash of
string,
returning the result in hexadecimal
- md5('Th\\000omas'::bytea)
+ md5(E'Th\\000omas'::bytea)
8ab2d3c9689aaf18 b4958c334c82d8b1
Note that the backslash already has a special meaning in string
literals, so to write a pattern constant that contains a backslash
- you must write two backslashes in an SQL statement. Thus, writing a pattern
+ you must write two backslashes in an SQL statement (assuming escape
+ string syntax is used). Thus, writing a pattern
that actually matches a literal backslash means writing four backslashes
in the statement. You can avoid this by selecting a different escape
character with ESCAPE; then a backslash is not special
substring matching the entire pattern should be inserted. Write
\\ if you need to put a literal backslash in the replacement
text. (As always, remember to double backslashes written in literal
- constant strings.)
+ constant strings, assuming escape string syntax is used.)
The flags parameter is an optional text
string containing zero or more single-letter flags that change the
function's behavior. Flag i specifies case-insensitive
fooXbaz
regexp_replace('foobarbaz', 'b..', 'X', 'g')
fooXX
-regexp_replace('foobarbaz', 'b(..)', 'X\\1Y', 'g')
+regexp_replace('foobarbaz', 'b(..)', E'X\\1Y', 'g')
fooXarYXazY
Remember that the backslash (\) already has a special
meaning in
PostgreSQL string literals. To write a pattern constant that contains a backslash,
- you must write two backslashes in the statement.
+ you must write two backslashes in the statement, assuming escape
+ string syntax is used.
Keep in mind that an escape's leading \ will need to be
doubled when entering the pattern as an SQL string constant. For example:
-'123' ~ '^\\d{3}' true
+'123' ~ E'^\\d{3}' true
If you want to have a double quote in the output you must
- precede it with a backslash, for example '\\"YYYY
+ precede it with a backslash, for example E'\\"YYYY
Month\\"'.
(Two backslashes are necessary because the backslash already
- has a special meaning in a string constant.)
+ has a special meaning when using the escape string syntax.)
-
+
<application>libpq</application> - C Library
If no value for standard_conforming_strings is reported,
-applications may assume it is false, that is, backslashes
+applications may assume it is off, that is, backslashes
are treated as escapes in string literals. Also, the presence of this
parameter may be taken as an indication that the escape string syntax
(E'...') is accepted.
of a
bytea literal in an
SQL statement. In general, to escape a byte, it is converted into the
three digit octal number equal to the octet value, and preceded by
- one or two backslashes. The single quote (') and backslash
+ usually two backslashes. The single quote (') and backslash
(\) characters have special alternative escape
sequences. See for more
information. PQescapeByteaConn performs this
-
+
PL/Perl - Perl Procedural Language
the function body to be written as a string constant. It is usually
most convenient to use dollar quoting (see
linkend="sql-syntax-dollar-quoting">) for the string constant.
- If you choose to use regular single-quoted string constant syntax,
- you must escape single quote marks (') and backslashes
- (\) used in the body of the function, typically by
- doubling them (see ).
+ If you choose to use escape string syntax E'',
+ you must double the single quote marks (') and backslashes
+ (\) used in the body of the function
+ (see ).
-
+
<application>PL/pgSQL</application> - <acronym>SQL</acronym> Procedural Language
CREATE FUNCTION as a string literal. If you
write the string literal in the ordinary way with surrounding
single quotes, then any single quotes inside the function body
- must be doubled; likewise any backslashes must be doubled.
+ must be doubled; likewise any backslashes must be doubled (assuming
+ escape string syntax is used).
Doubling quotes is at best tedious, and in more complicated cases
the code can become downright incomprehensible, because you can
easily find yourself needing half a dozen or more adjacent quote marks.
- A variant approach is to escape quotation marks in the function body
- with a backslash rather than by doubling them. With this method
- you'll find yourself writing things like \'\' instead
- of ''''. Some find this easier to keep track of, some
- do not.
-
-
+
PL/Tcl - Tcl Procedural Language
$$ LANGUAGE pltcl;
- We need backslashes inside the query string given to
- spi_prepare to ensure that the
- $n markers will be passed
- through to spi_prepare as-is, and not replaced by Tcl
- variable substitution.
+ We need backslashes inside the query string given to
+ spi_prepare to ensure that the
+ $n markers will be passed
+ through to spi_prepare as-is, and not replaced by Tcl
+ variable substitution.
-
+
Composite Types
Remember that what you write in an SQL command will first be interpreted
as a string literal, and then as a composite. This doubles the number of
- backslashes you need. For example, to insert a text field
+ backslashes you need (assuming escape string syntax is used).
+ For example, to insert a text field
containing a double quote and a backslash in a composite
value, you'd need to write
-INSERT ... VALUES ('("\\"\\\\")');
+INSERT ... VALUES (E'("\\"\\\\")');
The string-literal processor removes one level of backslashes, so that
what arrives at the composite-value parser looks like
-
+
User-Defined Functions
most convenient to use dollar quoting (see
linkend="sql-syntax-dollar-quoting">) for the string constant.
If you choose to use regular single-quoted string constant syntax,
- you must escape single quote marks (') and backslashes
- (\) used in the body of the function, typically by
- doubling them (see ).
+ you must double single quote marks (') and backslashes
+ (\) (assuming escape string syntax) in the body of
+ the function (see ).
projects / postgresql.git / commitdiff