SQL92 allows expressions to transform data in tables. Expressions may contain operators (see Operators for more details) and functions (Functions has more information).
An expression is one of the following:
| ( a_expr ) |
| constant |
| attribute |
| a_expr binary_operator a_expr |
| a_expr right_unary_operator |
| left_unary_operator a_expr |
| parameter |
| functional expression |
| aggregate expression |
We have already discussed constants and attributes. 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.
A parameter is used to indicate a parameter in a SQL function. Typically this is used in SQL function definition statement. The form of a parameter is:
$number
For example, consider the definition of a function, dept, as
CREATE FUNCTION dept (name)
RETURNS dept
AS 'select * from
dept where name=$1'
LANGUAGE 'sql';
A functional expression is the name of a legal SQL function, followed by its argument list enclosed in parentheses:
function (a_expr [, a_expr ... ] )
For example, the following computes the square root of an employee salary:
sqrt(emp.salary)
An aggregate expression 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:
| aggregate_name (expression) |
| aggregate_name (ALL expression) |
| aggregate_name (DISTINCT expression) |
| aggregate_name ( * ) |
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.
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.
A target list is a parenthesized, comma-separated list of one or more elements, each of which must be of the form:
a_expr [ AS result_attname ]
where result_attname
is the name of the attribute to be created (or an
already existing attribute name in the case of update statements.) If
result_attname
is not present, then
a_expr
must contain only one attribute name which is assumed to be the name
of the result field. In Postgres
default naming is only used if
a_expr
is an attribute.
A qualification consists of any number of clauses connected by the logical operators:
| NOT |
| AND |
| OR |
The from list is a comma-separated list of from expressions. Each "from expression" is of the form:
[ class_reference ] instance_variable
{, [ class_ref ] instance_variable... }
where class_reference
is of the form
class_name [ * ]
The "from expression"
defines one or more instance variables to range over the class
indicated in class_reference.
One can also request
the instance variable to range over all classes that are beneath the
indicated class in the inheritance hierarchy by postpending the
designator asterisk ("*").