Apache Tajo - Query SQL

Questo capitolo spiega le seguenti query significative.

  • Predicates
  • Explain
  • Join

Procediamo ed eseguiamo le query.

Predicati

Il predicato è un'espressione utilizzata per valutare i valori vero / falso e UNKNOWN. I predicati vengono utilizzati nella condizione di ricerca delle clausole WHERE e delle clausole HAVING e altri costrutti in cui è richiesto un valore booleano.

Predicato IN

Determina se il valore dell'espressione da testare corrisponde a qualsiasi valore nella sottoquery o nell'elenco. La sottoquery è un'istruzione SELECT ordinaria che ha un set di risultati di una colonna e una o più righe. Questa colonna o tutte le espressioni nell'elenco devono avere lo stesso tipo di dati dell'espressione da testare.

Syntax

IN::= 
<expression to test> [NOT] IN (<subquery>) 
| (<expression1>,...)

Query

select id,name,address from mytable where id in(2,3,4);

Result

La query precedente genererà il seguente risultato.

id,  name,   address 
------------------------------- 
2,  Amit,  12 old street 
3,  Bob,   10 cross street 
4,  David, 15 express avenue

La query restituisce record da mytable per gli studenti id 2,3 e 4.

Query

select id,name,address from mytable where id not in(2,3,4);

Result

La query precedente genererà il seguente risultato.

id,  name,  address 
------------------------------- 
1,  Adam,   23 new street 
5,  Esha,   20 garden street 
6,  Ganga,  25 north street 
7,  Jack,   2 park street 
8,  Leena,  24 south street 
9,  Mary,   5 west street 
10, Peter,  16 park avenue

La query precedente restituisce record da mytable dove gli studenti non sono in 2,3 e 4.

Come Predicate

Il predicato LIKE confronta la stringa specificata nella prima espressione per il calcolo del valore stringa, a cui si fa riferimento come valore da testare, con il modello definito nella seconda espressione per il calcolo del valore stringa.

Il modello può contenere qualsiasi combinazione di caratteri jolly come:

  • Simbolo di sottolineatura (_), che può essere utilizzato al posto di un singolo carattere nel valore da testare.

  • Segno di percentuale (%), che sostituisce qualsiasi stringa di zero o più caratteri nel valore da testare.

Syntax

LIKE::= 
<expression for calculating the string value> 
[NOT] LIKE 
<expression for calculating the string value> 
[ESCAPE <symbol>]

Query

select * from mytable where name like ‘A%';

Result

La query precedente genererà il seguente risultato.

id,  name,  address,     age,  mark 
------------------------------- 
1,  Adam,  23 new street,  12,  90 
2,  Amit,  12 old street,  13,  95

La query restituisce i record da mytable di quegli studenti i cui nomi iniziano con "A".

Query

select * from mytable where name like ‘_a%';

Result

La query precedente genererà il seguente risultato.

id,  name,  address,    age,  mark 
——————————————————————————————————————- 
4,  David,  15 express avenue,  12,  85 
6,  Ganga,  25 north street,    12,  55 
7,  Jack,  2 park street,       12,  60 
9,  Mary,  5 west street,       12,  75

La query restituisce record da mytable di quegli studenti i cui nomi iniziano con "a" come secondo carattere.

Utilizzo del valore NULL nelle condizioni di ricerca

Vediamo ora come utilizzare il valore NULL nelle condizioni di ricerca.

Syntax

Predicate  
IS [NOT] NULL

Query

select name from mytable where name is not null;

Result

La query precedente genererà il seguente risultato.

name 
------------------------------- 
Adam 
Amit 
Bob 
David 
Esha 
Ganga 
Jack 
Leena 
Mary 
Peter  
(10 rows, 0.076 sec, 163 B selected)

Qui, il risultato è vero quindi restituisce tutti i nomi dalla tabella.

Query

Controlliamo ora la query con la condizione NULL.

default> select name from mytable where name is null;

Result

La query precedente genererà il seguente risultato.

name 
------------------------------- 
(0 rows, 0.068 sec, 0 B selected)

Spiegare

Explainviene utilizzato per ottenere un piano di esecuzione della query. Mostra l'esecuzione del piano logico e globale di un'istruzione.

Query del piano logico

explain select * from mytable;  
explain 
-------------------------------  
   => target list: default.mytable.id (INT4), default.mytable.name (TEXT), 
      default.mytable.address (TEXT), default.mytable.age (INT4), default.mytable.mark (INT4) 
   
   => out schema: {
   (5) default.mytable.id (INT4), default.mytable.name (TEXT), default.mytable.address (TEXT), 
      default.mytable.age (INT4), default.mytable.mark (INT4)
   } 
   
   => in schema: {
	(5) default.mytable.id (INT4), default.mytable.name (TEXT), default.mytable.address (TEXT), 
      default.mytable.age (INT4), default.mytable.mark (INT4)
   }

Result

La query precedente genererà il seguente risultato.

Il risultato della query mostra un formato del piano logico per la tabella data. Il piano logico restituisce i seguenti tre risultati:

  • Elenco di destinazione
  • Fuori schema
  • Nello schema

Query del piano globale

explain global select * from mytable;  
explain 
------------------------------- 
------------------------------------------------------------------------------- 
Execution Block Graph (TERMINAL - eb_0000000000000_0000_000002) 
------------------------------------------------------------------------------- 
|-eb_0000000000000_0000_000002 
   |-eb_0000000000000_0000_000001 
------------------------------------------------------------------------------- 
Order of Execution 
------------------------------------------------------------------------------- 
1: eb_0000000000000_0000_000001 
2: eb_0000000000000_0000_000002 
-------------------------------------------------------------------------------  
======================================================= 
Block Id: eb_0000000000000_0000_000001 [ROOT] 
=======================================================  
SCAN(0) on default.mytable 
   
   => target list: default.mytable.id (INT4), default.mytable.name (TEXT), 
      default.mytable.address (TEXT), default.mytable.age (INT4), default.mytable.mark (INT4) 
   
   => out schema: {
	(5) default.mytable.id (INT4), default.mytable.name (TEXT),default.mytable.address (TEXT), 
      default.mytable.age (INT4), default.mytable.mark (INT4)
   } 
   
   => in schema: {
	(5) default.mytable.id (INT4), default.mytable.name (TEXT), default.mytable.address (TEXT), 
      default.mytable.age (INT4), default.mytable.mark (INT4)
   }  
======================================================= 
Block Id: eb_0000000000000_0000_000002 [TERMINAL] 
======================================================= 
(24 rows, 0.065 sec, 0 B selected)

Result

La query precedente genererà il seguente risultato.

Qui, il piano globale mostra l'ID del blocco di esecuzione, l'ordine di esecuzione e le sue informazioni.

Si unisce

I join SQL vengono utilizzati per combinare righe da due o più tabelle. Di seguito sono riportati i diversi tipi di join SQL:

  • Unione interna
  • {SINISTRA | DESTRA | FULL} OUTER JOIN
  • Cross join
  • Self join
  • Unione naturale

Considera le due tabelle seguenti per eseguire operazioni di join.

Tabella 1 - Clienti

Id Nome Indirizzo Età
1 Cliente 1 23 Old Street 21
2 Cliente 2 12 New Street 23
3 Cliente 3 10 Express Avenue 22
4 Cliente 4 15 Express Avenue 22
5 Cliente 5 20 Garden Street 33
6 Cliente 6 21 North Street 25

Tabella2 - cliente_ordine

Id ID ordine Emp Id
1 1 101
2 2 102
3 3 103
4 4 104
5 5 105

Procediamo ora ed eseguiamo le operazioni di join SQL sulle due tabelle precedenti.

Inner Join

Il join interno seleziona tutte le righe da entrambe le tabelle quando c'è una corrispondenza tra le colonne in entrambe le tabelle.

Syntax

SELECT column_name(s) FROM table1 INNER JOIN table2 ON table1.column_name = table2.column_name;

Query

default> select c.age,c1.empid from customers c inner join customer_order c1 on c.id = c1.id;

Result

La query precedente genererà il seguente risultato.

age,  empid 
------------------------------- 
21,  101 
23,  102 
22,  103 
22,  104 
33,  105

La query corrisponde a cinque righe di entrambe le tabelle. Quindi, restituisce l'età delle righe corrispondenti dalla prima tabella.

Join esterno sinistro

Un join esterno sinistro conserva tutte le righe della tabella "sinistra", indipendentemente dal fatto che esista una riga che corrisponde o meno alla tabella "destra".

Query

select c.name,c1.empid from customers c left outer join customer_order c1 on c.id = c1.id;

Result

La query precedente genererà il seguente risultato.

name,       empid 
------------------------------- 
customer1,  101 
customer2,  102 
customer3,  103 
customer4,  104 
customer5,  105 
customer6,

Qui, il join esterno sinistro restituisce le righe della colonna del nome dalla tabella dei clienti (a sinistra) e le righe corrispondenti alla colonna empid dalla tabella customer_order (a destra).

Right Outer Join

Un join esterno destro conserva tutte le righe della tabella "destra", indipendentemente dal fatto che esista una riga che corrisponde alla tabella "sinistra".

Query

select c.name,c1.empid from customers c right outer join customer_order c1 on c.id = c1.id;

Result

La query precedente genererà il seguente risultato.

name,      empid 
------------------------------- 
customer1,  101 
customer2,  102 
customer3,  103 
customer4,  104 
customer5,  105

Qui, Right Outer Join restituisce le righe empid dalla tabella customer_order (a destra) e le righe corrispondenti alla colonna del nome dalla tabella clienti.

Join esterno completo

Il Full Outer Join mantiene tutte le righe della tabella di sinistra e di destra.

Query

select * from customers c full outer join customer_order c1 on c.id = c1.id;

Result

La query precedente genererà il seguente risultato.

La query restituisce tutte le righe corrispondenti e non corrispondenti sia dai clienti che dalle tabelle customer_order.

Cross Join

Restituisce il prodotto cartesiano dei set di record delle due o più tabelle unite.

Syntax

SELECT *  FROM table1  CROSS JOIN table2;

Query

select orderid,name,address from customers,customer_order;

Result

La query precedente genererà il seguente risultato.

La query precedente restituisce il prodotto cartesiano della tabella.

Natural Join

Un Natural Join non utilizza alcun operatore di confronto. Non concatena come fa un prodotto cartesiano. Possiamo eseguire un Natural Join solo se tra le due relazioni esiste almeno un attributo comune.

Syntax

SELECT * FROM table1 NATURAL JOIN table2;

Query

select * from customers natural join customer_order;

Result

La query precedente genererà il seguente risultato.

Qui, c'è un ID colonna comune che esiste tra due tabelle. Usando quella colonna comune, ilNatural Join unisce entrambe le tabelle.

Self Join

SQL SELF JOIN viene utilizzato per unire una tabella a se stessa come se la tabella fosse due tabelle, rinominando temporaneamente almeno una tabella nell'istruzione SQL.

Syntax

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

Query

default> select c.id,c1.name from customers c, customers c1 where c.id = c1.id;

Result

La query precedente genererà il seguente risultato.

id,   name 
------------------------------- 
1,   customer1 
2,   customer2 
3,   customer3 
4,   customer4 
5,   customer5 
6,   customer6

La query unisce una tabella cliente a se stessa.