SELECT
Syntax
SELECT [ALL | DISTINCT | DISTINCTROW] [HIGH_PRIORITY] [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT] [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS] select_expr [, select_expr ...] [ INTO OUTFILE 'file_name' [export_options] | INTO DUMPFILE 'file_name' | INTO var_name [, var_name] ] [ FROM table_references [WHERE where_condition] [GROUP BY {col_name | expr | position} [ASC | DESC], ... [WITH ROLLUP]] [HAVING where_condition] [ORDER BY {col_name | expr | position} [ASC | DESC], ...] [LIMIT {[offset,] row_count | row_count OFFSET offset}] [PROCEDURE procedure_name(argument_list)] [FOR UPDATE | LOCK IN SHARE MODE] ]
Description
SELECT
is used to retrieve rows selected from one or more
tables, and can include UNION
statements and subqueries. See
UNION, and http://dev.mysql.com/doc/refman/5.1/en/subqueries.html.
- Each select_expr expression indicates a column or data that you want to retrieve. You must have at least one select expression. See Select Expressions below.
- The
FROM
clause indicates the table or tables from which to retrieve rows. Use either a single table name or aJOIN
expression. SeeJOIN
for details.
- The
WHERE
clause, if given, indicates the condition or conditions that rows must satisfy to be selected.where_condition
is an expression that evaluates to true for each row to be selected. The statement selects all rows if there is no WHERE clause.- In the
WHERE
clause, you can use any of the functions and operators that MySQL supports, except for aggregate (summary) functions. See http://dev.mysql.com/doc/refman/5.1/en/functions.html
- In the
- Use the
ORDER BY
clause to order the results.
- Use the
LIMIT
clause allows you to restrict the results to only a certain number of rows, optionally with an offset.
- Use the
GROUP BY
andHAVING
clauses to group rows together when they have columns or computed values in common.
SELECT can also be used to retrieve rows computed without reference to any table.
Select Expressions
A SELECT
statement must contain one or more select expressions, separated
by commas. Each select expression can be one of the following:
- The name of a column.
- Any expression using functions and operators.
*
to select all columns from all tables in theFROM
clause.tbl_name.*
to select all columns from just the table tbl_name.
When specifying a column, you can either use just the column name or qualify the column
name with the name of the table using tbl_name.col_name
. The qualified form is
useful if you are joining multiple tables in the FROM
clause. If you do not qualify the
column names when selecting from multiple tables, MariaDB will try to find the column in
each table. It is an error if that column name exists in multiple tables.
You can quote column names using backticks. If you are qualifying column names
with table names, quote each part separately as `tbl_name`.`col_name`
.
If you use any grouping functions
in any of the select expressions, all rows in your results will be implicitly grouped, as if
you had used GROUP BY NULL
.
ORDER BY
Use the ORDER BY
clause to order the results that are returned from a SELECT
statement. You can specify just a column or use any expression with functions. If you are
using the GROUP BY
clause, you can use grouping functions in ORDER BY
.
Ordering is done after grouping.
You can use multiple ordering expressions, separated by commas. Rows will be sorted by the first expression, then by the second expression if they have the same value for the first, and so on.
You can use the keywords ASC
and DESC
after each ordering expression to
force that ordering to be ascending or descending, respectively. Ordering is ascending
by default.
You can also use a single integer as the ordering expression. If you use an integer n, the results will be ordered by the nth column in the select expression.
When string values are compared, they are compared as if by the STRCMP
function. STRCMP
ignores trailing whitespace and may normalize
characters and ignore case, depending on the collation in use.
LIMIT
Use the LIMIT
clause to restrict the number of returned rows. When you use a single
integer n with LIMIT
, the first n rows will be returned. Use the ORDER BY
clause to control which rows come first. You can also select a number of rows after an offset
using either of the following:
LIMIT offset, row_count LIMIT row_count OFFSET offset
When you provide an offset m with a limit n, the first m rows will be ignored, and the following n rows will be returned.
GROUP BY
Use the GROUP BY
clause to group rows together that have the same value in
one or more column, or the same computed value using expressions with any
functions and operators except
grouping functions. When you
use a GROUP BY
clause, you will get a single result row for each group of rows
that have the same value for the expression given in GROUP BY
.
When grouping rows, grouping values are compared as if by the =
operator.
For string values, the =
operator ignores trailing whitespace and may normalize
characters and ignore case, depending on the collation in use.
You can use any of the grouping functions in your select expression. Their values will be calculated based on all the rows that have been grouped together for each result row. If you select a non-grouped column or a value computed from a non-grouped column, it is undefined which row the returned value is taken from.
You can use multiple expressions in the GROUP BY
clause, separated by commas.
Rows are grouped together if they match on each of the expressions.
You can also use a single integer as the grouping expression. If you use an integer n, the results will be grouped by the nth column in the select expression.
The WHERE
clause is applied before the GROUP BY
clause. It filters non-aggregated
rows before the rows are grouped together. To filter grouped rows based on aggregate values,
use the HAVING
clause. The HAVING
clause takes any expression and evaluates it as
a boolean, just like the WHERE
clause. You can use grouping functions in the HAVING
clause. As with the select expression, if you reference non-grouped columns in the HAVING
clause, the behavior is undefined.
GROUP BY
Examples
Consider the following table that records how many times each user has played and won a game:
CREATE TABLE plays (name VARCHAR(16), plays INT, wins INT); INSERT INTO plays VALUES ("John", 20, 5), ("Robert", 22, 8), ("Wanda", 32, 8), ("Susan", 17, 3);
Get a list of win counts along with a count:
MariaDB> SELECT wins, COUNT(*) FROM plays GROUP BY wins; +------+----------+ | wins | COUNT(*) | +------+----------+ | 3 | 1 | | 5 | 1 | | 8 | 2 | +------+----------+ 3 rows in set (0.00 sec)
The GROUP BY
expression can be a computed value, and can refer back to an identifer
specified with AS
. Get a list of win averages along with a count:
MariaDB> SELECT (wins / plays) AS winavg, COUNT(*) FROM plays GROUP BY winavg; +--------+----------+ | winavg | COUNT(*) | +--------+----------+ | 0.1765 | 1 | | 0.2500 | 2 | | 0.3636 | 1 | +--------+----------+ 3 rows in set (0.00 sec)
You can use any grouping function in the select expression. For each win average as above, get a list of the average play count taken to get that average:
MariaDB> SELECT (wins / plays) AS winavg, AVG(plays) FROM plays GROUP BY winavg; +--------+------------+ | winavg | AVG(plays) | +--------+------------+ | 0.1765 | 17.0000 | | 0.2500 | 26.0000 | | 0.3636 | 22.0000 | +--------+------------+ 3 rows in set (0.00 sec)
You can filter on aggregate information using the HAVING
clause. The HAVING
clause is applied after GROUP BY
and allows you to filter on aggregate data that is
not available to the WHERE
clause. Restrict the above example to results that involve
an average number of plays over 20:
MariaDB> SELECT (wins / plays) AS winavg, AVG(plays) FROM plays GROUP BY winavg HAVING AVG(plays) > 20; +--------+------------+ | winavg | AVG(plays) | +--------+------------+ | 0.2500 | 26.0000 | | 0.3636 | 22.0000 | +--------+------------+ 2 rows in set (0.00 sec)