mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-08-22 15:13:24 +02:00
1090 lines
34 KiB
Plaintext
1090 lines
34 KiB
Plaintext
<!--
|
|
$Header: /cvsroot/pgsql/doc/src/sgml/syntax.sgml,v 1.28 2000/12/17 05:47:57 tgl Exp $
|
|
-->
|
|
|
|
<chapter id="syntax">
|
|
<title>SQL Syntax</title>
|
|
|
|
<abstract>
|
|
<para>
|
|
A description of the general syntax of SQL.
|
|
</para>
|
|
</abstract>
|
|
|
|
<para>
|
|
<acronym>SQL</acronym> manipulates sets of data. The language is
|
|
composed of various <firstterm>key words</firstterm>. Arithmetic
|
|
and procedural expressions are allowed. We will cover these topics
|
|
in this chapter; subsequent chapters will include details on data
|
|
types, functions, and operators.
|
|
</para>
|
|
|
|
<sect1 id="sql-keywords">
|
|
<title>Key Words</title>
|
|
|
|
<para>
|
|
<acronym>SQL92</acronym> defines <firstterm>key words</firstterm>
|
|
for the language
|
|
which have specific meaning. Some key words are
|
|
<firstterm>reserved</firstterm>, which indicates that they are
|
|
restricted to appear in only certain contexts. Other key words are
|
|
<firstterm>not restricted</firstterm>, which indicates that in certain
|
|
contexts they
|
|
have a specific meaning but are not otherwise constrained.
|
|
</para>
|
|
|
|
<para>
|
|
<productname>Postgres</productname> implements an extended subset of the
|
|
<acronym>SQL92</acronym> and <acronym>SQL3</acronym> languages. Some language
|
|
elements are not as restricted in this implementation as is
|
|
called for in the language standards, in part due
|
|
to the extensibility features of <productname>Postgres</productname>.
|
|
</para>
|
|
|
|
<para>
|
|
Information on <acronym>SQL92</acronym> and <acronym>SQL3</acronym> key words
|
|
is derived from <xref linkend="DATE97" endterm="DATE97">.
|
|
</para>
|
|
|
|
<sect2>
|
|
<title>Reserved Key Words</title>
|
|
|
|
<para>
|
|
<acronym>SQL92</acronym> and <acronym>SQL3</acronym> have
|
|
<firstterm>reserved key words</firstterm> which are not allowed
|
|
as identifiers and not allowed in any usage other than as fundamental
|
|
tokens in <acronym>SQL</acronym> statements.
|
|
<productname>Postgres</productname> has additional key words
|
|
which have similar restrictions. In particular, these key words
|
|
are not allowed as column or table names, though in some cases
|
|
they are allowed to be column labels (i.e. in AS clauses).
|
|
</para>
|
|
|
|
<tip>
|
|
<para>
|
|
Any string can be used as an identifier if surrounded by
|
|
double quotes (<quote>like this!</quote>). Some care is required since
|
|
such an identifier will be case sensitive
|
|
and will retain embedded whitespace and most other special characters.
|
|
</para>
|
|
</tip>
|
|
|
|
<para>
|
|
The following are <productname>Postgres</productname>
|
|
reserved words which are neither <acronym>SQL92</acronym>
|
|
nor <acronym>SQL3</acronym> reserved words. These are allowed
|
|
to be present as column labels, but not as identifiers:
|
|
|
|
<programlisting>
|
|
ABORT ANALYZE
|
|
BINARY
|
|
CLUSTER CONSTRAINT COPY
|
|
DO
|
|
EXPLAIN EXTEND
|
|
LISTEN LOAD LOCK
|
|
MOVE
|
|
NEW NONE NOTIFY
|
|
OFFSET
|
|
RESET
|
|
SETOF SHOW
|
|
UNLISTEN UNTIL
|
|
VACUUM VERBOSE
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are <productname>Postgres</productname>
|
|
reserved words which are also <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> reserved words, and which
|
|
are allowed to be present as column labels, but not as identifiers:
|
|
|
|
<programlisting>
|
|
ALL ANY ASC BETWEEN BIT BOTH
|
|
CASE CAST CHAR CHARACTER CHECK COALESCE COLLATE COLUMN
|
|
CONSTRAINT CROSS CURRENT CURRENT_DATE CURRENT_TIME
|
|
CURRENT_TIMESTAMP CURRENT_USER
|
|
DEC DECIMAL DEFAULT DESC DISTINCT
|
|
ELSE END EXCEPT EXISTS EXTRACT
|
|
FALSE FLOAT FOR FOREIGN FROM FULL
|
|
GLOBAL GROUP
|
|
HAVING
|
|
IN INNER INTERSECT INTO IS
|
|
JOIN
|
|
LEADING LEFT LIKE LOCAL
|
|
NATURAL NCHAR NOT NULL NULLIF NUMERIC
|
|
ON OR ORDER OUTER OVERLAPS
|
|
POSITION PRECISION PRIMARY PUBLIC
|
|
REFERENCES RIGHT
|
|
SELECT SESSION_USER SOME SUBSTRING
|
|
TABLE THEN TO TRANSACTION TRIM TRUE
|
|
UNION UNIQUE USER
|
|
VARCHAR
|
|
WHEN WHERE
|
|
</programlisting>
|
|
|
|
The following are <productname>Postgres</productname>
|
|
reserved words which are also <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> reserved words:
|
|
|
|
<programlisting>
|
|
ADD ALTER AND AS
|
|
BEGIN BY
|
|
CASCADE CLOSE COMMIT CREATE CURSOR
|
|
DECLARE DEFAULT DELETE DESC DISTINCT DROP
|
|
EXECUTE EXISTS EXTRACT
|
|
FETCH FLOAT FOR FROM FULL
|
|
GRANT
|
|
HAVING
|
|
IN INNER INSERT INTERVAL INTO INOUT IS
|
|
JOIN
|
|
LEADING LEFT LIKE LOCAL
|
|
NAMES NATIONAL NATURAL NCHAR NO NOT NULL
|
|
ON OR OUT OUTER
|
|
PARTIAL PRIMARY PRIVILEGES PROCEDURE PUBLIC
|
|
REFERENCES REVOKE RIGHT ROLLBACK
|
|
SELECT SESSION SET SUBSTRING
|
|
TO TRAILING TRIM
|
|
UNION UNIQUE UPDATE USING
|
|
VALUES VARCHAR VARYING VIEW
|
|
WHERE WITH WITHOUT WORK
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are <acronym>SQL92</acronym> reserved key words which
|
|
are not <productname>Postgres</productname> reserved key words, but which
|
|
if used as function names are always translated into the function
|
|
<function>CHAR_LENGTH</function>:
|
|
|
|
<programlisting>
|
|
CHARACTER_LENGTH
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are <acronym>SQL92</acronym> or <acronym>SQL3</acronym>
|
|
reserved key words which
|
|
are not <productname>Postgres</productname> reserved key words, but
|
|
if used as type names are always translated into an alternate, native type:
|
|
|
|
<programlisting>
|
|
BOOLEAN DOUBLE FLOAT INT INTEGER INTERVAL REAL SMALLINT
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are not keywords of any kind, but when used in the
|
|
context of a type name are translated into a native
|
|
<productname>Postgres</productname> type, and when used in the
|
|
context of a function name are translated into a native function:
|
|
|
|
<programlisting>
|
|
DATETIME TIMESPAN
|
|
</programlisting>
|
|
|
|
(translated to <type>TIMESTAMP</type> and <type>INTERVAL</type>,
|
|
respectively). This feature is intended to help with
|
|
transitioning to v7.0, and will be removed in the next full
|
|
release (likely v7.1).
|
|
</para>
|
|
|
|
<para>
|
|
The following are either <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> reserved key words
|
|
which are not key words in <productname>Postgres</productname>.
|
|
These have no proscribed usage in <productname>Postgres</productname>
|
|
at the time of writing (v7.0) but may become reserved key words in the
|
|
future:
|
|
|
|
<note>
|
|
<para>
|
|
Some of these key words represent functions in <acronym>SQL92</acronym>.
|
|
These functions are defined in <productname>Postgres</productname>,
|
|
but the parser does not consider the names to be key words and they are allowed
|
|
in other contexts.
|
|
</para>
|
|
</note>
|
|
|
|
<programlisting>
|
|
ALLOCATE ARE ASSERTION AT AUTHORIZATION AVG
|
|
BIT_LENGTH
|
|
CASCADED CATALOG CHAR_LENGTH CHARACTER_LENGTH COLLATION
|
|
CONNECT CONNECTION CONTINUE CONVERT CORRESPONDING COUNT
|
|
CURRENT_SESSION
|
|
DATE DEALLOCATE DEC DESCRIBE DESCRIPTOR
|
|
DIAGNOSTICS DISCONNECT DOMAIN
|
|
ESCAPE EXCEPT EXCEPTION EXEC EXTERNAL
|
|
FIRST FOUND
|
|
GET GO GOTO
|
|
IDENTITY INDICATOR INPUT INTERSECT
|
|
LAST LOWER
|
|
MAX MIN MODULE
|
|
OCTET_LENGTH OPEN OUTPUT OVERLAPS
|
|
PREPARE PRESERVE
|
|
ROWS
|
|
SCHEMA SECTION SESSION SIZE SOME
|
|
SQL SQLCODE SQLERROR SQLSTATE SUM SYSTEM_USER
|
|
TEMPORARY TRANSLATE TRANSLATION
|
|
UNKNOWN UPPER USAGE
|
|
VALUE
|
|
WHENEVER WRITE
|
|
</programlisting>
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Non-reserved Keywords</title>
|
|
|
|
<para>
|
|
<acronym>SQL92</acronym> and <acronym>SQL3</acronym> have
|
|
<firstterm>non-reserved keywords</firstterm> which have
|
|
a prescribed meaning in the language but which are also allowed
|
|
as identifiers.
|
|
<productname>Postgres</productname> has additional keywords
|
|
which allow similar unrestricted usage.
|
|
In particular, these keywords
|
|
are allowed as column or table names.
|
|
</para>
|
|
|
|
<para>
|
|
The following are <productname>Postgres</productname>
|
|
non-reserved key words which are neither <acronym>SQL92</acronym>
|
|
nor <acronym>SQL3</acronym> non-reserved key words:
|
|
|
|
<programlisting>
|
|
ACCESS AFTER AGGREGATE
|
|
BACKWARD BEFORE
|
|
CACHE COMMENT CREATEDB CREATEUSER CYCLE
|
|
DATABASE DELIMITERS
|
|
EACH ENCODING EXCLUSIVE
|
|
FORCE FORWARD FUNCTION
|
|
HANDLER
|
|
INCREMENT INDEX INHERITS INSENSITIVE INSTEAD ISNULL
|
|
LANCOMPILER LOCATION
|
|
MAXVALUE MINVALUE MODE
|
|
NOCREATEDB NOCREATEUSER NOTHING NOTIFY NOTNULL
|
|
OIDS OPERATOR
|
|
PASSWORD PROCEDURAL
|
|
RECIPE REINDEX RENAME RETURNS ROW RULE
|
|
SEQUENCE SERIAL SHARE START STATEMENT STDIN STDOUT
|
|
TEMP TRUSTED
|
|
UNLISTEN UNTIL
|
|
VALID VERSION
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are <productname>Postgres</productname>
|
|
non-reserved key words which are <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> reserved key words:
|
|
|
|
<programlisting>
|
|
ABSOLUTE ACTION
|
|
CHARACTERISTICS CONSTRAINTS
|
|
DAY DEFERRABLE DEFERRED
|
|
HOUR
|
|
IMMEDIATE INITIALLY INSENSITIVE ISOLATION
|
|
KEY
|
|
LANGUAGE LEVEL
|
|
MATCH MINUTE MONTH
|
|
NEXT
|
|
OF ONLY OPTION
|
|
PATH PENDANT PRIOR PRIVILEGES
|
|
READ RELATIVE RESTRICT
|
|
SCHEMA SCROLL SECOND
|
|
TIME TIMESTAMP TIMEZONE_HOUR TIMEZONE_MINUTE TRIGGER
|
|
YEAR
|
|
ZONE
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are <productname>Postgres</productname>
|
|
non-reserved key words which are also either <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> non-reserved key words:
|
|
|
|
<programlisting>
|
|
COMMITTED SERIALIZABLE TYPE
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
The following are either <acronym>SQL92</acronym>
|
|
or <acronym>SQL3</acronym> non-reserved key words which are not
|
|
key words of any kind in <productname>Postgres</productname>:
|
|
|
|
<programlisting>
|
|
ADA
|
|
C CATALOG_NAME CHARACTER_SET_CATALOG CHARACTER_SET_NAME
|
|
CHARACTER_SET_SCHEMA CLASS_ORIGIN COBOL COLLATION_CATALOG
|
|
COLLATION_NAME COLLATION_SCHEMA COLUMN_NAME
|
|
COMMAND_FUNCTION CONDITION_NUMBER
|
|
CONNECTION_NAME CONSTRAINT_CATALOG CONSTRAINT_NAME
|
|
CONSTRAINT_SCHEMA CURSOR_NAME
|
|
DATA DATE_TIME_INTERVAL_CODE DATE_TIME_INTERVAL_PRECISION
|
|
DYNAMIC_FUNCTION
|
|
FORTRAN
|
|
LENGTH
|
|
MESSAGE_LENGTH MESSAGE_OCTET_LENGTH MORE MUMPS
|
|
NAME NULLABLE NUMBER
|
|
PAD PASCAL PLI
|
|
REPEATABLE RETURNED_LENGTH RETURNED_OCTET_LENGTH
|
|
RETURNED_SQLSTATE ROW_COUNT
|
|
SCALE SCHEMA_NAME SERVER_NAME SPACE SUBCLASS_ORIGIN
|
|
TABLE_NAME
|
|
UNCOMMITTED UNNAMED
|
|
</programlisting>
|
|
</para>
|
|
</sect2>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-comments">
|
|
<title>Comments</title>
|
|
|
|
<para>
|
|
A <firstterm>comment</firstterm>
|
|
is an arbitrary sequence of characters beginning with double dashes
|
|
and extending to the end of the line, e.g.:
|
|
|
|
<programlisting>
|
|
-- This is a standard SQL comment
|
|
</programlisting>
|
|
</para>
|
|
|
|
<para>
|
|
We also support C-style block comments, e.g.:
|
|
|
|
<programlisting>
|
|
/* multi-line comment
|
|
* with nesting: /* nested block comment */
|
|
*/
|
|
</programlisting>
|
|
|
|
where the comment begins with "<literal>/*</literal>" and extends
|
|
to the matching occurrence of "<literal>*/</literal>". These block
|
|
comments nest, as specified in SQL99, so that one can comment out
|
|
larger blocks of code which may contain existing block comments.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-names">
|
|
<title>Names</title>
|
|
|
|
<para>
|
|
Names in SQL must begin with a letter
|
|
(<literal>a</literal>-<literal>z</literal>) or underscore
|
|
(<literal>_</literal>).
|
|
Subsequent characters in a name can be letters, digits
|
|
(<literal>0</literal>-<literal>9</literal>),
|
|
or underscores. The system uses no more than NAMEDATALEN-1 characters
|
|
of a name; longer names can be written in queries, but they will be
|
|
truncated.
|
|
By default, NAMEDATALEN is 32 so the maximum name length is 31 (but
|
|
at the time the system is built, NAMEDATALEN can be changed in
|
|
<filename>src/include/postgres_ext.h</filename>).
|
|
</para>
|
|
|
|
<para>
|
|
Names containing other characters may be formed by surrounding them
|
|
with double quotes (<literal>"</literal>). For example, table or column
|
|
names may contain
|
|
otherwise disallowed characters such as spaces, ampersands, etc. if
|
|
quoted. Quoting a name also makes it case-sensitive,
|
|
whereas unquoted names are always folded to lower case. For example,
|
|
the names <literal>FOO</literal>, <literal>foo</literal>
|
|
and <literal>"foo"</literal> are
|
|
considered the same by <productname>Postgres</productname>, but
|
|
<literal>"Foo"</literal> is a different name.
|
|
</para>
|
|
|
|
<para>
|
|
Double quotes can also be used to protect a name that would otherwise
|
|
be taken to be an SQL keyword. For example, <literal>IN</literal>
|
|
is a keyword but <literal>"IN"</literal> is a name.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-constants">
|
|
<title>Constants</title>
|
|
|
|
<para>
|
|
There are three kinds of <firstterm>implicitly typed constants</firstterm>
|
|
in <productname>Postgres</productname>: strings, integers,
|
|
and floating point numbers. Constants can
|
|
also be specified with explicit types, which can enable more
|
|
accurate representation and more efficient handling by the
|
|
backend. The implicit constants are described below; explicit
|
|
constants are discussed afterwards.
|
|
</para>
|
|
|
|
<sect2>
|
|
<title>String Constants</title>
|
|
|
|
<para>
|
|
<firstterm>Strings</firstterm>
|
|
in SQL are arbitrary sequences of ASCII characters bounded by single
|
|
quotes ("'", e.g. <literal>'This is a string'</literal>).
|
|
SQL92 allows single quotes to be embedded in strings by typing two
|
|
adjacent single quotes (e.g. <literal>'Dianne''s horse'</literal>).
|
|
In <productname>Postgres</productname> single quotes may alternatively
|
|
be escaped with a backslash ("\", e.g.
|
|
<literal>'Dianne\'s horse'</literal>). To include a
|
|
backslash in a string constant, type two backslashes.
|
|
Non-printing characters may also be embedded within strings by
|
|
prepending them with a backslash
|
|
(e.g. <literal>'\<replaceable>tab</replaceable>'</literal>).
|
|
</para>
|
|
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Integer Constants</title>
|
|
|
|
<para>
|
|
<firstterm>Integer constants</firstterm>
|
|
in SQL are sequences of ASCII digits with no decimal point.
|
|
The range of legal values depends on which integer datatype is
|
|
used, but the plain <literal>integer</literal> type accepts values
|
|
ranging from -2147483648 to +2147483647.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Floating Point Constants</title>
|
|
|
|
<para>
|
|
<firstterm>Floating point constants</firstterm>
|
|
consist of an integer part, a decimal point, and a fraction part or
|
|
scientific notation of the following format:
|
|
|
|
<synopsis>
|
|
{<replaceable>dig</replaceable>}.{<replaceable>dig</replaceable>} [e [+-] {<replaceable>dig</replaceable>}]
|
|
</synopsis>
|
|
|
|
where <replaceable>dig</replaceable> is one or more digits.
|
|
You must include at least one <replaceable>dig</replaceable> after the
|
|
period and after the [+-] if you use those options. An exponent with
|
|
a missing mantissa has a mantissa of 1 inserted. There may be no
|
|
extra characters embedded in the string.
|
|
</para>
|
|
|
|
<para>
|
|
Floating point constaints are of type
|
|
<type>float8</type>. <type>float4</type> can be specified
|
|
explicitly by using <acronym>SQL92</acronym> string notation or
|
|
<productname>Postgres</productname> type notation:
|
|
|
|
<programlisting>
|
|
float4 '1.23' -- string style
|
|
'1.23'::float4 -- Postgres (historical) style
|
|
</programlisting>
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Constants of Postgres User-Defined Types</title>
|
|
|
|
<para>
|
|
A constant of an
|
|
<emphasis>arbitrary</emphasis>
|
|
type can be entered using any one of the following notations:
|
|
|
|
<synopsis>
|
|
<replaceable>type</replaceable> '<replaceable>string</replaceable>'
|
|
'<replaceable>string</replaceable>'::<replaceable>type</replaceable>
|
|
CAST ( '<replaceable>string</replaceable>' AS <replaceable>type</replaceable> )
|
|
</synopsis>
|
|
|
|
The value inside the string is passed to the input
|
|
conversion routine for the type called
|
|
<replaceable>type</replaceable>. The result is a
|
|
constant of the indicated type. The explicit typecast may be omitted
|
|
if there is no ambiguity as to the type the constant must be, in which
|
|
case it is automatically coerced.
|
|
</para>
|
|
|
|
<para>
|
|
It is also possible to specify a type coercion using a function-like
|
|
syntax:
|
|
|
|
<synopsis>
|
|
<replaceable>typename</replaceable> ( <replaceable>value</replaceable> )
|
|
</synopsis>
|
|
|
|
although this only works for types whose names are also valid as
|
|
function names. (For example, <literal>double precision</literal>
|
|
can't be used this way --- but the equivalent <literal>float8</literal>
|
|
can.)
|
|
</para>
|
|
|
|
<para>
|
|
The <literal>::</literal>, <literal>CAST()</literal>, and function-call
|
|
syntaxes can also be used to specify run-time type conversions. But
|
|
the form <replaceable>type</replaceable>
|
|
'<replaceable>string</replaceable>' can only be used to specify the
|
|
type of a literal constant.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Array constants</title>
|
|
|
|
<para>
|
|
<firstterm>Array constants</firstterm>
|
|
are n-dimensional arrays of any Postgres datatype.
|
|
The general format of an array constant is the following:
|
|
|
|
<synopsis>
|
|
{ <replaceable>val1</replaceable> <replaceable>delim</replaceable> <replaceable>val2</replaceable> <replaceable>delim</replaceable> ... }
|
|
</synopsis>
|
|
|
|
where <replaceable>delim</replaceable>
|
|
is the delimiter character for the type, as recorded in its
|
|
<literal>pg_type</literal> class entry.
|
|
(For all built-in types, this is the comma character ",".)
|
|
Each <replaceable>val</replaceable> is either a constant
|
|
of the array element type, or a sub-array.
|
|
An example of an array constant is
|
|
|
|
<programlisting>
|
|
{{1,2,3},{4,5,6},{7,8,9}}
|
|
</programlisting>
|
|
|
|
This constant is a two-dimensional, 3 by 3 array consisting of three
|
|
sub-arrays of integers.
|
|
</para>
|
|
|
|
<para>
|
|
Individual array elements can be placed between single-quote
|
|
marks to avoid ambiguity problems with respect to leading white space.
|
|
Without quote marks, the array-value parser will skip white space.
|
|
Note that to write a quote mark inside a string literal that is to
|
|
become an array value, you must double the quote mark as described
|
|
previously.
|
|
</para>
|
|
</sect2>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-columns">
|
|
<title>Fields and Columns</title>
|
|
|
|
<sect2>
|
|
<title>Fields</title>
|
|
|
|
<para>
|
|
A <firstterm>field</firstterm>
|
|
is either a user-defined attribute of a given class or one of the
|
|
following system-defined attributes:
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>oid</term>
|
|
<listitem>
|
|
<para>
|
|
stands for the unique identifier of an instance which is added by
|
|
Postgres to all instances automatically. OIDs are not reused and are
|
|
32-bit quantities.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
|
|
<varlistentry>
|
|
<term>xmin</term>
|
|
<listitem>
|
|
<para>
|
|
The identity of the inserting transaction.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
|
|
<varlistentry>
|
|
<term>xmax</term>
|
|
<listitem>
|
|
<para>
|
|
The identity of the deleting transaction.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
|
|
<varlistentry>
|
|
<term>cmin</term>
|
|
<listitem>
|
|
<para>
|
|
The command identifier within the inserting transaction.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
|
|
<varlistentry>
|
|
<term>cmax</term>
|
|
<listitem>
|
|
<para>
|
|
The command identifier within the deleting transaction.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</para>
|
|
|
|
<para>
|
|
For further information on the system attributes consult
|
|
<xref linkend="STON87a" endterm="STON87a">.
|
|
Transaction and command identifiers are 32 bit quantities.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Columns</title>
|
|
|
|
<para>
|
|
A <firstterm>column</firstterm> is a construct of the form:
|
|
|
|
<synopsis>
|
|
<replaceable>instance</replaceable>{.<replaceable>composite_field</replaceable>}.<replaceable>field</replaceable> `['<replaceable>subscript</replaceable>`]'
|
|
</synopsis>
|
|
|
|
<replaceable>instance</replaceable>
|
|
identifies a particular class and can be thought of as standing for
|
|
the instances of that class. An instance variable is either a class
|
|
name, an alias for a class defined by means of a FROM clause,
|
|
or the keyword NEW or OLD.
|
|
(NEW and OLD can only appear in the action portion of a rule, while
|
|
other instance variables can be used in any SQL statement.) The
|
|
instance name can be omitted if the first field name is unique
|
|
across all the classes being used in the current query.
|
|
<replaceable>composite_field</replaceable>
|
|
is a field of of one of the Postgres composite types,
|
|
while successive composite fields select attributes in the
|
|
class(s) to which the composite field evaluates. Lastly,
|
|
<replaceable>field</replaceable>
|
|
is a normal (base type) field in the class(s) last addressed. If
|
|
<replaceable>field</replaceable>
|
|
is of an array type,
|
|
then the optional <replaceable>subscript</replaceable>
|
|
selects a specific element in the array. If no subscript is
|
|
provided, then the whole array is selected.
|
|
</para>
|
|
</sect2>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-operators">
|
|
<title>Operators</title>
|
|
|
|
<para>
|
|
Any built-in or user-defined operator may be used in SQL.
|
|
For the list of built-in operators consult <xref linkend="functions">.
|
|
For a list of user-defined operators consult your system administrator
|
|
or run a query on the <literal>pg_operator</literal> class.
|
|
Parentheses may be used for arbitrary grouping of operators in expressions.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="sql-expressions">
|
|
<title>Expressions</title>
|
|
|
|
<para>
|
|
<acronym>SQL92</acronym> allows <firstterm>expressions</firstterm>
|
|
to transform data in tables. Expressions may contain operators
|
|
and functions.
|
|
</para>
|
|
|
|
<para>
|
|
An expression is one of the following:
|
|
|
|
<simplelist>
|
|
<member>constant</member>
|
|
<member>column</member>
|
|
<member><replaceable>expression</replaceable> <replaceable>binary_operator</replaceable> <replaceable>expression</replaceable></member>
|
|
<member><replaceable>expression</replaceable> <replaceable>right_unary_operator</replaceable></member>
|
|
<member><replaceable>left_unary_operator</replaceable> <replaceable>expression</replaceable></member>
|
|
<member>( <replaceable>expression</replaceable> )</member>
|
|
<member>parameter</member>
|
|
<member>functional expression</member>
|
|
<member>aggregate expression</member>
|
|
</simplelist>
|
|
</para>
|
|
|
|
<para>
|
|
We have already discussed constants and columns. The three kinds of
|
|
operator expressions indicate respectively binary (infix), right-unary
|
|
(suffix) and left-unary (prefix) operators. The following sections
|
|
discuss the remaining options.
|
|
</para>
|
|
|
|
<sect2>
|
|
<title>Parameters</title>
|
|
|
|
<para>
|
|
A <firstterm>parameter</firstterm>
|
|
is used to indicate a parameter in a SQL function. Typically this
|
|
is used in SQL function definition statements. The form of a
|
|
parameter is:
|
|
|
|
<synopsis>
|
|
$<replaceable class="parameter">number</replaceable>
|
|
</synopsis>
|
|
</para>
|
|
|
|
<para>
|
|
For example, consider the definition of a function,
|
|
<function>dept</function>, as
|
|
|
|
<programlisting>
|
|
CREATE FUNCTION dept (name)
|
|
RETURNS dept
|
|
AS 'select * from dept where name = $1'
|
|
LANGUAGE 'sql';
|
|
</programlisting>
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Functional Expressions</title>
|
|
|
|
<para>
|
|
A <firstterm>functional expression</firstterm>
|
|
is the name of a legal SQL function, followed by its argument list
|
|
enclosed in parentheses:
|
|
|
|
<synopsis>
|
|
<replaceable>function</replaceable> (<replaceable>expression</replaceable> [, <replaceable>expression</replaceable> ... ] )
|
|
</synopsis>
|
|
</para>
|
|
|
|
<para>
|
|
For example, the following computes the square root of an employee
|
|
salary:
|
|
|
|
<programlisting>
|
|
sqrt(emp.salary)
|
|
</programlisting>
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2 id="syntax-aggregates">
|
|
<title>Aggregate Expressions</title>
|
|
|
|
<para>
|
|
An <firstterm>aggregate expression</firstterm> represents the application
|
|
of an aggregate function across the rows selected by a query.
|
|
An aggregate function reduces multiple inputs to a single output value,
|
|
such as the sum or average of the inputs.
|
|
The syntax of an aggregate expression is one of the following:
|
|
|
|
<simplelist>
|
|
<member><replaceable>aggregate_name</replaceable> (<replaceable>expression</replaceable>)</member>
|
|
<member><replaceable>aggregate_name</replaceable> (ALL <replaceable>expression</replaceable>)</member>
|
|
<member><replaceable>aggregate_name</replaceable> (DISTINCT <replaceable>expression</replaceable>)</member>
|
|
<member><replaceable>aggregate_name</replaceable> ( * )</member>
|
|
</simplelist>
|
|
|
|
where <replaceable>aggregate_name</replaceable> is a previously defined
|
|
aggregate, and <replaceable>expression</replaceable> is any expression
|
|
that doesn't itself contain an aggregate expression.
|
|
</para>
|
|
|
|
<para>
|
|
The first form of aggregate expression invokes the aggregate across all
|
|
input rows for which the given expression yields a non-null value.
|
|
The second form is the same as the first, since ALL is the default.
|
|
The third form invokes the aggregate for all distinct non-null values
|
|
of the expression found in the input rows. The last form invokes the
|
|
aggregate once for each input row regardless of null or non-null values;
|
|
since no particular input value is specified, it is generally only useful
|
|
for the count() aggregate.
|
|
</para>
|
|
|
|
<para>
|
|
For example, count(*) yields the total number of input rows;
|
|
count(f1) yields the number of input rows in which f1 is non-null;
|
|
count(distinct f1) yields the number of distinct non-null values of f1.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Target List</title>
|
|
|
|
<para>
|
|
A <firstterm>target list</firstterm>
|
|
is a comma-separated list of one or more elements, each
|
|
of which must be of the form:
|
|
|
|
<synopsis>
|
|
<replaceable>expression</replaceable> [ AS <replaceable>result_attname</replaceable> ]
|
|
</synopsis>
|
|
|
|
where <replaceable>result_attname</replaceable>
|
|
is the name to be assigned to the created column. If
|
|
<replaceable>result_attname</replaceable>
|
|
is not present, then <productname>Postgres</productname> selects a
|
|
default name based on the contents of <replaceable>expression</replaceable>.
|
|
If <replaceable>expression</replaceable> is a simple attribute reference
|
|
then the default name will be the same as that attribute's name, but
|
|
otherwise the implementation is free to assign any default name.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>Qualification</title>
|
|
|
|
<para>
|
|
A <firstterm>qualification</firstterm>
|
|
consists of any number of clauses connected by the logical operators:
|
|
|
|
<simplelist>
|
|
<member>NOT</member>
|
|
<member>AND</member>
|
|
<member>OR</member>
|
|
</simplelist>
|
|
|
|
A clause is an <replaceable>expression</replaceable>
|
|
that evaluates to a <literal>boolean</literal> over a set of instances.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2>
|
|
<title>From List</title>
|
|
|
|
<para>
|
|
The <firstterm>from list</firstterm>
|
|
is a comma-separated list of <firstterm>from-expressions</firstterm>.
|
|
The simplest possibility for a from-expression is:
|
|
|
|
<synopsis>
|
|
<replaceable>class_reference</replaceable> [ [ AS ] <replaceable class="PARAMETER">alias</replaceable> ]
|
|
</synopsis>
|
|
|
|
where <replaceable>class_reference</replaceable> is of the form
|
|
|
|
<synopsis>
|
|
[ ONLY ] <replaceable class="PARAMETER">table_name</replaceable> [ * ]
|
|
</synopsis>
|
|
|
|
The from-expression defines an instance variable that ranges over the
|
|
rows of the specified table. The instance variable's name is either
|
|
the table name, or the <replaceable>alias</replaceable> if one is given.
|
|
Ordinarily, if the table has child tables then the instance variable
|
|
will range over all rows in the inheritance hierarchy starting with
|
|
the specified table. If <literal>ONLY</literal> is specified then
|
|
child tables are not included. A trailing asterisk <literal>*</literal>
|
|
can be written to specifically indicate that child tables are included
|
|
(<literal>ONLY</literal> and <literal>*</literal> are mutually
|
|
exclusive).
|
|
</para>
|
|
|
|
<para>
|
|
A from-expression can also be a sub-query:
|
|
|
|
<synopsis>
|
|
( <replaceable class="PARAMETER">select-statement</replaceable> ) [ AS ] <replaceable class="PARAMETER">alias</replaceable>
|
|
</synopsis>
|
|
|
|
Here, the effect is as though the SELECT were executed and its results
|
|
stored in a temporary table, which then becomes available as an instance
|
|
variable under the given <replaceable>alias</replaceable>.
|
|
</para>
|
|
|
|
<para>
|
|
Finally, a from-expression can be built up from simpler from-expressions
|
|
using JOIN clauses:
|
|
|
|
<synopsis>
|
|
<replaceable class="PARAMETER">from_expression</replaceable> [ NATURAL ] <replaceable class="PARAMETER">join_type</replaceable> <replaceable class="PARAMETER">from_expression</replaceable>
|
|
[ ON <replaceable class="PARAMETER">join_condition</replaceable> | USING ( <replaceable class="PARAMETER">join_column_list</replaceable> ) ]
|
|
</synopsis>
|
|
|
|
This syntax allows specification of <firstterm>outer joins</firstterm>.
|
|
For details see the reference page for SELECT.
|
|
</para>
|
|
</sect2>
|
|
|
|
|
|
<sect2 id="sql-precedence">
|
|
<title>Lexical Precedence</title>
|
|
|
|
<para>
|
|
The precedence and associativity of the operators is hard-wired
|
|
into the parser. Most operators have the same precedence and are
|
|
left-associative. This may lead to non-intuitive behavior; for
|
|
example the boolean operators "<" and ">" have a different
|
|
precedence than the boolean operators "<=" and ">=". Also,
|
|
you will sometimes need to add parentheses when using combinations
|
|
of binary and unary operators. For instance
|
|
<programlisting>
|
|
SELECT 5 & ~ 6;
|
|
</programlisting>
|
|
will be parsed as
|
|
<programlisting>
|
|
SELECT (5 &) ~ 6;
|
|
</programlisting>
|
|
because the parser has no idea that <token>&</token> is
|
|
defined as a binary operator. This is the price one pays for
|
|
extensibility.
|
|
</para>
|
|
|
|
<table tocentry="1">
|
|
<title>Operator Ordering (decreasing precedence)</title>
|
|
|
|
<tgroup cols="2">
|
|
<thead>
|
|
<row>
|
|
<entry>OperatorElement</entry>
|
|
<entry>Associativity</entry>
|
|
<entry>Description</entry>
|
|
</row>
|
|
</thead>
|
|
|
|
<tbody>
|
|
<row>
|
|
<entry><token>::</token></entry>
|
|
<entry>left</entry>
|
|
<entry><productname>Postgres</productname>-style typecast</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>[</token> <token>]</token></entry>
|
|
<entry>left</entry>
|
|
<entry>array element selection</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>.</token></entry>
|
|
<entry>left</entry>
|
|
<entry>table/column name separator</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>-</token></entry>
|
|
<entry>right</entry>
|
|
<entry>unary minus</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>^</token></entry>
|
|
<entry>left</entry>
|
|
<entry>exponentiation</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>*</token> <token>/</token> <token>%</token></entry>
|
|
<entry>left</entry>
|
|
<entry>multiplication, division, modulo</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>+</token> <token>-</token></entry>
|
|
<entry>left</entry>
|
|
<entry>addition, subtraction</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>IS</token></entry>
|
|
<entry></entry>
|
|
<entry>test for TRUE, FALSE, NULL</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>ISNULL</token></entry>
|
|
<entry></entry>
|
|
<entry>test for NULL</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>NOTNULL</token></entry>
|
|
<entry></entry>
|
|
<entry>test for NOT NULL</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry>(any other)</entry>
|
|
<entry>left</entry>
|
|
<entry>all other native and user-defined operators</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>IN</token></entry>
|
|
<entry></entry>
|
|
<entry>set membership</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>BETWEEN</token></entry>
|
|
<entry></entry>
|
|
<entry>containment</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>OVERLAPS</token></entry>
|
|
<entry></entry>
|
|
<entry>time interval overlap</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>LIKE</token> <token>ILIKE</token></entry>
|
|
<entry></entry>
|
|
<entry>string pattern matching</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token><</token> <token>></token></entry>
|
|
<entry></entry>
|
|
<entry>less than, greater than</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>=</token></entry>
|
|
<entry>right</entry>
|
|
<entry>equality, assignment</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>NOT</token></entry>
|
|
<entry>right</entry>
|
|
<entry>logical negation</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>AND</token></entry>
|
|
<entry>left</entry>
|
|
<entry>logical conjunction</entry>
|
|
</row>
|
|
|
|
<row>
|
|
<entry><token>OR</token></entry>
|
|
<entry>left</entry>
|
|
<entry>logical disjunction</entry>
|
|
</row>
|
|
</tbody>
|
|
</tgroup>
|
|
</table>
|
|
|
|
<para>
|
|
Note that the operator precedence rules also apply to user-defined
|
|
operators that have the same names as the built-in operators
|
|
mentioned above. For example, if you define a
|
|
<quote>+</quote> operator for some custom data type it will have
|
|
the same precedence as the built-in <quote>+</quote> operator, no
|
|
matter what yours does.
|
|
</para>
|
|
</sect2>
|
|
|
|
</sect1>
|
|
</chapter>
|
|
|
|
<!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode:sgml
|
|
sgml-omittag:nil
|
|
sgml-shorttag:t
|
|
sgml-minimize-attributes:nil
|
|
sgml-always-quote-attributes:t
|
|
sgml-indent-step:1
|
|
sgml-indent-data:t
|
|
sgml-parent-document:nil
|
|
sgml-default-dtd-file:"./reference.ced"
|
|
sgml-exposed-tags:nil
|
|
sgml-local-catalogs:("/usr/lib/sgml/catalog")
|
|
sgml-local-ecat-files:nil
|
|
End:
|
|
-->
|