检索数据(RETRIEVING DATA)

使用SQL的SELECT语句从Crate检索数据。SELECT查询语句中包含的列的名称，实际结果行是一个二位数组，行数和持续时间。 A simple select: 一个简单的查询:

cr> select name, position from locations order by id limit 2;
+-------------------+----------+
| name              | position |
+-------------------+----------+
| North West Ripple | 1        |
| Arkintoofle Minor | 3        |
+-------------------+----------+
SELECT 2 rows in set (... sec)

如果'*'，将返回所有在schema中定义的列：

cr> select * from locations order by id limit 1 offset 1;
+----...-+--------------...-+----+-------------+--...-+--...-+----------+------------------...-+
| date   | description      | id | information | kind | name | position | race                 |
+----...-+--------------...-+----+-------------+--...-+--...-+----------+------------------...-+
| 308... | Motivated by ... | 10 |        NULL | P... | A... | 3        | {"description": ...} |
+----...-+--------------...-+----+-------------+--...-+--...-+----------+------------------...-+
SELECT 1 row in set (... sec)

可以使用as来改变输出的列的名称:

cr> select name as n
... from locations
... where name = 'North West Ripple';
+-------------------+
| n                 |
+-------------------+
| North West Ripple |
+-------------------+
SELECT 1 row in set (... sec)

FROM子句(FROM Clause)

FROM子句用于SELECT的查询引用。可以是单个表，多个表，表连接(JOIN)或者子查询(Sub Select)。

一个表被schema和表名称引用，并且也可以是表别名。如果表t仅仅被表名引用，Crate假定使用doc.t。使用CREATE TABLE新创建的Schemas必须显示引用。

以下两种查询是等价的:

cr> select name, position from locations
... order by name desc nulls last limit 2;
+-------------------+----------+
| name              | position |
+-------------------+----------+
| Outer Eastern Rim |        2 |
| North West Ripple |        1 |
+-------------------+----------+
SELECT 2 rows in set (... sec)

cr> select doc.locations.name as n, position from doc.locations
... order by name desc nulls last limit 2;
+-------------------+----------+
| n                 | position |
+-------------------+----------+
| Outer Eastern Rim |        2 |
| North West Ripple |        1 |
+-------------------+----------+
SELECT 2 rows in set (... sec)

为了简洁，表名也可以是别名:

cr> select name from doc.locations as l
... where l.name = 'Outer Eastern Rim';
+-------------------+
| name              |
+-------------------+
| Outer Eastern Rim |
+-------------------+
SELECT 1 row in set (... sec)

连接(Joins)

注意

Crate目前只支持一组有限的JOIN。查看Joins获取最新的状况。

DISTINCT子句(DISTINCT Clause)

如果执行DISTINCT，将只保留唯一行。结果集中所有其他重复的行将被移除:

cr> select distinct date from locations order by date;
+---------------+
| date          |
+---------------+
| 308534400000  |
| 1367366400000 |
| 1373932800000 |
+---------------+
SELECT 3 rows in set (... sec)

WHERE子句(WHERE Clause)

一个使用等号操作的简单的where子句的例子:

cr> select description from locations where id = '1';
+---------------------------------------...--------------------------------------+
| description                                                                    |
+---------------------------------------...--------------------------------------+
| Relative to life on NowWhat, living on... a factor of about seventeen million. |
+---------------------------------------...--------------------------------------+
SELECT 1 row in set (... sec)

比较运算符(Comparison Operators)

在where子句中使用的通常比较运算符适用于所有简单数据类型:

操作符(Operator)    详情(Description)
<    小于(less than)
>    大于(greater than)
<=    小于等于(less than or equal to)
>=    大于等于(greater than or equal to)
=    等于(equal)
<>    不等于(not equal)
!=    不等于(not equal) - 等价于 <>
like    匹配给定值的一部分内容(matches a part of the given value)
~    正则匹配(regular expression match)
!~    否定式正则匹配(negated regular expression match)

对于字符串，基于Lucene TermRangeQuery执行逐一比较:

cr> select name from locations where name > 'Argabuthon' order by name;
+------------------------------------+
| name                               |
+------------------------------------+
| Arkintoofle Minor                  |
| Bartledan                          |
| Galactic Sector QQ7 Active J Gamma |
| North West Ripple                  |
| Outer Eastern Rim                  |
+------------------------------------+
SELECT 5 rows in set (... sec)

更多的细节请参见Apache Lucene site

数字和日期类型的比较和标准SQL一致。下面的例子使用支持的ISO日期格式中的一种:

cr> select date, position from locations where date <= '1979-10-12' and
... position < 3 order by position;
+--------------+----------+
| date         | position |
+--------------+----------+
| 308534400000 | 1        |
| 308534400000 | 2        |
+--------------+----------+
SELECT 2 rows in set (... sec)

有关支持的ISO日期格式的详细说明，请参阅joda date_optional_time网站。

对于自定义的日期类型或者对象映射中的定义的日期类型应该使用相应的格式进行比较，否则比较失败。

谓词(Predicates)

谓词是结果为boolean类型的表达式。

虽然值为boolean类型的标准函数可以在谓词出现的地方使用，但谓词不能在任何地方使用，例如.在一个select语句的结果列里。谓词的语意通常不同于函数的语义。

例如通过名称和参数类型识别函数。一个引用可以和函数的参数值互换。谓词可以具有不同的语意，例如强制使用列引用。

以下谓词扩展了where子句中可用条件的范围。

谓词	描述
IS NOT NULL	字段不为空而且不能缺失
IS NULL	字段为空或者缺失
MATCH Predicate	在索引列上执行搜索。请参阅全文搜索或者地理位置搜索的使用。

注意不是所有的谓词都可以有效地利用索引。例如“is null”不能使用索引，而且它的执行效率比其他操作符差。

正则表达式

正则表达式匹配值的操作符。

操作符	描述	例子
~	匹配正则表达式，区分大小写	'foo' ~ '.foo.'
~*	匹配正则表达式区分大小写	'Foo' ~ '.foo.*'
!~	不匹配的正则表达式，区分大小写	'Foo' !~ '.foo.'
!~*	不匹配的正则表达式，区分大小写	'foo' !~ '.bar.*'

~操作符可以通过正则表达式来匹配一个字符串。如果字符串符合正则匹配规则返回true，否则为false，如果字符串为NULL则返回NULL。

要否定匹配，在签名使用“!”。如果字符串与模式不匹配将返回true，否则false。允许使用所有的Unicode。

如果在正则表达式中使用PCRE,使用java标准库 java.util.regex中的操作符。

如果不在正则表达式中使用PCRE的特性，则运算符使用Lucene中的正则表达式，该表达式针对Lucene的分词优化正则表达式。

Lucene表达式是基本的POSIX扩展的正则表达式，没有字符类觉一些其它扩展，想元字符#匹配空串或者~匹配非空或其它。默认Lucene的扩展是开启的。详情参阅Lucene的文档

注意
因为使用使用~* 或者 !~*且不区分大小写的匹配隐式使用标准的java库，Lucene表达式将不会在这起作用。

例如:

cr> select name from locations where name ~ '([A-Z][a-z0-9]+)+'
... order by name;
+------------+
| name       |
+------------+
| Aldebaran  |
| Algol      |
| Altair     |
| Argabuthon |
| Bartledan  |
+------------+
SELECT 5 rows in set (... sec)

cr> select 'matches' from sys.cluster where
... 'gcc --std=c99 -Wall source.c' ~ '[A-Za-z0-9]+((-|--)[A-Za-z0-9]+)*( [^ ]+)*';
+-----------+
| 'matches' |
+-----------+
| matches   |
+-----------+
SELECT 1 row in set (... sec)

cr> select 'no_match' from sys.cluster where 'foobaz' !~ '(foo)?(bar)$';
+------------+
| 'no_match' |
+------------+
| no_match   |
+------------+
SELECT 1 row in set (... sec)

LIKE(模糊查找)

Crate支持LIKE操作。like操作可用来查询部分列值匹配的的行。例如获取所有名字以‘Ar’开头的位置信息可使用如下查询:

cr> select name from locations where name like 'Ar%' order by name asc;
+-------------------+
| name              |
+-------------------+
| Argabuthon        |
| Arkintoofle Minor |
+-------------------+
SELECT 2 rows in set (... sec)

以下的通配符操作是有用的:

% 替代0个或多个字符 _ 替代一个字符

通配符可以在任何字符串中使用。例如，像这样一个更复杂的子句:

cr> select name from locations where name like '_r%a%' order by name asc;
+------------+
| name       |
+------------+
| Argabuthon |
+------------+
SELECT 1 row in set (... sec)

In order so search for the wildcard characters themselves it is possible to escape them using a backslash: 为了搜索本身的字符，可以使用反斜线转义:

cr> select description from locations
... where description like '%\%' order by description asc;
+-------------------------+
| description             |
+-------------------------+
| The end of the Galaxy.% |
+-------------------------+
SELECT 1 row in set (... sec)

注意使用like子句的插叙会相当慢。特别是以通配符开始的like子句。因为crate在处理这种情况四必须遍历所有的行而且不使用索引。为了更好的性能考虑使用全文索引。

NOT NOT的否定是一个布尔表达式:

[ NOT ] 布尔表达式

结果类型是布尔值。

expression	result
true	false
false	true
null	true

注意
这不符合SQL标准而且不遵循三值逻辑。根据标准NOT(NULL)将会返回NULL。

IN

Crate也支持二元运算符IN,将允许你验证左边的操作数在右边的一组表达式中。当右边表达式中的任意值和左边的操作数相等将返回true，否则为false:

cr> select name, kind from locations
... where (kind in ('Star System', 'Planet'))  order by name asc;
 +---------------------+-------------+
 | name                | kind        |
 +---------------------+-------------+
 |                     | Planet      |
 | Aldebaran           | Star System |
 | Algol               | Star System |
 | Allosimanius Syneca | Planet      |
 | Alpha Centauri      | Star System |
 | Altair              | Star System |
 | Argabuthon          | Planet      |
 | Arkintoofle Minor   | Planet      |
 | Bartledan           | Planet      |
 +---------------------+-------------+
 SELECT 9 rows in set (... sec)

IS NULL

如果表达式评定为NULL则返回TRUE。如果给定一个引用列的字段中包含NULL或者缺失将返回TRUE。

使用此谓词来检查NULL的值就像使用SQL中的三值逻辑，当比较NULL时将总是返回NULL。

expr: Crate支持的数据类型的表达式。

cr> select name from locations where race is null order by name;
+------------------------------------+
| name                               |
+------------------------------------+
|                                    |
| Aldebaran                          |
| Algol                              |
| Allosimanius Syneca                |
| Alpha Centauri                     |
| Altair                             |
| Argabuthon                         |
| Galactic Sector QQ7 Active J Gamma |
| North West Ripple                  |
| Outer Eastern Rim                  |
| NULL                               |
+------------------------------------+
SELECT 11 rows in set (... sec)

cr> select count(*) from locations where name is null;
+----------+
| count(*) |
+----------+
|        1 |
+----------+
SELECT 1 row in set (... sec)

IS NOT NULL

Returns TRUE if expr does not evaluate to NULL. Additionally, for column references it returns FALSE if the column does not exist.

如果表达式不评定为NULL则发回TRUE。总之，对引用列如果不存在将返回FALSE。

Use this predicate to check for non-NULL values as SQL’s three-valued logic does always return NULL when comparing NULL.

使用此谓词检查非空值像SQL中三值逻辑当比较NULL时总是返回NULL。

expr: expression of one of the supported Data Types supported by crate.

cr> select name from locations where race['interests'] is not null;
+-------------------+
| name              |
+-------------------+
| Arkintoofle Minor |
| Bartledan         |
+-------------------+
SELECT 2 rows in set (... sec)

cr> select count(*) from locations where name is not null;
+----------+
| count(*) |
+----------+
|       12 |
+----------+
SELECT 1 row in set (... sec)

ANY (array)

ANY(或者 SOME)操作符允许在数组内的元素上搜索。这允许查询数组中某些元素的行，例如，等于或大于某些表达。

以下的例子将返回任何数组 race['interests']中包含‘netball’的行:

cr> select race['name'], race['interests'] from locations
... where 'netball' = ANY(race['interests']);
+----------------+-----------------------------------------+
| race['name']   | race['interests']                       |
+----------------+-----------------------------------------+
| Bartledannians | ["netball", "books with 100.000 words"] |
+----------------+-----------------------------------------+
SELECT 1 row in set (... sec)

cr> select race['name'], race['interests'] from locations
... where 'books%' LIKE ANY(race['interests']);
+----------------+-----------------------------------------+
| race['name']   | race['interests']                       |
+----------------+-----------------------------------------+
| Bartledannians | ["netball", "books with 100.000 words"] |
+----------------+-----------------------------------------+
SELECT 1 row in set (... sec)

It can also be used on array literals: 也可以用于文本数组:

cr> select name, race['interests'] from locations
... where name = ANY (['Bartledan', 'Algol'])
... order by name asc;
+-----------+-----------------------------------------+
| name      | race['interests']                       |
+-----------+-----------------------------------------+
| Algol     | NULL                                    |
| Bartledan | ["netball", "books with 100.000 words"] |
+-----------+-----------------------------------------+
SELECT 2 rows in set (... sec)

This way it can be used as a shortcut for name = 'Bartledan' OR name = 'Algol' or any other ANY comparison. 这种方法可以用作为诸如 name = 'Bartledan' OR name = 'Algol' 或者其它比较的快捷方式。 Syntax of the ANY Operator: ANY操作符的语法:

expression operator ANY | SOME (array)

ANY操作符允许在数组中的元素中使用操作符。比较必须返回一个boolean结果。

如果任何比较都返回true则ANY的结果就为true。
如果没有比较但会true或者一个数组不包含任何元素，则ANY的结果为false。
如果其中一个表达式或者数组为null，ANY的结果为NULL。如果没有为true的比较且数组中的人任何元素都为null，ANY的结果也为null。

注意
以下不支持ANY的操作符:

‘is null’和‘is not null’操作符

对象数组

对象表达式

Negating ANY

使用ANY时需要注意的一个重要的事情是对ANY操作取反将不会像普通的比较操作一样会取反。

以下的查询可被翻译为race[‘interests’]中至少有一个元素等于‘netball’的所有行:

cr> select race['name'], race['interests'] from locations
... where 'netball' = ANY(race['interests']);
+----------------+-----------------------------------------+
| race['name']   | race['interests']                       |
+----------------+-----------------------------------------+
| Bartledannians | ["netball", "books with 100.000 words"] |
+----------------+-----------------------------------------+
SELECT 1 row in set (... sec)

以下的查询使用否定运算符!=可能被翻译为race[‘interests’]中至少有一个元素不等于‘netball’的所有行。正如你看到的，再这个例子汇总结果是一样的:

cr> select race['name'], race['interests'] from locations
... where 'netball' != ANY(race['interests']);
+----------------+-----------------------------------------+
| race['name']   | race['interests']                       |
+----------------+-----------------------------------------+
| Minories       | ["baseball", "short stories"]           |
| Bartledannians | ["netball", "books with 100.000 words"] |
+----------------+-----------------------------------------+
SELECT 2 rows in set (... sec)

否定=查询和上面的完全不同。他将被翻译为获取所有race[‘interests’]没有值等于‘netball’的行:

cr> select race['name'], race['interests'] from locations
... where not 'netball' = ANY(race['interests']) order by race['name'];
+--------------+-------------------------------+
| race['name'] | race['interests']             |
+--------------+-------------------------------+
| Minories     | ["baseball", "short stories"] |
+--------------+-------------------------------+
SELECT 1 row in set (... sec)

同样的行为(尽管涉及不同的比较操作)对操作符是成立的。

LIKE and NOT LIKE

所有的其它的比较操作(IS NULL和IS NOT NULL除外)

Limits

不限制的SELECT查询不会打断你的集群如果匹配到的行超过节点的内存的大小，SELECT语句通过默认的10000行来限制。你可以扩大这个限制使用严格的limit子句。但是鼓励您使用LIMIT和OFFSET使用窗口来遍历潜在的大的结果集而不是扩大默认的limit。

当使用PostgreSQL的有线协议，在SELECT语句上将没有严格10000行的限制。

内部/嵌套对象

Crate支持对象数据类型，简单将一个对象存储到一个列中，甚至可以查询和选择此对象的属性。

选择一个对象内部的属性:

cr> select name, race['name'] from locations where name = 'Bartledan';
+-----------+----------------+
| name      | race['name']   |
+-----------+----------------+
| Bartledan | Bartledannians |
+-----------+----------------+
SELECT 1 row in set (... sec)

插叙一个内部对象的属性:

cr> select name, race['name'] from locations
... where race['name'] = 'Bartledannians';
+-----------+----------------+
| name      | race['name']   |
+-----------+----------------+
| Bartledan | Bartledannians |
+-----------+----------------+
SELECT 1 row in set (... sec)

插入对象:

cr> insert into locations (id, name, position, kind, race)
... values ('DO', 'Dornbirn', 14, 'City', {name='Vorarlberger',
...     description = 'Very nice people with a strange accent',
...     interests = ['mountains', 'cheese', 'enzian']}
... );
INSERT OK, 1 row affected (... sec)

对象数组(Object Arrays)

数组在crate中仅仅包含数。对象数组是一个例外。你可以使用下标表达式访问存储内部或嵌套对象的字段，你可以访问对象数据的字段。因为对象数组不是对象，你将不会得到单个字段的值，而是包含那个字段的所有对象，及对象中所有值的一个数组。

例如:

c> select name, information['population'] from locations
... where information['population'] is not null
... order by name;
+-------------------+---------------------------+
| name              | information['population'] |
+-------------------+---------------------------+
| North West Ripple | [12, 42]                  |
| Outer Eastern Rim | [5673745846]              |
+-------------------+---------------------------+
SELECT 2 rows in set (... sec)

cr> select information from locations
... where information['population'] is not null
... order by name;
+----------------------------------------------------...-----------------------+
| information                                                                  |
+----------------------------------------------------...-----------------------+
| [{"evolution_level": 4, "population": 12}, {"evolu...": 42, "popul...": 42}] |
| [{"evolution_level": 2, "population": 5673745846}]                           |
+---------------------------------------------------...------------------------+
SELECT 2 rows in set (... sec)

cr> insert into locations (id, name, position, kind, information)
... values (
...   'B', 'Berlin', 15, 'City',
...   [{evolution_level=6, population=3600001},
...   {evolution_level=42, population=1}]
... );
INSERT OK, 1 row affected (... sec)

cr> refresh table locations;
REFRESH OK, 1 row affected (... sec)
```sh
cr> select name from locations where 4 < ANY (information['evolution_level'])
... order by name;
+-------------------+
| name              |
+-------------------+
| Berlin            |
| North West Ripple |
+-------------------+
SELECT 2 rows in set (... sec)

选择数组元素(Selecting Array Elements)

数组元素可以使用一个大于或等于1的值直接选中。最大支持的数组下标是2147483648。使用大于实际值的下标将会返回空值NULL。

cr> select name, information[1]['population'] as population from locations
... where information['population'] is not null
... order by name;
+-------------------+------------+
| name              | population |
+-------------------+------------+
| Berlin            |    3600001 |
| North West Ripple |         12 |
| Outer Eastern Rim | 5673745846 |
+-------------------+------------+
SELECT 3 rows in set (... sec)

注意
只支持数组下标中的一个数组符号，例如以下将不会工作:
select information[1][tags][1] from locations;

数据聚合(Data Aggregation)

Crate支持聚合，使用以下列出的在select语句上的聚合函数。

聚合工作在与查询匹配的所有行，或者使用GROUP BY语句的每个不同组中的匹配行上工作。聚合查询语句没有GROUP BY将总是返回一行，因为它们在当做一个组的匹配行上执行聚合操作。

参见
聚合

名称	参数	描述	返回值类型
ARBITRARY	基本类型(除对象外)列的列名	返回参数列中所有值中未定义的值。可以为NULL	列的类型或者NULL，如果匹配行的列为NULL
AVG / MEAN	一个数字类型或者时间戳类型的列名	返回参数列的算术平均值。忽略NULL值	double或者NULL，如果所有匹配行的列值都是NULL
COUNT(*)	星型作为参数或恒定	统计查询匹配的行数	long
COUNT	列名	统计中包含非NULL的给定列的行数。	long
COUNT(DISTINCT col)	列名	统计给定列的buweiNULL的值的数量	long
GEOMETRIC_MEAN	数字类型或者时间戳类型的列名称	计算正数的几何平均值。	double 或者 NULL如果匹配到的所有行都为NULL或者为负数。
MIN	数字类型，时间戳或者字符串类型的列名。	返回参数列中最小的值，如果是string则意味着按字典中最小的。NULL值忽略。	输入列类型或者NULL,如果匹配到的行的那一列为空
MAX	数字类型，时间戳或者字符串类型的列名。	返回参数列中值最大的，如果是string则意味着按字典中最大的。NULL值忽略。	输入列类型或者NULL,如果匹配到的行的那一列为空
STDDEV	数字类型，时间戳或者字符串类型的列名。	返回参数列中的值的标准偏差。忽略NULL值	double或者NULL,如果匹配到的行的那一列为NULL
SUM	数字或者时间戳类型的列名	返回参数列的求和值。忽略NULL值	double或者NULL,如果匹配到的行的那一列为NULL。
VARIANCE	数字或时间戳类型的列名	返回参数列中值的方差	double 或者 NULL若果所有值都为NULL或者我们没有取到任何值

注意聚合仅仅应用在普通索引上，默认所有基本类型的列。更多详情，请参见Plain index(default)。

一些例子:

cr> select count(*) from locations;
+----------+
| count(*) |
+----------+
| 15       |
+----------+
SELECT 1 row in set (... sec)

cr> select count(*) from locations where kind = 'Planet';
+----------+
| count(*) |
+----------+
| 5       |
+----------+
SELECT 1 row in set (... sec)

cr> select count(name), count(*) from locations;
+-------------+----------+
| count(name) | count(*) |
+-------------+----------+
| 14          | 15       |
+-------------+----------+
SELECT 1 row in set (... sec)

cr> select max(name) from locations;
+-------------------+
| max(name)         |
+-------------------+
| Outer Eastern Rim |
+-------------------+
SELECT 1 row in set (... sec)

cr> select min(date) from locations;
+--------------+
| min(date)    |
+--------------+
| 308534400000 |
+--------------+
SELECT 1 row in set (... sec)

cr> select count(*), kind from locations
... group by kind order by kind asc;
+----------+-------------+
| count(*) | kind        |
+----------+-------------+
| 2        | City        |
| 4        | Galaxy      |
| 5        | Planet      |
| 4        | Star System |
+----------+-------------+
SELECT 4 rows in set (... sec)

cr> select max(position), kind from locations
... group by kind order by max(position) desc;
+---------------+-------------+
| max(position) | kind        |
+---------------+-------------+
| 15            | City        |
| 6             | Galaxy      |
| 5             | Planet      |
| 4             | Star System |
+---------------+-------------+
SELECT 4 rows in set (... sec)
```sh
cr> select min(name), kind from locations
... group by kind order by min(name) asc;
+------------------------------------+-------------+
| min(name)                          | kind        |
+------------------------------------+-------------+
|                                    | Planet      |
| Aldebaran                          | Star System |
| Berlin                             | City        |
| Galactic Sector QQ7 Active J Gamma | Galaxy      |
+------------------------------------+-------------+
SELECT 4 rows in set (... sec)

cr> select count(*), min(name), kind from locations
... group by kind order by kind;
+----------+------------------------------------+-------------+
| count(*) | min(name)                          | kind        |
+----------+------------------------------------+-------------+
| 2        | Berlin                             | City        |
| 4        | Galactic Sector QQ7 Active J Gamma | Galaxy      |
| 5        |                                    | Planet      |
| 4        | Aldebaran                          | Star System |
+----------+------------------------------------+-------------+
SELECT 4 rows in set (... sec)

cr> select sum(position) as sum_positions, kind from locations
... group by kind order by sum_positions;
+---------------+-------------+
| sum_positions | kind        |
+---------------+-------------+
| 10.0          | Star System |
| 13.0          | Galaxy      |
| 15.0          | Planet      |
| 29.0          | City        |
+---------------+-------------+
SELECT 4 rows in set (... sec)

分组(GROUP BY)

Crate支持group by子句。这个子句可以用来对结果行按一个或多个列的值进行分组。这意味着包含多个值的行将会合并在一起。如果和聚合函数一起使用，这是很有用的:

cr> select count(*), kind from locations
... group by kind order by count(*) desc, kind asc;
+----------+-------------+
| count(*) | kind        |
+----------+-------------+
| 5        | Planet      |
| 4        | Galaxy      |
| 4        | Star System |
| 2        | City        |
+----------+-------------+
SELECT 4 rows in set (... sec)

注意用作结果列或者order by子句的所有列必须在group by子句中使用。否则语句将不能执行。

注意多值字段分组不起作用。如果在group by操作中有这样的字段将会抛出一个错误。

注意分组可仅仅用于一个普通索引，默认对所有行。为了获取更多的信息，请参见Plain index(Default)。

HAVING

having子句等价于group by子句结果行的where子句。一个简单的having子句的例子使用一个等价的操作:

cr> select count(*), kind from locations
... group by kind having count(*) = 4 order by kind;
+----------+-------------+
| count(*) | kind        |
+----------+-------------+
|        4 | Galaxy      |
|        4 | Star System |
+----------+-------------+
SELECT 2 rows in set (... sec)

having子句的条件可以引用到group子句的结果列。而且可以在having子句中使用聚合就像早结果列中:

cr> select count(*), kind from locations
... group by kind having min(name) = 'Berlin';
+----------+------+
| count(*) | kind |
+----------+------+
|        2 | City |
+----------+------+
SELECT 1 row in set (... sec)

cr> select count(*), kind from locations
... group by kind having count(*) = 4 and kind like 'Gal%';
+----------+--------+
| count(*) | kind   |
+----------+--------+
|        4 | Galaxy |
+----------+--------+
SELECT 1 row in set (... sec)

比较运算符 having子句支持和where子句相同的操作:

操作符	描述
<	小于
>	大于
<=	小于等于
>=	大于等于
=	等于
<>	不等于
!=	不等于等价于 <>
like	匹配给定值的部分
~	正则表达式匹配
!~	否定正则表达式匹配

数据检索(Retrieving Data)