要检索表 PART 中属性 PRICE 大于 10 的所有元组，我们写出如下查询：

SELECT * FROM PART
    WHERE PRICE > 10;
        

并得到表：

 PNO |  PNAME  |  PRICE
-----+---------+--------
  3  |  Bolt   |   15
  4  |  Cam    |   25
        

在 SELECT 语句中使用 "*" 将交付该表的所有属性。如果只想检索表 PART 的属性 PNAME 和 PRICE，我们使用如下语句：

SELECT PNAME, PRICE 
    FROM PART
    WHERE PRICE > 10;
        

此时结果为：

                      PNAME  |  PRICE
                     --------+--------
                      Bolt   |   15
                      Cam    |   25
        

注意，SQL 的 SELECT 对应于关系代数中的"投影"而不是"选择"（更多细节见 关系代数）。

WHERE 子句中的限定条件也可以用关键字 OR、AND 和 NOT 进行逻辑连接：

SELECT PNAME, PRICE 
    FROM PART
    WHERE PNAME = 'Bolt' AND
         (PRICE = 0 OR PRICE <= 15);
        

将得到结果：

 PNAME  |  PRICE
--------+--------
 Bolt   |   15
        

目标列表和 WHERE 子句中可以使用算术运算。例如，如果我们想知道取一个零件的两件要花多少钱，可以用如下查询：

SELECT PNAME, PRICE * 2 AS DOUBLE
    FROM PART
    WHERE PRICE * 2 < 50;
        

我们得到：

 PNAME  |  DOUBLE
--------+---------
 Screw  |    20
 Nut    |    16
 Bolt   |    30
        

注意，关键字 AS 之后的单词 DOUBLE 是第二列的新标题。此技术可用于目标列表的每个元素，为结果列指派新标题。这个新标题通常称为别名。别名不能在查询的其余部分中使用。

如果我们想知道表 PART 中所有零件的平均价格，使用以下查询：

SELECT AVG(PRICE) AS AVG_PRICE
    FROM PART;
        

结果是：

 AVG_PRICE
-----------
   14.5
        

如果我们想知道表 PART 中定义了多少个零件，使用语句：

SELECT COUNT(PNO)
    FROM PART;
        

并得到：

 COUNT
-------
   4
        

如果我们想知道每个供应商销售多少个零件，可以表述如下查询：

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
    FROM SUPPLIER S, SELLS SE
    WHERE S.SNO = SE.SNO
    GROUP BY S.SNO, S.SNAME;
        

并得到：

 SNO | SNAME | COUNT
-----+-------+-------
  1  | Smith |   2
  2  | Jones |   1
  3  | Adams |   2
  4  | Blake |   3
        

现在来看看这里发生了什么。首先导出表 SUPPLIER 和 SELLS 的连接：

 S.SNO | S.SNAME | SE.PNO
-------+---------+--------
   1   |  Smith  |   1
   1   |  Smith  |   2
   2   |  Jones  |   4
   3   |  Adams  |   1
   3   |  Adams  |   3
   4   |  Blake  |   2
   4   |  Blake  |   3
   4   |  Blake  |   4
        

接下来，把在 S.SNO 和 S.SNAME 两个属性上都一致的元组放在一起， 将元组划分为组：

 S.SNO | S.SNAME | SE.PNO
-------+---------+--------
   1   |  Smith  |   1
                 |   2
--------------------------
   2   |  Jones  |   4
--------------------------
   3   |  Adams  |   1
                 |   3
--------------------------
   4   |  Blake  |   2
                 |   3
                 |   4
        

在我们的例子中得到了四个组，现在可以对每个组应用聚合函数 COUNT， 从而得到上面给出的查询最终结果。

如果我们只想要销售多于一个零件的供应商，我们使用如下查询：

SELECT S.SNO, S.SNAME, COUNT(SE.PNO)
    FROM SUPPLIER S, SELLS SE
    WHERE S.SNO = SE.SNO
    GROUP BY S.SNO, S.SNAME
    HAVING COUNT(SE.PNO) > 1;
        

并得到：

 SNO | SNAME | COUNT
-----+-------+-------
  1  | Smith |   2
  3  | Adams |   2
  4  | Blake |   3
        

如果我们想知道所有比名为 'Screw' 的零件价格更高的零件，我们使用如下查询：

SELECT * 
    FROM PART 
    WHERE PRICE > (SELECT PRICE FROM PART
                   WHERE PNAME='Screw');
        

结果是：

 PNO |  PNAME  |  PRICE
-----+---------+--------
  3  |  Bolt   |   15
  4  |  Cam    |   25
        

观察上面的查询可以看到关键字 SELECT 出现了两次。第一次在查询的开头——我们称之为外层 SELECT——另一次在 WHERE 子句中，它开始一个嵌套查询——我们称之为内层 SELECT。对外层 SELECT 的每个元组，都必须求值内层 SELECT。每次求值后我们就知道了名为 'Screw' 的元组的价格，从而可以检查当前元组的价格是否更大。（实际上在本例中，内层查询只需求值一次，因为它不依赖外层查询的状态。）

如果我们想知道没有销售任何零件的供应商（例如，以便能从数据库中删除 这些供应商），使用：

SELECT * 
    FROM SUPPLIER S
    WHERE NOT EXISTS
        (SELECT * FROM SELLS SE
         WHERE SE.SNO = S.SNO);
        

在本例中结果将为空，因为每个供应商都至少销售一个零件。注意我们在内层 SELECT 的 WHERE 子句中使用了来自外层 SELECT 的 S.SNO。这里子查询必须对外层查询的每个元组重新求值，即 S.SNO 的值总是取自外层 SELECT 的当前元组。

如果我们想知道所有供应商中最高的平均零件价格，不能写成 MAX(AVG(PRICE))，但可以写成：

SELECT MAX(subtable.avgprice)
    FROM (SELECT AVG(P.PRICE) AS avgprice
          FROM SUPPLIER S, PART P, SELLS SE
          WHERE S.SNO = SE.SNO AND
                P.PNO = SE.PNO
          GROUP BY S.SNO) subtable;

子查询为每个供应商返回一行（因为它有 GROUP BY），然后我们在外层 查询中对这些行进行聚合。

下面的查询是 UNION 的例子：

SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNAME = 'Jones'
UNION
    SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNAME = 'Adams';

给出结果：

 SNO | SNAME |  CITY
-----+-------+--------
  2  | Jones | Paris
  3  | Adams | Vienna
        

下面是 INTERSECT 的例子：

SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNO > 1
INTERSECT
    SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNO < 3;
        

给出结果：

 SNO | SNAME |  CITY
-----+-------+--------
  2  | Jones | Paris
        

查询两部分都返回的唯一元组是 SNO=2 的那一个。

最后是 EXCEPT 的例子：

SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNO > 1
EXCEPT
    SELECT S.SNO, S.SNAME, S.CITY
    FROM SUPPLIER S
    WHERE S.SNO > 3;
        

给出结果：

 SNO | SNAME |  CITY
-----+-------+--------
  2  | Jones | Paris
  3  | Adams | Vienna
        

要创建供应商与零件数据库中定义的表， 使用以下 SQL 语句：

CREATE TABLE SUPPLIER
    (SNO   INTEGER,
     SNAME VARCHAR(20),
     CITY  VARCHAR(20));
     

CREATE TABLE PART
    (PNO   INTEGER,
     PNAME VARCHAR(20),
     PRICE DECIMAL(4 , 2));
     

CREATE TABLE SELLS
    (SNO INTEGER,
     PNO INTEGER);
        

要在关系 SUPPLIER 的属性 SNAME 上创建名为 I 的索引，使用以下语句：

CREATE INDEX I ON SUPPLIER (SNAME);
      

创建的索引会被自动维护，即每当有新元组插入关系 SUPPLIER 时，索引 I 都会随之调整。注意，存在索引时用户能察觉到的唯一变化是 SELECT 的速度提高和更新的速度降低。