在SELECT语句的FROM子句中，直接列出所要连接的表，即可实现简单的多表查询功能。利用逗号把FROM后的表名隔开，这就构成了最简单的连接查询。

SQL> select people.name,age,sex,books.name,price from people,books;

NAME        AGE SEX    NAME            PRICE
---------- ---- ------ ---------- ----------
Bob          25 male   CSS                32
Bob          25 male   Java_1             38
Bob          25 male   Java_2             40
Bob          25 male   SQL                25
Bob          25 male   Python             55
Jeff         27 male   CSS                32
Jeff         27 male   Java_1             38
Jeff         27 male   Java_2             40
Jeff         27 male   SQL                25
Jeff         27 male   Python             55
Jan          32 female CSS                32
Jan          32 female Java_1             38
Jan          32 female Java_2             40
Jan          32 female SQL                25
Jan          32 female Python             55
Susan        19 female CSS                32
Susan        19 female Java_1             38
Susan        19 female Java_2             40
Susan        19 female SQL                25
Susan        19 female Python             55

NAME        AGE SEX    NAME            PRICE
---------- ---- ------ ---------- ----------
Tom          29 male   CSS                32
Tom          29 male   Java_1             38
Tom          29 male   Java_2             40
Tom          29 male   SQL                25
Tom          29 male   Python             55
Lucy         29 female CSS                32
Lucy         29 female Java_1             38
Lucy         29 female Java_2             40
Lucy         29 female SQL                25
Lucy         29 female Python             55
Tomas        32 male   CSS                32
Tomas        32 male   Java_1             38
Tomas        32 male   Java_2             40
Tomas        32 male   SQL                25
Tomas        32 male   Python             55

35 rows selected

以上查询实际上返回的是连接表中所有数据行的笛卡儿积，这种查询实际意义很小。

可以在SELECT语句的WHERE子句中指定连接条件。

SQL> select people.name,age,books.name,price from people,books where people.name=books.owner;

NAME        AGE NAME            PRICE
---------- ---- ---------- ----------
Susan        19 CSS                32
Bob          25 Java_1             38
Bob          25 Java_2             40
Tom          29 SQL                25
Lucy         29 Python             55

以上代码是这样执行的：

1. 数据库系统首先执行FROM子句，根据FROM子句列出的people和books两个表，计算这两个表的笛卡儿积，列出这两个表中行的所有可能组合，形成一个中间表。中间表中的每条记录包含了两个表中的所有行。

2. DBMS将执行WHERE子句，根据“people.name=books.owner”关系对中间表进行搜索，去除那些不满足该关系的记录。

3. 系统执行SELECT语句，从执行WHERE子句后得到的中间表的每条记录中，提取所需要的字段信息作为结果表显示。
   

多表查询时，如果连接的两个表中没有相同的列名，则也可以省略表名。但是，如果两个表中含有相同的列名，则在使用该列时必须指明其对应的表名。

有时表名比较烦琐，使用起来很麻烦，为了使程序简洁明了，在SQL中也可以通过AS关键词为表定义别名。然而，与给列起别名不同，为表起别名是在FROM子句中完成的。

SQL> select p.name,age,b.name,price from people p,books b where p.name=b.owner;

NAME        AGE NAME            PRICE
---------- ---- ---------- ----------
Susan        19 CSS                32
Bob          25 Java_1             38
Bob          25 Java_2             40
Tom          29 SQL                25
Lucy         29 Python             55

由于SELECT语句在执行过程中首先执行的是FROM子句，而表的别名是在FROM子句中实现的，所以在SELECT语句的任何子句中都可以使用定义的表的别名。

注意：当一个新的SELECT语句被创建时，表的别名必须被重新定义。

在查询信息时，有时需要将表与其自身进行连接，即自连接，这就需要为表定义别名。

以下示例查询people表中所有身高比Bob高的人员信息：

SQL> select * from people;

  ID NAME        AGE SEX    HEIGHT WEIGHT
---- ---------- ---- ------ ------ ------
   1 Bob          25 male      170     70
   2 Jeff         27 male      176     82
   3 Jan          32 female    166     52
   4 Susan        19 female    168     55
   5 Tom          29 male      188     95
   6 Lucy         29 female    168     65
   7 Tomas        32 male      166     60

7 rows selected


SQL> select p1.* from people p1,people p2 where p2.name='Bob' and p1.height>p2.height;

  ID NAME        AGE SEX    HEIGHT WEIGHT
---- ---------- ---- ------ ------ ------
   2 Jeff         27 male      176     82
   5 Tom          29 male      188     95