HSQLDB: uniones

Siempre que sea necesario recuperar datos de varias tablas mediante una sola consulta, puede utilizar JOINS desde RDBMS. Puede utilizar varias tablas en su única consulta SQL. El acto de unirse en HSQLDB se refiere a romper dos o más tablas en una sola tabla.

Considere las siguientes tablas de Clientes y Pedidos.

Customer:
+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |    MP     |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+
Orders:
+-----+---------------------+-------------+--------+
|OID  |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Ahora, intentemos recuperar los datos de los clientes y el monto del pedido que realizó el cliente respectivo. Esto significa que estamos recuperando los datos de registro tanto de clientes como de la tabla de pedidos. Podemos lograr esto usando el concepto JOINS en HSQLDB. A continuación se muestra la consulta JOIN para el mismo.

SELECT ID, NAME, AGE, AMOUNT FROM CUSTOMERS, ORDERS WHERE CUSTOMERS.ID =
ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+-----+--------+
| ID |   NAME   | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |  3000  |
|  3 | kaushik  |  23 |  1500  |
|  2 | Khilan   |  25 |  1560  |
|  4 | Chaitali |  25 |  2060  |
+----+----------+-----+--------+

Tipos de JOIN

Hay diferentes tipos de combinaciones disponibles en HSQLDB.

INNER JOIN - Devuelve las filas cuando hay una coincidencia en ambas tablas.
LEFT JOIN - Devuelve todas las filas de la tabla de la izquierda, incluso si no hay coincidencias en la tabla de la derecha.
RIGHT JOIN - Devuelve todas las filas de la tabla de la derecha, incluso si no hay coincidencias en la tabla de la izquierda.
FULL JOIN - Devuelve las filas cuando hay una coincidencia en una de las tablas.
SELF JOIN - Se utiliza para unir una tabla consigo misma como si fueran dos tablas, cambiando temporalmente el nombre de al menos una tabla en la declaración SQL.

Unir internamente

La combinación más utilizada e importante es la INNER JOIN. También se conoce como EQUIJOIN.

INNER JOIN crea una nueva tabla de resultados combinando los valores de columna de dos tablas (table1 y table2) según el predicado de unión. La consulta compara cada fila de table1 con cada fila de table2 para encontrar todos los pares de filas que satisfacen el predicado de unión. Cuando se satisface el predicado de unión, los valores de columna para cada par coincidente de filas A y B se combinan en una fila de resultados.

Sintaxis

La sintaxis básica de INNER JOIN es la siguiente.

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

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |     MP    | 4500.00  |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      | 3000   |
| 100 | 2009-10-08 00:00:00 |      3      | 1500   |
| 101 | 2009-11-20 00:00:00 |      2      | 1560   |
| 103 | 2008-05-20 00:00:00 |      4      | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta INNER JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
| 3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
| 3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
| 2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
| 4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

Unión a la izquierda

HSQLDB LEFT JOIN devuelve todas las filas de la tabla izquierda, incluso si no hay coincidencias en la tabla derecha. Esto significa que si la cláusula ON coincide con 0 (cero) registros en la tabla de la derecha, la combinación seguirá devolviendo una fila en el resultado, pero con NULL en cada columna de la tabla de la derecha.

Esto significa que una combinación izquierda devuelve todos los valores de la tabla izquierda, más los valores coincidentes de la tabla derecha o NULL en caso de que no haya un predicado de combinación coincidente.

Sintaxis

La sintaxis básica de LEFT JOIN es la siguiente:

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

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |    MP     | 4500.00  |
| 7  |  Muffy   | 24  |  Indore   | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |        DATE         | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |     3       | 3000   |
| 100 | 2009-10-08 00:00:00 |     3       | 1500   |
| 101 | 2009-11-20 00:00:00 |     2       | 1560   |
| 103 | 2008-05-20 00:00:00 |     4       | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta LEFT JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
|  1 |  Ramesh  |  NULL  |        NULL         |
|  2 |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  3 |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3 |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  4 | Chaitali |  2060  | 2008-05-20 00:00:00 |
|  5 |  Hardik  |  NULL  |        NULL         |
|  6 |  Komal   |  NULL  |        NULL         |
|  7 |  Muffy   |  NULL  |        NULL         |
+----+----------+--------+---------------------+

Unión derecha

HSQLDB RIGHT JOIN devuelve todas las filas de la tabla derecha, incluso si no hay coincidencias en la tabla izquierda. Esto significa que si la cláusula ON coincide con 0 (cero) registros en la tabla de la izquierda, la combinación seguirá devolviendo una fila en el resultado, pero con NULL en cada columna de la tabla de la izquierda.

Esto significa que una combinación derecha devuelve todos los valores de la tabla derecha, más los valores coincidentes de la tabla izquierda o NULL en caso de que no haya un predicado de combinación coincidente.

Sintaxis

La sintaxis básica de RIGHT JOIN es como sigue -

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

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |     MP    |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |       DATE          | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta RIGHT JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------+--------+---------------------+
|  ID  |   NAME   | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|  3   |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3   |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  2   |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  4   | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Unión completa

HSQLDB FULL JOIN combina los resultados de las combinaciones externas izquierda y derecha.

La tabla unida contendrá todos los registros de ambas tablas y completará los NULL para las coincidencias que faltan en cada lado.

Sintaxis

La sintaxis básica de FULL JOIN es la siguiente:

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

Aquí, la condición dada podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  | 32  | Ahmedabad | 2000.00  |
|  2 |  Khilan  | 25  |   Delhi   | 1500.00  |
|  3 |  kaushik | 23  |   Kota    | 2000.00  |
|  4 | Chaitali | 25  |   Mumbai  | 6500.00  |
|  5 |  Hardik  | 27  |   Bhopal  | 8500.00  |
|  6 |  Komal   | 22  |   MP      | 4500.00  |
|  7 |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |    3        | 3000   |
| 100 | 2009-10-08 00:00:00 |    3        | 1500   |
| 101 | 2009-11-20 00:00:00 |    2        | 1560   |
| 103 | 2008-05-20 00:00:00 |    4        | 2060   |
+-----+---------------------+-------------+--------+

Ahora, unamos estas dos tablas usando la consulta FULL JOIN de la siguiente manera:

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado.

+------+----------+--------+---------------------+
|  ID  |    NAME  | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|   1  |  Ramesh  |  NULL  |        NULL         |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
|   5  |  Hardik  |  NULL  |        NULL         |
|   6  |   Komal  |  NULL  |        NULL         |
|   7  |   Muffy  |  NULL  |        NULL         |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Auto unión

SQL SELF JOIN se utiliza para unir una tabla consigo misma como si fueran dos tablas, cambiando temporalmente el nombre de al menos una tabla en la declaración SQL.

Sintaxis

La sintaxis básica de SELF JOIN es la siguiente:

SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_field = b.common_field;

Aquí, la cláusula WHERE podría ser cualquier expresión dada según su requisito.

Ejemplo

Considere las siguientes dos tablas, una titulada como tabla CLIENTES y otra titulada como tabla PEDIDOS de la siguiente manera:

+----+----------+-----+-----------+----------+
| ID |    NAME  | AGE |   ADDRESS |   SALARY |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  |  32 | Ahmedabad | 2000.00  |
|  2 |  Khilan  |  25 |   Delhi   | 1500.00  |
|  3 |  kaushik |  23 |   Kota    | 2000.00  |
|  4 | Chaitali |  25 |   Mumbai  | 6500.00  |
|  5 |  Hardik  |  27 |   Bhopal  | 8500.00  |
|  6 |  Komal   |  22 |   MP      | 4500.00  |
|  7 |  Muffy   |  24 |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

Ahora, unámonos a esta tabla usando la consulta SELF JOIN de la siguiente manera:

SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY > b.SALARY;

Después de la ejecución de la consulta anterior, recibirá el siguiente resultado:

+----+----------+---------+
| ID |   NAME   | SALARY  |
+----+----------+---------+
| 2  |  Ramesh  | 1500.00 |
| 2  |  kaushik | 1500.00 |
| 1  | Chaitali | 2000.00 |
| 2  | Chaitali | 1500.00 |
| 3  | Chaitali | 2000.00 |
| 6  | Chaitali | 4500.00 |
| 1  |  Hardik  | 2000.00 |
| 2  |  Hardik  | 1500.00 |
| 3  |  Hardik  | 2000.00 |
| 4  |  Hardik  | 6500.00 |
| 6  |  Hardik  | 4500.00 |
| 1  |  Komal   | 2000.00 |
| 2  |  Komal   | 1500.00 |
| 3  |  Komal   | 2000.00 |
| 1  |  Muffy   | 2000.00 |
| 2  |  Muffy   | 1500.00 |
| 3  |  Muffy   | 2000.00 |
| 4  |  Muffy   | 6500.00 |
| 5  |  Muffy   | 8500.00 |
| 6  |  Muffy   | 4500.00 |
+----+----------+---------+

↰ Previous page Next page ↱