4D v15

Suporte de joins

Página Inicial

 
Página Inicial
4D v15
Manual de SQL
Utilizar SQL em 4D
Suporte de joins

Suporte de joins  


 

 

O motor SQL de 4D amplia o suporte das sentenças join.

As sentenças join podem ser internas ou externas, implícitas ou explícitas. As joins internas (INNER joins) implícitas são suportadas pelo comando SELECT. Também pode gerar joins internas e externas explícitas utilizando a palavra chave SQL JOIN.

Nota: A implementação atual de joins no motor SQL de 4D não inclui:

  • joins naturais.
  • o construtor USING nas joins internas.
  • joins cruzadas internas.

As sentenças join permitem fazer conexões entre os registros de duas ou mais tabelas e combinar o resultado em uma tabela nova, chamada join.

Gere joins via as instruções SELECT que especificam as condições de join. Com as joins explícitas, estas condições podem ser complexas, mas sempre devem ser baseadas em uma comparação de igualdade entre as colunas incluídas na join. Por exemplo, não é possível utilizar o operador >= em uma condição de join explícita. Todo tipo de comparação pode ser utilizada em uma join implícita.
Internamente, as comparações de igualdade são realizadas diretamente pelo motor de 4D, que garante uma rápida execução.

Nota: Geralmente, no motor do banco de dados, a ordem das tabelas está determinada pela ordem definida durante a pesquisa. No entanto, ao usar combinações, a ordem das tabelas são determinadas pela lista de tabelas. No seguinte exemplo:
SELECT * FROM T1 RIGHT OUTER JOIN T2 ON = T2.depID T1.depID;
... a ordem das tabelas é T1 e depois T2 (tal como aparecem na lista de tabelas) e não T1 e depois T2 (tal como aparecem na condição de join).

Para ilustrar como funcionam as junções, vamos usar os bancos de dados abaixo nessa seção:

  • Employees
    namedepIDcityID
    Alan1030
    Anne1139
    Bernard1033
    Fabrice1235
    Martin1530
    PhilipNULL33
    Thomas10NULL
  • Departments
    depIDdepName
    10Program
    11Engineering
    NULLMarketing
    12Development
    13Quality
  • Cities
    cityIDcityName
    30Paris
    33New York
    NULLBerlin

Se quiser, pode gerar este banco de dados automaticamente ao executar o código abaixo:

 Begin SQL
         DROP TABLE IF EXISTS Employees;
         CREATE TABLE Employees ( depID INT32, name VARCHAR, cityID INT32);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Alan', 10, 30);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Anne', 11, 39);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Bernard', 10, 33);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Fabrice', 12, 35);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Martin', 15, 30);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Philip', NULL, 33);
         INSERT INTO Employees (name, depID, cityID) VALUES ('Thomas', 10, NULL);
 
         DROP TABLE IF EXISTS Departments;
         CREATE TABLE Departments ( depID INT32, depName VARCHAR );
         INSERT INTO Departments (depID, depName) VALUES (10, 'Program');
         INSERT INTO Departments (depID, depName) VALUES (11, 'Engineering');
         INSERT INTO Departments (depID, depName) VALUES (NULL, 'Marketing');
         INSERT INTO Departments (depID, depName) VALUES (12, 'Development');
         INSERT INTO Departments (depID, depName) VALUES (13, 'Quality');
 
         DROP TABLE IF EXISTS Cities;
         CREATE TABLE Cities ( cityID INT32, cityName VARCHAR );
         INSERT INTO Cities (cityID, cityName) VALUES (30, 'Paris');
         INSERT INTO Cities (cityID, cityName) VALUES (33, 'New York');
         INSERT INTO Cities (cityID, cityName) VALUES (NULL, 'Berlin');
 End SQL

Uma junção interna (INNER JOIN)é baseada em uma comparação para achar coincidências entre duas colunas.

Aqui é um exemplo de uma junção interna implícita:

SELECT *  
        FROM employees, departments
        WHERE employees.DepID = departments.DepID;

Em 4D, pode também usar a palavra chave JOIN para especificar uma junção interna explícita:

SELECT *
        FROM employees
        INNER JOIN departments
            ON employees.DepID = departments.DepID;

Pode inserir esta pesquisa no código 4D como mostrado abaixo:

 ARRAY TEXT(aName;0)
 ARRAY TEXT(aDepName;0)
 ARRAY INTEGER(aEmpDepID;0)
 ARRAY INTEGER(aDepID;0)
 Begin SQL
        SELECT Employees.name, Employees.depID, Departments.depID, Departments.depName
        FROM Employees
                INNER JOIN Departments
                    ON Employees.depID = Departments.depID
                INTO :aName, :aEmpDepID, :aDepID, :aDepName;
 End SQL

Aqui estão os resultado a unir:

aNameaEmpDepIDaDepIDaDepName
Alan1010Program
Anne1111Engineering
Bernard1010Program
Mark1212Development
Thomas1010Program

Note que nem os empregados chamados Philip ou Martin nem os departamentos de Marketing ou Qualidade aparecem nos resultados unidos porque:

  • Philip não tem um departamento associado com seu nome (NULL value),
  • A ID do departamento associado com o nome de Martin não existe na tabela Departamentos,
  • Não há nenhum empregado associado com o Departamento de Qualidade  (ID 13),
  • O departamento de Marketing não tem nenhuma ID associada (NULL value).

Agora pode gerar joins externas com 4D (OUTER JOINs). Em uma join externa, não é necessário que tenha uma correspondência entre as linhas das tabelas combinadas. A tabela resultante contém todas as linhas das tabelas (ou de pelo menos uma das tabelas combinadas), inclusive se não há linhas correspondentes. Isto significa que toda a informação de uma tabela pode ser utilizada, ainda que as linhas não enchem completamente entre as diferentes tabelas unidas.

Há três tipos de joins externas, definidas pelas palavras chaves LEFT, RIGHT e FULL. LEFT e RIGHT se utilizam para indicar a tabela (localizada a esquerda ou a direita da palavra chave JOIN) na que todos os dados devem ser processados. FULL indica uma join externa bilateral.

Nota: Somente as joins externas explícitas são suportadas por 4D.

O resultado de uma join externa esquerda (ou left join) sempre contém todos os registros da tabela situada a esquerda da palavra chave, inclusive se a condição de join não encontra um registro correspondente na tabela a direita. Isto significa que para cada linha da tabela da esquerda, onde a pesquisa não encontra nenhuma linha correspondente na tabela da direita, a join vai conter a linha com valores NULL para cada coluna da tabela da direita. Em outras palavras, uma join externa esquerda devolve todas as linhas da tabela da esquerda, além das da tabela da direita que correspondam a condição de join (ou NULL se nenhuma corresponde). Tenha em conta que se a tabela da direita contém mais de uma linha que corresponde com o predicado da join para uma linha da tabela da esquerda, os valores da tabela esquerda serão repetidas para cada linha diferente da tabela direita.


Este é um exemplo de código 4D com uma join externa esquerda:

 ARRAY TEXT(aName;0)
 ARRAY TEXT(aDepName;0)
 ARRAY INTEGER(aEmpDepID;0)
 ARRAY INTEGER(aDepID;0)
 Begin SQL
        SELECT Employees.name, Employees.depID, Departments.depID, Departments.depName
            FROM Employees
            LEFT OUTER JOIN Departments
                ON Employees.DepID = Departments.DepID;
                INTO :aName, :aEmpDepID, :aDepID, :aDepName;
 End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais são mostradas em vermelho):

aNameaEmpDepIDaDepIDaDepName
Alan1010Program
Anne1111Engineering
Bernard1010Program
Mark1212Development
Thomas1010Program
Martin15NULLNULL
PhilipNULLNULLNULL

Uma join externa direita é o oposto exato de uma join externa esquerda. Seu resultado sempre contém todos os registros da tabela localizada a direita da palavra chave JOIN inclusive se a condição join não encontra um registro correspondente na tabela esquerda.

Este é um exemplo de código 4D com uma join externa direita:

 ARRAY TEXT(aName;0)
 ARRAY TEXT(aDepName;0)
 ARRAY INTEGER(aEmpDepID;0)
 ARRAY INTEGER(aDepID;0)
 Begin SQL
        SELECT Employees.name, Employees.depID, Departments.depID, Departments.depName
            FROM Employees
            RIGHT OUTER JOIN Departments
                ON Employees.DepID = Departments.DepID;
                INTO :aName, :aEmpDepID, :aDepID, :aDepName;
 End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais estão em vermelho):

aNameaEmpDepIDaDepIDaDepName
Alan1010Program
Anne1111Engineering
Bernard1010Program
Mark1212Development
Thomas1010Program
NULLNULLNULLMarketing
NULLNULL13Quality

Uma join externa bilateral combina os resultados de uma join externa esquerda e de uma join externa direita. A tabela join resultante contém todos os registros das tabelas esquerda e direita e enche os campos que faltam de cada lado valores NULL.

Este é um exemplo de código 4D com uma join externa bilateral:

 ARRAY TEXT(aName;0)
 ARRAY TEXT(aDepName;0)
 ARRAY INTEGER(aEmpDepID;0)
 ARRAY INTEGER(aDepID;0)
 Begin SQL
        SELECT Employees.name, Employees.depID, Departments.depID, Departments.depName
            FROM Employees
            FULL OUTER JOIN Departments
                ON Employees.DepID = Departments.DepID;
                INTO :aName, :aEmpDepID, :aDepID, :aDepName;
 End SQL

Este é o resultado desta join com nossa base de exemplo (as linhas adicionais são mostradas em vermelho):

aNameaEmpDepIDaDepIDaDepName
Alan1010Program
Anne1111Engineering
Bernard1010Program
Mark1212Development
Thomas1010Program
Martin15NULLNULL
PhilipNULLNULLNULL
NULLNULLNULLMarketing
NULLNULL13Quality

anterior
seguido

 
PROPRIEDADES 

Produto: 4D
Tema: Utilizar SQL em 4D

 
HISTÓRIA 

 
ARTICLE USAGE

Manual de SQL ( 4D v15)