# SQLite `SELECT`语句

> 原文： [http://zetcode.com/db/sqlite/select/](http://zetcode.com/db/sqlite/select/)

SQLite 教程的这一部分详细介绍了 SQLite `SELECT`语句的实现。

## SQLite 检索所有数据

以下 SQL 语句是最常见的语句之一。 它也是最昂贵的之一。

```sql
sqlite> SELECT * FROM Cars;
Id          Name        Price     
----------  ----------  ----------
1           Audi        52642     
2           Mercedes    57127     
3           Skoda       9000      
4           Volvo       29000     
5           Bentley     350000    
6           Citroen     21000     
7           Hummer      41400     
8           Volkswagen  21600 

```

在这里，我们从`Cars`表中检索所有数据。

### SQLite 选择特定列

我们可以使用`SELECT`语句来检索特定的列。 列名紧随`SELECT`字。

```sql
sqlite> SELECT Name, Price FROM Cars;
Name        Price     
----------  ----------
Audi        52642     
Mercedes    57127     
Skoda       9000      
Volvo       29000     
Bentley     350000    
Citroen     21000     
Hummer      41400     
Volkswagen  21600    

```

我们检索`Name`和`Price`列。 列名用逗号分隔。

### SQLite 重命名列名

我们可以重命名返回结果集的列名。 为此，我们使用`AS`子句。

```sql
sqlite> SELECT Name, Price AS 'Price of car' FROM Cars;
Name        Price of car
----------  ------------
Audi        52642       
Mercedes    57127       
Skoda       9000        
Volvo       29000       
Bentley     350000      
Citroen     21000       
Hummer      41400       
Volkswagen  21600  

```

通过上面的 SQL 语句，我们将`Price`列重命名为`Price of car`。

## SQLite 限制数据输出

如上所述，在处理大量数据时，检索所有数据非常昂贵。 我们可以使用`LIMIT`子句来限制该语句返回的数据量。

```sql
sqlite> SELECT * FROM Cars LIMIT 4;
Id          Name        Price     
----------  ----------  ----------
1           Audi        52642     
2           Mercedes    57127     
3           Skoda       9000      
4           Volvo       29000    

```

`LIMIT`子句将返回的行数限制为 4。

```sql
sqlite> SELECT * FROM Cars LIMIT 2, 4;
Id          Name        Price     
----------  ----------  ----------
3           Skoda       9000      
4           Volvo       29000     
5           Bentley     350000    
6           Citroen     21000  

```

该语句选择四行，跳过前两行。

`LIMIT`之后的`OFFSET`子句指定在结果集的开头要跳过多少行。 这是上一个解决方案的替代方案。

```sql
sqlite> SELECT * FROM Cars LIMIT 4 OFFSET 2;
Id          Name        Price     
----------  ----------  ----------
3           Skoda       9000      
4           Volvo       29000     
5           Bentley     350000    
6           Citroen     21000  

```

在这里，我们从最多四行中选择所有数据，然后从第三行开始。 `OFFSET`子句跳过前两行。

## SQLite 排序数据

我们使用`ORDER BY`子句对返回的数据集进行排序。 `ORDER BY`子句后面是进行排序的列。 `ASC`关键字以升序对数据进行排序，`DESC`则以降序对数据进行排序。

```sql
sqlite> SELECT * FROM Cars ORDER BY Price;
Id          Name        Price     
----------  ----------  ----------
3           Skoda       9000      
6           Citroen     21000     
8           Volkswagen  21600     
4           Volvo       29000     
7           Hummer      41400     
1           Audi        52642     
2           Mercedes    57127     
5           Bentley     350000  

```

默认排序为升序。 `ASC`子句可以省略。

```sql
sqlite> SELECT Name, Price FROM Cars ORDER BY Price DESC;
Name        Price     
----------  ----------
Bentley     350000    
Mercedes    57127     
Audi        52642     
Hummer      41400     
Volvo       29000     
Volkswagen  21600     
Citroen     21000     
Skoda       9000  

```

在上面的 SQL 语句中，我们从`Cars`表中选择`Name`和`Price`列，并按汽车的`Price`降序对其进行排序。 因此，最昂贵的汽车排在第一位。

## SQLite 按更多列排序数据

可以按多于一列的顺序订购数据。

```sql
sqlite> INSERT INTO Cars(Name, Price) VALUES('Fiat', 9000);
sqlite> INSERT INTO Cars(Name, Price) VALUES('Tatra', 9000);

```

在此示例中，我们添加了两辆价格为 9000 的汽车。

```sql
sqlite> SELECT * FROM Cars ORDER BY Price, Name DESC;
Id          Name        Price     
----------  ----------  ----------
10          Tatra       9000      
3           Skoda       9000      
9           Fiat        9000      
6           Citroen     21000     
8           Volkswagen  21600     
4           Volvo       29000     
7           Hummer      41400     
1           Audi        52642     
2           Mercedes    57127     
5           Bentley     350000  

```

在语句中，我们按两列对数据进行排序：价格和名称。 名称按降序排列。

## SQLite 使用`WHERE`选择特定行

下一组示例使用`Orders`表。

```sql
sqlite> SELECT * FROM Orders;
Id          OrderPrice  Customer  
----------  ----------  ----------
1           1200        Williamson
2           200         Robertson 
3           40          Robertson 
4           1640        Smith     
5           100         Robertson 
6           50          Williamson
7           150         Smith     
8           250         Smith     
9           840         Brown     
10          440         Black     
11          20          Brown  

```

在这里，我们看到`Orders`表中的所有数据。

接下来，我们要选择一个特定的行。

```sql
sqlite> SELECT * FROM Orders WHERE Id=6;
Id          OrderPrice  Customer  
----------  ----------  ----------
6           50          Williamson

```

上面的 SQL 语句选择具有 ID 6 的行。

```sql
sqlite> SELECT * FROM Orders WHERE Customer="Smith";
Id          OrderPrice  Customer  
----------  ----------  ----------
4           1640        Smith     
7           150         Smith     
8           250         Smith     

```

上面的 SQL 语句选择`Smith`客户的所有订单。

我们可以使用`LIKE`子句在数据中查找特定的模式。

```sql
sqlite> SELECT * FROM Orders WHERE Customer LIKE 'B%';
Id          OrderPrice  Customer  
----------  ----------  ----------
9           840         Brown     
10          440         Black     
11          20          Brown 

```

该 SQL 语句从名称以字母 B 开头的客户中选择所有订单。

## SQLite 删除重复项

`DISTINCT`子句用于从结果集中仅选择唯一项。

```sql
sqlite> SELECT Customer FROM Orders WHERE Customer LIKE 'B%';
Customer  
----------
Brown     
Black     
Brown  

```

这次，我们选择了名称以 B 开头的客户。我们可以看到 Brown 出现了两次。 要删除重复项，我们使用`DISTINCT`关键字。

```sql
sqlite> SELECT DISTINCT Customer FROM Orders WHERE Customer LIKE 'B%';
Customer  
----------
Black     
Brown   

```

这是正确的解决方案。

## SQLite 组数据

`GROUP BY`子句用于将具有相同值的数据库记录组合到单个记录中。 它通常与聚合函数一起使用。

假设我们想找出每个客户的订单总和。

```sql
sqlite> SELECT sum(OrderPrice) AS Total, Customer FROM Orders GROUP BY Customer;
Total       Customer  
----------  ----------
440         Black     
860         Brown     
340         Robertson 
2040        Smith     
1250        Williamson

```

`sum()`函数返回数字列的总和。 `GROUP BY`子句将总金额分配给客户。 因此，我们可以看到`Black`订购了 440，`Smith`订购了 2040 个商品。

使用聚合函数时，不能使用`WHERE`子句。 我们改用`HAVING`子句。

```sql
sqlite> SELECT sum(OrderPrice) AS Total, Customer FROM Orders 
        GROUP BY Customer HAVING sum(OrderPrice)>1000;
Total       Customer  
----------  ----------
2040        Smith     
1250        Williamson

```

上面的 SQL 语句选择总订单量大于 1000 个单位的客户。

在 SQLite 教程的这一部分中，我们更详细地描述了 SQL `SELECT`语句。