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.