Tutorial básico do PostgreSQL

Tutorial avançado do PostgreSQL

Interface PostgreSQL

Operador UNION do PostgreSQL Restrições do PostgreSQL

Conexão (JOIN) do PostgreSQL

A cláusula JOIN do PostgreSQL é usada para combinar linhas de duas ou mais tabelas com base em campos comuns entre essas tabelas.

No PostgreSQL, há cinco tipos de conexões JOIN:

CROSS JOIN : Conexão cruzada
INNER JOIN: Conexão interna
LEFT OUTER JOIN: Conexão externa esquerda
RIGHT OUTER JOIN: Conexão externa direita
FULL OUTER JOIN: Conexão externa completa

Vamos criar duas tabelas COMPANY e DEPARTMENT。

Exemplo online

Criar tabela COMPANY (Baixar arquivo SQL da tabela COMPANY ），os dados são os seguintes：

w3codeboxdb# select　*　FROM COMPANY;
　id | name | age | address | salary
----+-------+-----+-----------+--------
　　1　|　Paul　　|　　32　| California|　　20000
　　2　|　Allen　|　　25　| Texas |　　15000
　　3　|　Teddy　|　　23　| Norway |　　20000
　　4　|　Mark　　|　　25　|　Rich-Mond |　　65000
　　5　|　David　|　　27　| Texas |　　85000
　　6　|　Kim　　　|　　22　|　South-Hall|　　45000
　　7　|　James　|　　24　| Houston |　　10000
(7　rows)

Vamos adicionar algumas linhas de dados à tabela:

INSERT INTO COMPANY VALUES (8, 'Paul',　24, 'Houston',　20000.00);
INSERT INTO COMPANY VALUES (9, 'James',　44, 'Norway',　5000.00);
INSERT INTO COMPANY VALUES (10, 'James',　45, 'Texas',　5000.00);

Neste momento, os registros da tabela COMPANY são os seguintes:

　id | name | age | address | salary
　----+-------+-----+--------------+--------
　　　1　|　Paul　　|　　32　| California |　　20000
　　　2　|　Allen　|　　25　|　Texas　　　　　　　　|　　15000
　　　3　|　Teddy　|　　23　|　Norway　　　　　　　|　　20000
　　　4　|　Mark　　|　　25　|　Rich-Mond　　　　|　　65000
　　　5　|　David　|　　27　|　Texas　　　　　　　　|　　85000
　　　6　|　Kim　　　|　　22　|　South-Hall　　　|　　45000
　　　7　|　James　|　　24　|　Houston　　　　　　|　　10000
　　　8　|　Paul　　|　　24　|　Houston　　　　　　|　　20000
　　　9　|　James　|　　44　|　Norway　　　　　　　|　　　5000
　　10　|　James　|　　45　|　Texas　　　　　　　　|　　　5000
(10　rows)

创建一张 DEPARTMENT 表，添加三个字段：

CREATE　TABLE　DEPARTMENT(
　　　ID　INT　PRIMARY　KEY　　　　　　NOT　NULL,
　　　DEPT　　　　　　　　　　　CHAR(50)　NOT　NULL,
　　　EMP_ID　　　　　　　　　INT　　　　　　NOT　NULL
);

向 DEPARTMENT 表插入三条记录：

INSERT　INTO　DEPARTMENT　(ID,　DEPT,　EMP_ID)　VALUES　(1,　'IT　Billing',　1　);
INSERT　INTO　DEPARTMENT　(ID,　DEPT,　EMP_ID)　VALUES　(2,　'Engineering',　2　);
INSERT　INTO　DEPARTMENT　(ID,　DEPT,　EMP_ID)　VALUES　(3,　'Finance',　7　);

此时，DEPARTMENT 表的记录如下：

　id　|　dept　　　　　　　　|　emp_id
----+-------------+--------
　　1　|　IT　Billing　　|　　1
　　2　|　Engineering　|　　2
　　3　|　Finance　　　　　|　　7

交叉连接

交叉连接（CROSS JOIN）把第一个表的每一行与第二个表的每一行进行匹配。如果两个输入表分别有 x 和 y 行，则结果表有 x*y 行。

由于交叉连接（CROSS JOIN）有可能产生非常大的表，使用时必须谨慎，只在适当的时候使用它们。

下面是 CROSS JOIN 的基础语法：

SELECT ... FROM tabela1　CROSS　JOIN　table2　...

基于上面的表，我们可以写一个交叉连接（CROSS JOIN），如下所示：

w3codeboxdb=#　SELECT　EMP_ID,　NAME,　DEPT　FROM　COMPANY　CROSS　JOIN　DEPARTMENT;

得到结果如下：

w3codeboxdb=#　SELECT　EMP_ID,　NAME,　DEPT　FROM　COMPANY　CROSS　JOIN　DEPARTMENT;
　emp_id　|　name　　|　　　　　　　dept
--------+-------+--------------------
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　1　|　Allen　|　IT　Billing
　　　　　　1　|　Teddy　|　IT　Billing
　　　　　　1　|　Mark　　|　IT　Billing
　　　　　　1　|　David　|　IT　Billing
　　　　　　1　|　Kim　　　|　IT　Billing
　　　　　　1　|　James　|　IT　Billing
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　1　|　James　|　IT　Billing
　　　　　　1　|　James　|　IT　Billing
　　　　　　2　| Paul | Engineering
　　　　　　2　|　Allen　|　Engineering
　　　　　　2　|　Teddy　|　Engineering
　　　　　　2　|　Mark　　|　Engineering
　　　　　　2　| David | Engineering
　　　　　　2　| Kim | Engineering
　　　　　　2　| James | Engineering
　　　　　　2　| Paul | Engineering
　　　　　　2　| James | Engineering
　　　　　　2　| James | Engineering
　　　　　　7　| Paul | Finance

JOIN interno

O JOIN interno (INNER JOIN) combina duas tabelas (table1 e table2) para criar uma nova tabela de resultado. A consulta combina table1 Cada linha é comparada com a tabela2 　Cada linha é comparada para encontrar todos os pares de correspondência que atendem às condições de conexão.

Quando as condições de conexão são atendidas, os valores das colunas de cada par de correspondência entre as linhas A e B são combinados em uma linha de resultado.

O JOIN interno (INNER JOIN) é o tipo mais comum de conexão e é o tipo padrão.

A palavra-chave INNER é opcional.

A seguir está a sintaxe do JOIN interno (INNER JOIN):

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;

Com base nas tabelas acima, podemos escrever um JOIN interno, conforme abaixo:

w3codeboxdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
　emp_id | name |               dept
--------+-------+--------------
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　2　|　Allen　|　Engineering
　　　　　　7　|　James　|　Finance
(3　rows)

LEFT OUTER JOIN

A conexão externa é uma extensão do JOIN interno. O padrão SQL define três tipos de conexões externas: LEFT, RIGHT e FULL, o PostgreSQL suporta todas elas.

Para o JOIN externo esquerdo, primeiro é executado um JOIN interno. Em seguida, para a tabela T1 não atenda à tabela T2 Cada linha da condição de conexão, onde T2 Se houver valores nulos na coluna, também será adicionada uma linha de conexão. Portanto, as tabelas conectadas em T1 Para cada linha.

A seguir está a sintaxe básica do JOIN externo esquerdo (LEFT OUTER JOIN):

SELECT ... FROM tabela1　LEFT OUTER JOIN table2　ON expressão_condicional...

Com base nas duas tabelas acima, podemos escrever um JOIN externo esquerdo, conforme abaixo:

w3codeboxdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
　emp_id　|　name　　|　　　　　　dept
--------+-------+----------------
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　2　|　Allen　|　Engineering
　　　　　　7　|　James　|　Finance
　　　　　　　　|　James　|　
　　　　　　　　|　David　|　
　　　　　　　　|　Paul　　|　
　　　　　　　　|　Kim　　　|　
　　　　　　　　|　Mark　　|　
　　　　　　　　|　Teddy　|　
　　　　　　　　|　James　|　
(10　rows)

Junção externa direita

Primeiro, execute a junção interna. Em seguida, para a tabela T2não atenda à tabela T1cada linha que atenda à condição de conexão, onde T1valores nulos na coluna também adicionam uma linha de conexão. Isso é contrário do vínculo esquerdo; para T2cada linha, a tabela de resultado sempre terá uma linha.

Abaixo está a sintaxe básica da junção externa direita (RIGHT OUT JOIN):

SELECT ... FROM tabela1　RIGHT OUTER JOIN tabela2　ON expressão_condicional...

Baseado nas duas tabelas acima, criamos uma junção externa direita:

w3codeboxdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
　emp_id　|　name　　|　　　　dept
--------+-------+-----------------
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　2　|　Allen　|　Engineering
　　　　　　7　|　James　|　Finance
(3　rows)

Junção externa

Primeiro, execute a junção interna. Em seguida, para a tabela T1 não atenda à tabela T2 qualquer linha que atenda à condição de junção T2 coluna com null também adiciona um ao resultado. Além disso, para T2 qualquer linha que não atenda à condição de junção T1 qualquer linha que atenda à condição de junção adiciona um T1 As colunas que contêm valores null são incluídas no resultado.

Abaixo está a sintaxe básica da junção externa:

SELECT ... FROM tabela1　FULL OUTER JOIN tabela2　ON expressão_condicional...

Baseado nas duas tabelas acima, podemos criar uma junção externa:

w3codeboxdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
　emp_id　|　name　　|　　　　　　dept
--------+-------+-----------------
　　　　　　1　|　Paul　　|　IT　Billing
　　　　　　2　|　Allen　|　Engineering
　　　　　　7　|　James　|　Finance
　　　　　　　　|　James　|　
　　　　　　　　|　David　|　
　　　　　　　　|　Paul　　|　
　　　　　　　　|　Kim　　　|　
　　　　　　　　|　Mark　　|　
　　　　　　　　|　Teddy　|　
　　　　　　　　|　James　|　
(10　rows)

Operador UNION do PostgreSQL Restrições do PostgreSQL