Impala - Guida rapida

Cos'è l'Impala?

Impala è un motore di query SQL MPP (Massive Parallel Processing) per l'elaborazione di enormi volumi di dati archiviati nel cluster Hadoop. È un software open source scritto in C ++ e Java. Fornisce prestazioni elevate e bassa latenza rispetto ad altri motori SQL per Hadoop.

In altre parole, Impala è il motore SQL con le prestazioni più elevate (che offre un'esperienza simile a RDBMS) che fornisce il modo più veloce per accedere ai dati archiviati in Hadoop Distributed File System.

Perché Impala?

Impala combina il supporto SQL e le prestazioni multiutente di un database analitico tradizionale con la scalabilità e la flessibilità di Apache Hadoop, utilizzando componenti standard come HDFS, HBase, Metastore, YARN e Sentry.

Con Impala, gli utenti possono comunicare con HDFS o HBase utilizzando le query SQL in modo più veloce rispetto ad altri motori SQL come Hive.
Impala può leggere quasi tutti i formati di file come Parquet, Avro, RCFile utilizzati da Hadoop.

Impala utilizza gli stessi metadati, sintassi SQL (Hive SQL), driver ODBC e interfaccia utente (Hue Beeswax) di Apache Hive, fornendo una piattaforma familiare e unificata per query in batch o in tempo reale.

A differenza di Apache Hive, Impala is not based on MapReduce algorithms. Implementa un'architettura distribuita basata sudaemon processes responsabili di tutti gli aspetti dell'esecuzione delle query eseguite sulle stesse macchine.

Pertanto, riduce la latenza dell'utilizzo di MapReduce e questo rende Impala più veloce di Apache Hive.

Vantaggi di Impala

Ecco un elenco di alcuni noti vantaggi di Cloudera Impala.

Utilizzando impala, puoi elaborare i dati archiviati in HDFS a una velocità fulminea con la conoscenza SQL tradizionale.
Poiché l'elaborazione dei dati viene effettuata dove risiedono i dati (sul cluster Hadoop), la trasformazione e lo spostamento dei dati non sono necessari per i dati archiviati su Hadoop, mentre si lavora con Impala.
Utilizzando Impala, puoi accedere ai dati archiviati in HDFS, HBase e Amazon s3 senza la conoscenza di Java (lavori MapReduce). Puoi accedervi con un'idea di base delle query SQL.
Per scrivere query negli strumenti aziendali, i dati devono essere sottoposti a un complicato ciclo di estrazione-trasformazione-caricamento (ETL). Ma, con Impala, questa procedura è abbreviata. Le lunghe fasi di caricamento e riorganizzazione vengono superate con le nuove tecniche comeexploratory data analysis & data discovery rendendo il processo più veloce.
Impala sta sperimentando l'uso del formato di file Parquet, un layout di archiviazione a colonne ottimizzato per query su larga scala tipiche degli scenari di data warehouse.

Caratteristiche di Impala

Di seguito sono riportate le caratteristiche di cloudera Impala:

Impala è disponibile gratuitamente come open source con la licenza Apache.
Impala supporta l'elaborazione dei dati in memoria, ovvero accede / analizza i dati archiviati sui nodi di dati Hadoop senza spostamento dei dati.
È possibile accedere ai dati utilizzando Impala utilizzando query di tipo SQL.
Impala fornisce un accesso più rapido ai dati in HDFS rispetto ad altri motori SQL.
Utilizzando Impala, puoi archiviare i dati in sistemi di archiviazione come HDFS, Apache HBase e Amazon s3.
Puoi integrare Impala con strumenti di business intelligence come Tableau, Pentaho, Micro strategy e Zoom data.
Impala supporta vari formati di file come LZO, Sequence File, Avro, RCFile e Parquet.
Impala utilizza metadati, driver ODBC e sintassi SQL di Apache Hive.

Database relazionali e Impala

Impala utilizza un linguaggio Query simile a SQL e HiveQL. La tabella seguente descrive alcune delle differenze chiave tra SQL e il linguaggio Impala Query.

Impala	Database relazionali
Impala utilizza un linguaggio di query simile a SQL che è simile a HiveQL.	I database relazionali utilizzano il linguaggio SQL.
In Impala, non è possibile aggiornare o eliminare singoli record.	Nei database relazionali è possibile aggiornare o eliminare singoli record.
Impala non supporta le transazioni.	I database relazionali supportano le transazioni.
Impala non supporta l'indicizzazione.	I database relazionali supportano l'indicizzazione.
Impala archivia e gestisce grandi quantità di dati (petabyte).	I database relazionali gestiscono quantità minori di dati (terabyte) rispetto a Impala.

Hive, Hbase e Impala

Sebbene Cloudera Impala utilizzi lo stesso linguaggio di query, metastore e interfaccia utente di Hive, differisce da Hive e HBase in alcuni aspetti. La tabella seguente presenta un'analisi comparativa tra HBase, Hive e Impala.

HBase	Alveare	Impala
HBase è un database di archivi a colonne larghe basato su Apache Hadoop. Utilizza i concetti di BigTable.	Hive è un software di data warehouse. Usando questo, possiamo accedere e gestire grandi set di dati distribuiti, costruiti su Hadoop.	Impala è uno strumento per gestire, analizzare i dati archiviati su Hadoop.
Il modello dati di HBase è un archivio di colonne larghe.	Hive segue il modello relazionale.	Impala segue il modello relazionale.
HBase è sviluppato utilizzando il linguaggio Java.	Hive è sviluppato utilizzando il linguaggio Java.	Impala è sviluppato utilizzando C ++.
Il modello di dati di HBase è privo di schemi.	Il modello di dati di Hive è basato su Schema.	Il modello di dati di Impala è basato su Schema.
HBase fornisce API Java, RESTful e Thrift.	Hive fornisce JDBC, ODBC, API Thrift.	Impala fornisce API JDBC e ODBC.
Supporta linguaggi di programmazione come C, C #, C ++, Groovy, Java PHP, Python e Scala.	Supporta linguaggi di programmazione come C ++, Java, PHP e Python.	Impala supporta tutte le lingue che supportano JDBC / ODBC.
HBase fornisce supporto per i trigger.	Hive non fornisce alcun supporto per i trigger.	Impala non fornisce alcun supporto per i trigger.

Tutti questi tre database -

Sono database NOSQL.
Disponibile come open source.
Supporta lo scripting lato server.
Segui le proprietà ACID come Durabilità e Concorrenza.
Uso sharding per partitioning.

Inconvenienti di Impala

Alcuni degli svantaggi dell'utilizzo di Impala sono i seguenti:

Impala non fornisce alcun supporto per la serializzazione e la deserializzazione.
Impala può leggere solo file di testo, non file binari personalizzati.
Ogni volta che vengono aggiunti nuovi record / file alla directory dei dati in HDFS, la tabella deve essere aggiornata.

Questo capitolo spiega i prerequisiti per l'installazione di Impala, come scaricare, installare e configurare Impala nel tuo sistema.

Simile a Hadoop e al suo software ecosistema, dobbiamo installare Impala sul sistema operativo Linux. Poiché cloudera ha spedito Impala, è disponibile conCloudera Quick Start VM.

Questo capitolo descrive come eseguire il download Cloudera Quick Start VM e avvia Impala.

Download di Cloudera Quick Start VM

Seguire i passaggi indicati di seguito per scaricare l'ultima versione di Cloudera QuickStartVM.

Passo 1

Apri la home page del sito web di cloudera http://www.cloudera.com/. Otterrai la pagina come mostrato di seguito.

Passo 2

Clicca il Sign in link sulla home page di cloudera, che ti reindirizzerà alla pagina di accesso come mostrato di seguito.

Se non sei ancora registrato, fai clic su Register Now link che ti darà Account Registrationmodulo. Registrati lì e accedi all'account cloudera.

Passaggio 3

Dopo aver effettuato l'accesso, apri la pagina di download del sito Web di cloudera facendo clic su Downloads collegamento evidenziato nella seguente istantanea.

Passaggio 4: scarica QuickStartVM

Scarica il cloudera QuickStartVM facendo clic sul file Download Now pulsante, come evidenziato nella seguente istantanea

Questo ti reindirizzerà alla pagina di download di QuickStart VM.

Clicca il Get ONE NOW , accetta il contratto di licenza e fai clic sul pulsante di invio come mostrato di seguito.

Cloudera fornisce VMware, KVM e VIRTUALBOX compatibili con le VM. Seleziona la versione richiesta. Qui nel nostro tutorial, stiamo dimostrando ilCloudera QuickStartVM configurazione utilizzando la casella virtuale, quindi fare clic su VIRTUALBOX DOWNLOAD pulsante, come mostrato nell'istantanea riportata di seguito.

Questo inizierà a scaricare un file denominato cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf che è un file immagine della scatola virtuale.

Importazione di Cloudera QuickStartVM

Dopo aver scaricato il file cloudera-quickstart-vm-5.5.0-0-virtualbox.ovffile, dobbiamo importarlo utilizzando la casella virtuale. Per questo, prima di tutto, devi installare la scatola virtuale nel tuo sistema. Seguire i passaggi indicati di seguito per importare il file immagine scaricato.

Passo 1

Scarica la scatola virtuale dal seguente link e installala https://www.virtualbox.org/

Passo 2

Apri il software della scatola virtuale. ClicFile e scegli Import Appliance, come mostrato di seguito.

Passaggio 3

Facendo clic Import Appliance, verrà visualizzata la finestra Importa dispositivo virtuale. Seleziona la posizione del file immagine scaricato come mostrato di seguito.

Dopo l'importazione Cloudera QuickStartVMimmagine, avvia la macchina virtuale. Questa macchina virtuale ha Hadoop, cloudera Impala e tutto il software richiesto installato. L'istantanea della VM è mostrata di seguito.

Avvio di Impala Shell

Per avviare Impala, apri il terminale ed esegui il seguente comando.

[[email protected] ~] $ impala-shell

Questo avvierà Impala Shell, visualizzando il seguente messaggio.

Starting Impala Shell without Kerberos authentication 
Connected to quickstart.cloudera:21000 
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build
0c891d79aa38f297d244855a32f1e17280e2129b) 
********************************************************************************
 Welcome to the Impala shell. Copyright (c) 2015 Cloudera, Inc. All rights reserved. 
(Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9 12:18:12 PST 2015)
 
Press TAB twice to see a list of available commands. 
******************************************************************************** 
[quickstart.cloudera:21000] >

Note - Discuteremo tutti i comandi impala-shell nei capitoli successivi.

Editor di query Impala

Inoltre Impala shell, puoi comunicare con Impala utilizzando il browser Hue. Dopo aver installato CDH5 e avviato Impala, se apri il browser, otterrai la home page di cloudera come mostrato di seguito.

Ora fai clic sul segnalibro Hueper aprire il browser Hue. Facendo clic, è possibile visualizzare la pagina di accesso del browser Hue, effettuando l'accesso con le credenziali cloudera e cloudera.

Non appena si accede al browser Hue, è possibile visualizzare la procedura guidata di avvio rapido del browser Hue come mostrato di seguito.

Facendo clic su Query Editors menu a discesa, otterrai l'elenco degli editor supportati da Impala come mostrato nello screenshot seguente.

Facendo clic Impala nel menu a discesa, otterrai l'editor di query Impala come mostrato di seguito.

Impala è un motore di esecuzione di query MPP (Massive Parallel Processing) che viene eseguito su numerosi sistemi nel cluster Hadoop. A differenza dei sistemi di archiviazione tradizionali, impala è disaccoppiato dal suo motore di archiviazione. Ha tre componenti principali e cioè, Impala daemon (Impalad) , Impala Statestore e Impala metadata o metastore.

Demone Impala ( Impalad )

Demone Impala (noto anche come impalad) viene eseguito su ogni nodo in cui è installato Impala. Accetta le query da varie interfacce come impala shell, hue browser, ecc ... e le elabora.

Ogni volta che una query viene inviata a un impalad su un particolare nodo, quel nodo funge da "coordinator node"Per quella query. Più query vengono servite da Impalad in esecuzione anche su altri nodi. Dopo aver accettato la query, Impalad legge e scrive su file di dati e parallelizza le query distribuendo il lavoro agli altri nodi Impala nel cluster Impala. Quando le query vengono elaborate su varie istanze di Impalad , tutte restituiscono il risultato al nodo di coordinamento centrale.

A seconda del requisito, le query possono essere inviate a un Impalad dedicato o in modo bilanciato a un altro Impalad nel cluster.

Impala State Store

Impala ha un altro componente importante chiamato Impala State store, che è responsabile del controllo dell'integrità di ogni Impalad e quindi di inoltrare frequentemente lo stato di ogni demone Impala agli altri demoni. Questo può essere eseguito sullo stesso nodo su cui è in esecuzione il server Impala o un altro nodo all'interno del cluster.

Il nome del processo del daemon di archivio di Impala State è State stored . Impalad segnala il proprio stato di integrità al daemon dell'archivio di Impala State, ovvero State stored .

In caso di guasto di un nodo per qualsiasi motivo, Statestore aggiorna tutti gli altri nodi su questo guasto e una volta che tale notifica è disponibile per l'altro impalad , nessun altro demone Impala assegna ulteriori query al nodo interessato.

Metadati e Meta Store Impala

I metadati e il meta store di Impala sono un altro componente importante. Impala utilizza i database MySQL o PostgreSQL tradizionali per memorizzare le definizioni delle tabelle. I dettagli importanti come le informazioni su tabelle e colonne e le definizioni di tabelle sono archiviati in un database centralizzato noto come meta store.

Ogni nodo Impala memorizza nella cache tutti i metadati localmente. Quando si ha a che fare con una quantità estremamente grande di dati e / o molte partizioni, ottenere metadati specifici della tabella potrebbe richiedere una notevole quantità di tempo. Quindi, una cache dei metadati archiviata localmente aiuta a fornire tali informazioni istantaneamente.

Quando una definizione di tabella o i dati di una tabella vengono aggiornati, altri daemon di Impala devono aggiornare la cache dei metadati recuperando i metadati più recenti prima di eseguire una nuova query sulla tabella in questione.

Interfacce di elaborazione delle query

Per elaborare le query, Impala fornisce tre interfacce elencate di seguito.

Impala-shell - Dopo aver configurato Impala utilizzando la VM Cloudera, è possibile avviare la shell Impala digitando il comando impala-shellnell'editor. Discuteremo di più sulla shell Impala nei prossimi capitoli.
Hue interface- È possibile elaborare le query Impala utilizzando il browser Hue. Nel browser Hue, hai l'editor di query Impala in cui puoi digitare ed eseguire le query impala. Per accedere a questo editor, prima di tutto, devi accedere al browser Hue.
ODBC/JDBC drivers- Proprio come altri database, Impala fornisce driver ODBC / JDBC. Utilizzando questi driver, è possibile connettersi a impala tramite linguaggi di programmazione che supportano questi driver e creare applicazioni che elaborano query in impala utilizzando tali linguaggi di programmazione.

Procedura di esecuzione della query

Ogni volta che gli utenti passano una query utilizzando una qualsiasi delle interfacce fornite, questa viene accettata da uno degli Impalad nel cluster. Questo Impalad viene trattato come un coordinatore per quella particolare query.

Dopo aver ricevuto la query, il coordinatore della query verifica se la query è appropriata, utilizzando il Table Schemadal meta store Hive. Successivamente, raccoglie le informazioni sulla posizione dei dati necessari per eseguire la query, dal nodo del nome HDFS e invia queste informazioni ad altri impalad per eseguire la query.

Tutti gli altri daemon Impala leggono il blocco di dati specificato ed elaborano la query. Non appena tutti i daemon completano le loro attività, il coordinatore della query raccoglie il risultato e lo consegna all'utente.

Nei capitoli precedenti, abbiamo visto l'installazione di Impala utilizzando cloudera e la sua architettura.

Shell Impala (prompt dei comandi)
Hue (interfaccia utente)
ODBC e JDBC (librerie di terze parti)

Questo capitolo spiega come avviare Impala Shell e le varie opzioni della shell.

Impala Shell Command Reference

I comandi della shell Impala sono classificati come general commands, query specific options, e table and database specific options, come spiegato di seguito.

Comandi generali

help
version
history
shell (o)!
connect
uscita | smettere

Opzioni specifiche di query

Set/unset
Profile
Explain

Opzioni specifiche per tabella e database

Alter
describe
drop
insert
select
show
use

Avvio di Impala Shell

Apri il terminale cloudera, accedi come superutente e digita cloudera come password come mostrato di seguito.

[[email protected] ~]$ su
Password: cloudera
[[email protected] cloudera]#

Avvia la shell Impala digitando il seguente comando:

[[email protected] cloudera] # impala-shell 
Starting Impala Shell without Kerberos authentication 
Connected to quickstart.cloudera:21000 
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE 
(build 0c891d79aa38f297d244855a32f1e17280e2129b)
********************************************************************* 

Welcome to the Impala shell. Copyright (c) 2015 Cloudera, Inc. All rights reserved.
(Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9 12:18:12 PST 2015)

Want to know what version of Impala you're connected to? Run the VERSION command to 
find out! 
********************************************************************* 
[quickstart.cloudera:21000] >

Impala - Comandi per uso generico

I comandi generali di Impala sono spiegati di seguito:

comando di aiuto

Il help Il comando della shell Impala ti dà un elenco dei comandi disponibili in Impala -

[quickstart.cloudera:21000] > help;
 
Documented commands (type help <topic>):
========================================================
compute  describe  insert  set     unset  with  version
connect  explain   quit    show    values use
exit     history   profile select  shell  tip 
  
Undocumented commands:
========================================= 
alter create desc drop help load summary

comando di versione

Il version Il comando fornisce la versione corrente di Impala, come mostrato di seguito.

[quickstart.cloudera:21000] > version;
Shell version: Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9 
12:18:12 PST 2015

Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build 
0c891d79aa38f297d244855a32f1e17280e2129b)

comando cronologia

Il historycomando di Impala mostra gli ultimi 10 comandi eseguiti nella shell. Di seguito è riportato l'esempio dihistorycomando. Qui abbiamo eseguito 5 comandi, ovvero version, help, show, use e history.

[quickstart.cloudera:21000] > history;
[1]:version;
[2]:help;
[3]:show databases;
[4]:use my_db;
[5]:history;

comando quit / exit

Puoi uscire dal guscio Impala usando il quit o exit comando, come mostrato di seguito.

[quickstart.cloudera:21000] > exit; 
Goodbye cloudera

comando di connessione

Il connectcomando viene utilizzato per connettersi a una determinata istanza di Impala. Nel caso in cui non specifichi alcuna istanza, si connette alla porta predefinita21000 come mostrato di seguito.

[quickstart.cloudera:21000] > connect; 
Connected to quickstart.cloudera:21000 
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build 
0c891d79aa38f297d244855a32f1e17280e2129b)

Opzioni specifiche della query Impala

I comandi specifici della query di Impala accettano una query. Sono spiegati di seguito:

Spiegare

Il explain restituisce il piano di esecuzione per la query data.

[quickstart.cloudera:21000] > explain select * from sample;
Query: explain select * from sample
+------------------------------------------------------------------------------------+ 
| Explain String                                                                     | 
+------------------------------------------------------------------------------------+ 
| Estimated Per-Host Requirements: Memory = 48.00MB VCores = 1                       | 
| WARNING: The following tables are missing relevant table and/or column statistics. |
| my_db.customers                                                                    | 
| 01:EXCHANGE [UNPARTITIONED]                                                        | 
| 00:SCAN HDFS [my_db.customers]                                                     | 
| partitions = 1/1 files = 6 size = 148B                                             | 
+------------------------------------------------------------------------------------+ 
Fetched 7 row(s) in 0.17s

Profilo

Il profileIl comando visualizza le informazioni di basso livello sulla query recente. Questo comando viene utilizzato per la diagnosi e l'ottimizzazione delle prestazioni di una query. Di seguito è riportato l'esempio di un fileprofilecomando. In questo scenario, ilprofile restituisce le informazioni di basso livello di explain query.

[quickstart.cloudera:21000] > profile;

Query Runtime Profile: 
Query (id=164b1294a1049189:a67598a6699e3ab6): 

   Summary: 
      Session ID: e74927207cd752b5:65ca61e630ad3ad
      Session Type: BEESWAX 
      Start Time: 2016-04-17 23:49:26.08148000 End Time: 2016-04-17 23:49:26.2404000 
      Query Type: EXPLAIN 
      Query State: FINISHED 
      Query Status: OK 
      Impala Version: impalad version 2.3.0-cdh5.5.0 RELEASE (build 0c891d77280e2129b) 
      User: cloudera 
      Connected User: cloudera 
      Delegated User: 
      Network Address:10.0.2.15:43870 
      Default Db: my_db 
      Sql Statement: explain select * from sample 
      Coordinator: quickstart.cloudera:22000 
      : 0ns 
      Query Timeline: 167.304ms 
         - Start execution: 41.292us (41.292us) - Planning finished: 56.42ms (56.386ms) 
         - Rows available: 58.247ms (1.819ms) 
         - First row fetched: 160.72ms (101.824ms) 
         - Unregister query: 166.325ms (6.253ms)
         
   ImpalaServer: 
      - ClientFetchWaitTimer: 107.969ms 
      - RowMaterializationTimer: 0ns

Opzioni specifiche per tabelle e database

La tabella seguente elenca la tabella e le opzioni specifiche dei dati in Impala.

Suor n	Comando e spiegazione
1	Alter Il alter comando viene utilizzato per modificare la struttura e il nome di una tabella in Impala.
2	Describe Il describeil comando di Impala fornisce i metadati di una tabella. Contiene le informazioni come le colonne e i loro tipi di dati. Ildescribe comando ha desc come scorciatoia.
3	Drop Il drop comando viene utilizzato per rimuovere un costrutto da Impala, dove un costrutto può essere una tabella, una vista o una funzione di database.
4	insert Il insert il comando di Impala è abituato a, Aggiungi dati (colonne) in una tabella. Sostituisci i dati di una tabella esistente. Sostituisci i dati di una tabella esistente.
5	select Il selectviene utilizzata per eseguire un'operazione desiderata su un particolare set di dati. Specifica il set di dati su cui completare alcune azioni. È possibile stampare o memorizzare (in un file) il risultato dell'istruzione select.
6	show Il show L'istruzione di Impala viene utilizzata per visualizzare il metastore di vari costrutti come tabelle, database e tabelle.
7	use Il use L'istruzione di Impala viene utilizzata per modificare il contesto corrente nel database desiderato.

Tipi di dati Impala

La tabella seguente descrive i tipi di dati Impala.

Suor n	Tipo di dati e descrizione
1	BIGINT Questo tipo di dati memorizza valori numerici e l'intervallo di questo tipo di dati è compreso tra -9223372036854775808 e 9223372036854775807. Questo tipo di dati viene utilizzato nelle istruzioni di creazione tabella e modifica tabella.
2	BOOLEAN Questo tipo di dati archivia solo true o false valori ed è utilizzato nella definizione della colonna dell'istruzione create table.
3	CHAR Questo tipo di dati è una memoria a lunghezza fissa, è imbottita di spazi, è possibile memorizzare fino alla lunghezza massima di 255.
4	DECIMAL Questo tipo di dati viene utilizzato per memorizzare valori decimali e viene utilizzato per creare tabelle e modificare istruzioni di tabella.
5	DOUBLE Questo tipo di dati viene utilizzato per memorizzare i valori in virgola mobile nell'intervallo positivo o negativo 4,94065645841246544e-324d -1,79769313486231570e + 308.
6	FLOAT Questo tipo di dati viene utilizzato per memorizzare i tipi di dati a valore mobile a precisione singola nell'intervallo positivo o negativo 1,40129846432481707e-45 .. 3,40282346638528860e + 38.
7	INT Questo tipo di dati viene utilizzato per memorizzare un numero intero a 4 byte fino all'intervallo compreso tra -2147483648 e 2147483647.
8	SMALLINT Questo tipo di dati viene utilizzato per memorizzare un numero intero a 2 byte fino all'intervallo da -32768 a 32767.
9	STRING Viene utilizzato per memorizzare i valori di stringa.
10	TIMESTAMP Questo tipo di dati viene utilizzato per rappresentare un punto nel tempo.
11	TINYINT Questo tipo di dati viene utilizzato per memorizzare un valore intero a 1 byte fino all'intervallo compreso tra -128 e 127.
12	VARCHAR Questo tipo di dati viene utilizzato per memorizzare caratteri di lunghezza variabile fino alla lunghezza massima 65.535.
13	ARRAY Questo è un tipo di dati complesso e viene utilizzato per memorizzare un numero variabile di elementi ordinati.
14	Map Questo è un tipo di dati complesso e viene utilizzato per memorizzare un numero variabile di coppie chiave-valore.
15	Struct Si tratta di un tipo di dati complesso e utilizzato per rappresentare più campi di un singolo elemento.

Commenti in Impala

I commenti in Impala sono simili a quelli in SQL.In generale abbiamo due tipi di commenti nei linguaggi di programmazione, ovvero Commenti su una riga e Commenti su più righe.

Single-line comments- Ogni singola riga seguita da "-" è considerata come un commento in Impala. Di seguito è riportato un esempio di commenti di una riga in Impala.

-- Hello welcome to tutorials point.

Multiline comments - Tutte le linee in mezzo /* e */sono considerati commenti multilinea in Impala. Di seguito è riportato un esempio di commenti su più righe in Impala.

/*
Hi this is an example
Of multiline comments in Impala
*/

Gli operatori in Impala sono simili a quelli in SQL. Fare riferimento al nostro tutorial SQL facendo clic sul collegamento seguenteoperatori sql.

Impala: crea un database

In Impala, un database è un costrutto che contiene tabelle, viste e funzioni correlate all'interno dei loro spazi dei nomi. È rappresentato come un albero di directory in HDFS; contiene tabelle, partizioni e file di dati. Questo capitolo spiega come creare un database in Impala.

Istruzione CREATE DATABASE

Il CREATE DATABASE Statement viene utilizzato per creare un nuovo database in Impala.

Sintassi

Di seguito è riportata la sintassi di CREATE DATABASE Dichiarazione.

CREATE DATABASE IF NOT EXISTS database_name;

Qui, IF NOT EXISTSè una clausola facoltativa. Se usiamo questa clausola, viene creato un database con il nome dato, solo se non esiste un database esistente con lo stesso nome.

Esempio

Di seguito è riportato un esempio di create database statement. In questo esempio, abbiamo creato un database con il nomemy_database.

[quickstart.cloudera:21000] > CREATE DATABASE IF NOT EXISTS my_database;

Quando si esegue la query sopra in cloudera impala-shell, otterrai il seguente output.

Query: create DATABASE my_database 

Fetched 0 row(s) in 0.21s

Verifica

Il SHOW DATABASES query fornisce l'elenco dei database in Impala, quindi è possibile verificare se il database è stato creato, utilizzando il SHOWDichiarazione DATABASES. Qui puoi osservare il database appena creatomy_db nella lista.

[quickstart.cloudera:21000] > show databases; 

Query: show databases
+-----------------------------------------------+
| name                                          | 
+-----------------------------------------------+ 
| _impala_builtins                              |
| default                                       | 
|  my_db                                        | 
+-----------------------------------------------+
Fetched 3 row(s) in 0.20s 
[quickstart.cloudera:21000] >

Percorso Hdfs

Per creare un database nel file system HDFS, è necessario specificare la posizione in cui deve essere creato il database.

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Creazione di un database utilizzando Hue Browser

Apri l'editor di query di Impala e digita CREATE DATABASEdichiarazione in esso. Successivamente, fare clic sul pulsante Esegui come mostrato nella seguente schermata.

Dopo aver eseguito la query, sposta delicatamente il cursore nella parte superiore del menu a discesa e troverai un simbolo di aggiornamento. Se fai clic sul simbolo di aggiornamento, l'elenco dei database verrà aggiornato e le modifiche recenti verranno applicate ad esso.

Verifica

Clicca il drop-down box sotto il titolo DATABASEsul lato sinistro dell'editor. Lì puoi vedere un elenco di database nel sistema. Qui puoi osservare il database appena creatomy_db come mostrato di seguito.

Se osservi attentamente, puoi vedere solo un database, ovvero my_db nell'elenco insieme al database predefinito.

Il DROP DATABASE Statementdi Impala viene utilizzato per rimuovere un database da Impala. Prima di eliminare il database, si consiglia di rimuovere tutte le tabelle da esso.

Sintassi

Di seguito è riportata la sintassi di DROP DATABASE Dichiarazione.

DROP (DATABASE|SCHEMA) [IF EXISTS] database_name [RESTRICT | 
CASCADE] [LOCATION hdfs_path];

Qui, IF EXISTSè una clausola facoltativa. Se utilizziamo questa clausola quando esiste un database con il nome specificato, verrà eliminato. E se non esiste un database esistente con il nome specificato, non viene eseguita alcuna operazione.

Esempio

Di seguito è riportato un esempio di DROP DATABASEdichiarazione. Supponiamo di avere un database in Impala con il nomesample_database.

Inoltre, se verifichi l'elenco dei database utilizzando l'estensione SHOW DATABASES dichiarazione, osserverai il nome in essa.

[quickstart.cloudera:21000] > SHOW DATABASES;

Query: show DATABASES
+-----------------------+ 
| name                  | 
+-----------------------+ 
| _impala_builtins      | 
| default               | 
| my_db                 | 
| sample_database       | 
+-----------------------+ 
Fetched 4 row(s) in 0.11s

Ora puoi eliminare questo database utilizzando il DROP DATABASE Statement come mostrato di seguito.

< DROP DATABASE IF EXISTS sample_database;

Questo cancellerà il database specificato e ti darà il seguente output.

Query: drop DATABASE IF EXISTS sample_database;

Verifica

È possibile verificare se il database specificato è stato eliminato, utilizzando il SHOW DATABASESdichiarazione. Qui puoi osservare che il database denominatosample_database viene rimosso dall'elenco dei database.

[quickstart.cloudera:21000] > SHOW DATABASES;

Query: show DATABASES 
+----------------------+ 
| name                 | 
+----------------------+ 
| _impala_builtins     | 
| default              | 
| my_db                | 
+----------------------+ 
Fetched 3 row(s) in 0.10s 
[quickstart.cloudera:21000] >

Cascata

In generale, per eliminare un database, è necessario rimuovere manualmente tutte le tabelle in esso contenute. Se si utilizza la cascata, Impala rimuove le tabelle all'interno del database specificato prima di eliminarlo.

Esempio

Supponiamo che ci sia un database in Impala denominato samplee contiene due tabelle, ovvero student e test. Se provi a rimuovere direttamente questo database, riceverai un errore come mostrato di seguito.

[quickstart.cloudera:21000] > DROP database sample;
Query: drop database sample 
ERROR: 
ImpalaRuntimeException: Error making 'dropDatabase' RPC to Hive Metastore: 
CAUSED BY: InvalidOperationException: Database sample is not empty. One or more 
tables exist.

Utilizzando cascade, puoi eliminare questo database direttamente (senza eliminarne il contenuto manualmente) come mostrato di seguito.

[quickstart.cloudera:21000] > DROP database sample cascade; 
Query: drop database sample cascade

Note - Non è possibile eliminare il "current database"In Impala. Pertanto, prima di eliminare un database, è necessario assicurarsi che il contesto corrente sia impostato sul database diverso da quello che si intende eliminare.

Eliminazione di un database utilizzando Hue Browser

Apri l'editor di query di Impala e digita DELETE DATABASEdichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato di seguito. Supponiamo che ci siano tre database, vale a dire,my_db, my_database, e sample_databaseinsieme al database predefinito. Qui stiamo eliminando il database denominato my_database.

Dopo aver eseguito la query, sposta delicatamente il cursore nella parte superiore del menu a discesa. Quindi, troverai un simbolo di aggiornamento come mostrato nello screenshot riportato di seguito. Se fai clic sul simbolo di aggiornamento, l'elenco dei database verrà aggiornato e le modifiche recenti apportate verranno applicate ad esso.

Verifica

Clicca sul drop down sotto il titolo DATABASEsul lato sinistro dell'editor. Lì puoi vedere un elenco di database nel sistema. Qui puoi osservare il database appena creatomy_db come mostrato di seguito.

Se osservi attentamente, puoi vedere solo un database, ovvero my_db nell'elenco insieme al database predefinito.

Una volta connesso a Impala, è necessario selezionarne uno tra i database disponibili. IlUSE DATABASE Statement di Impala viene utilizzato per passare la sessione corrente a un altro database.

Sintassi

Di seguito è riportata la sintassi di USE Dichiarazione.

USE db_name;

Esempio

Di seguito è riportato un esempio di USE statement. Prima di tutto, creiamo un database con il nomesample_database come mostrato di seguito.

> CREATE DATABASE IF NOT EXISTS sample_database;

Questo creerà un nuovo database e ti darà il seguente output.

Query: create DATABASE IF NOT EXISTS my_db2

Fetched 0 row(s) in 2.73s

Se verifichi l'elenco dei database utilizzando il file SHOW DATABASES , puoi osservare il nome del database appena creato al suo interno.

> SHOW DATABASES;

Query: show DATABASES 
+-----------------------+ 
| name                  | 
+-----------------------+ 
| _impala_builtins      | 
| default               | 
| my_db                 | 
| sample_database       | 
+-----------------------+ 
Fetched 4 row(s) in 0.11s

Ora, passiamo la sessione al database appena creato (sample_database) usando il USE Dichiarazione come mostrato di seguito.

> USE sample_database;

Questo cambierà il contesto corrente in sample_database e visualizzerà un messaggio come mostrato di seguito.

Query: use sample_database

Selezione di un database utilizzando Hue Browser

Sul lato sinistro del file Query Editor di Impala, troverai un menu a discesa come mostrato nello screenshot seguente.

Se fai clic sul menu a discesa, troverai l'elenco di tutti i database in Impala come mostrato di seguito.

Seleziona semplicemente il database in cui devi modificare il contesto corrente.

Il CREATE TABLEL'istruzione viene utilizzata per creare una nuova tabella nel database richiesto in Impala. La creazione di una tabella di base implica la denominazione della tabella e la definizione delle sue colonne e del tipo di dati di ciascuna colonna.

Sintassi

Di seguito è riportata la sintassi di CREATE TABLEDichiarazione. Qui,IF NOT EXISTSè una clausola facoltativa. Se usiamo questa clausola, viene creata una tabella con il nome specificato, solo se non esiste una tabella esistente nel database specificato con lo stesso nome.

create table IF NOT EXISTS database_name.table_name (
   column1 data_type,
   column2 data_type,
   column3 data_type,
   ………
   columnN data_type
);

CREATE TABLE è la parola chiave che indica al sistema di database di creare una nuova tabella. Il nome o l'identificatore univoco per la tabella segue l'istruzione CREATE TABLE. Facoltativamente puoi specificaredatabase_name insieme a table_name.

Esempio

Di seguito è riportato un esempio dell'istruzione create table. In questo esempio, abbiamo creato una tabella denominatastudent nel database my_db.

[quickstart.cloudera:21000] > CREATE TABLE IF NOT EXISTS my_db.student
   (name STRING, age INT, contact INT );

Eseguendo l'istruzione precedente, verrà creata una tabella con il nome specificato, che mostra il seguente output.

Query: create table student (name STRING, age INT, phone INT) 

Fetched 0 row(s) in 0.48s

Verifica

Il show Tablesquery fornisce un elenco di tabelle nel database corrente in Impala. Pertanto, è possibile verificare se la tabella è stata creata, utilizzando ilShow Tables dichiarazione.

Prima di tutto, è necessario passare il contesto al database in cui esiste la tabella richiesta, come mostrato di seguito.

[quickstart.cloudera:21000] > use my_db; 
Query: use my_db

Quindi, se ottieni l'elenco delle tabelle utilizzando il show tables query, puoi osservare la tabella denominata student in esso come mostrato di seguito.

[quickstart.cloudera:21000] > show tables;

Query: show tables 
+-----------+ 
| name      | 
+-----------+ 
| student   | 
+-----------+ 
Fetched 1 row(s) in 0.10s

Percorso HDFS

Per creare un database nel file system HDFS, è necessario specificare la posizione in cui deve essere creato il database come mostrato di seguito.

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Creazione di un database utilizzando Hue Browser

Apri l'editor di query impala e digita CREATE TableDichiarazione in esso. E fai clic sul pulsante Esegui come mostrato nello screenshot seguente.

Verifica

Clicca sul drop down sotto il titolo DATABASEsul lato sinistro dell'editor. Lì puoi vedere un elenco di database. Seleziona il databasemy_db come mostrato di seguito.

Alla selezione del database my_dbpuoi vedere un elenco di tabelle come mostrato di seguito. Qui puoi trovare la tabella appena creatastudent come mostrato di seguito.

Il INSERT La dichiarazione di Impala ha due clausole: into e overwrite. Inserisci dichiarazione coninto viene utilizzata per aggiungere nuovi record in una tabella esistente in un database.

Sintassi

Esistono due sintassi di base di INSERT dichiarazione come segue -

insert into table_name (column1, column2, column3,...columnN)

values (value1, value2, value3,...valueN);

Qui, colonna1, colonna2, ... colonnaN sono i nomi delle colonne nella tabella in cui si desidera inserire i dati.

Puoi anche aggiungere valori senza specificare i nomi delle colonne ma, per questo, devi assicurarti che l'ordine dei valori sia nello stesso ordine delle colonne nella tabella come mostrato di seguito.

Insert into table_name values (value1, value2, value2);

CREATE TABLE è la parola chiave che dice al sistema di database di creare una nuova tabella. Il nome o l'identificatore univoco per la tabella segue l'istruzione CREATE TABLE. Facoltativamente puoi specificaredatabase_name insieme con il table_name.

Esempio

Supponiamo di aver creato una tabella denominata student in Impala come mostrato di seguito.

create table employee (Id INT, name STRING, age INT,address STRING, salary BIGINT);

Di seguito è riportato un esempio di creazione di un record nella tabella denominata employee.

[quickstart.cloudera:21000] > insert into employee 
(ID,NAME,AGE,ADDRESS,SALARY)VALUES (1, 'Ramesh', 32, 'Ahmedabad', 20000 );

Eseguendo l'istruzione precedente, un record viene inserito nella tabella denominata employee visualizzando il seguente messaggio.

Query: insert into employee (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Ramesh',
   32, 'Ahmedabad', 20000 ) 
Inserted 1 row(s) in 1.32s

È possibile inserire un altro record senza specificare i nomi delle colonne come mostrato di seguito.

[quickstart.cloudera:21000] > insert into employee values (2, 'Khilan', 25, 
   'Delhi', 15000 );

Eseguendo l'istruzione precedente, un record viene inserito nella tabella denominata employee visualizzando il seguente messaggio.

Query: insert into employee values (2, 'Khilan', 25, 'Delhi', 15000 ) 
Inserted 1 row(s) in 0.31s

È possibile inserire altri record nella tabella dei dipendenti come mostrato di seguito.

Insert into employee values (3, 'kaushik', 23, 'Kota', 30000 );

Insert into employee values (4, 'Chaitali', 25, 'Mumbai', 35000 );

Insert into employee values (5, 'Hardik', 27, 'Bhopal', 40000 );

Insert into employee values (6, 'Komal', 22, 'MP', 32000 );

Dopo aver inserito i valori, il file employee la tabella in Impala sarà come mostrato di seguito.

+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+

Sovrascrittura dei dati in una tabella

Possiamo sovrascrivere i record di una tabella utilizzando la clausola di sovrascrittura. I record sovrascritti verranno eliminati definitivamente dalla tabella. Di seguito è riportata la sintassi per l'utilizzo della clausola di sovrascrittura.

Insert overwrite table_name values (value1, value2, value2);

Esempio

Di seguito è riportato un esempio di utilizzo della clausola overwrite.

[quickstart.cloudera:21000] > Insert overwrite employee values (1, 'Ram', 26, 
   'Vishakhapatnam', 37000 );

Quando si esegue la query precedente, questo sovrascriverà i dati della tabella con il record specificato visualizzando il seguente messaggio.

Query: insert overwrite employee values (1, 'Ram', 26, 'Vishakhapatnam', 37000 ) 
Inserted 1 row(s) in 0.31s

Verificando la tabella, puoi osservare che tutti i record della tabella employee vengono sovrascritti da nuovi record come mostrato di seguito.

+----+------+-----+---------------+--------+
| id | name | age | address       | salary |
+----+------+-----+---------------+--------+
| 1  | Ram  | 26  | Vishakhapatnam| 37000  |
+----+------+-----+---------------+--------+

Inserimento di dati utilizzando Hue Browser

Apri l'editor di query di Impala e digita insertDichiarazione in esso. E fai clic sul pulsante Esegui come mostrato nello screenshot seguente.

Dopo aver eseguito la query / istruzione, questo record viene aggiunto alla tabella.

Impala SELECTviene utilizzata per recuperare i dati da una o più tabelle in un database. Questa query restituisce dati sotto forma di tabelle.

Sintassi

Di seguito è riportata la sintassi dell'Impala select dichiarazione.

SELECT column1, column2, columnN from table_name;

Qui, colonna1, colonna2 ... sono i campi di una tabella i cui valori si desidera recuperare. Se desideri recuperare tutti i campi disponibili nel campo, puoi utilizzare la seguente sintassi:

SELECT * FROM table_name;

Esempio

Supponiamo di avere una tabella denominata customers a Impala, con i seguenti dati:

ID    NAME       AGE    ADDRESS      SALARY
---   -------    ---    ----------   -------
1     Ramesh     32     Ahmedabad    20000
2     Khilan     25     Delhi        15000
3     Hardik     27     Bhopal       40000
4     Chaitali   25     Mumbai       35000
5     kaushik    23     Kota         30000
6     Komal      22     Mp           32000

Puoi recuperare il file id, name, e age di tutti i record di customers tabella utilizzando select dichiarazione come mostrato di seguito -

[quickstart.cloudera:21000] > select id, name, age from customers;

Eseguendo la query precedente, Impala recupera id, nome, età di tutti i record dalla tabella specificata e li visualizza come mostrato di seguito.

Query: select id,name,age from customers

+----+----------+-----+
| id | name     | age |
| 1  | Ramesh   | 32  |
| 2  | Khilan   | 25  |
| 3  | Hardik   | 27  |
| 4  | Chaitali | 25  |
| 5  | kaushik  | 23  |
| 6  | Komal    | 22  |
+----+----------+-----+

Fetched 6 row(s) in 0.66s

Puoi anche recuperare all i record dal customers tabella utilizzando il select query come mostrato di seguito.

[quickstart.cloudera:21000] > select name, age from customers; 
Query: select * from customers

All'esecuzione della query precedente, Impala recupera e visualizza tutti i record dalla tabella specificata come mostrato di seguito.

+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | Hardik   | 27  | Bhopal    | 40000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+

Fetched 6 row(s) in 0.66s

Recupero dei record utilizzando Hue

Apri l'editor di query di Impala e digita selectDichiarazione in esso. E fai clic sul pulsante Esegui come mostrato nello screenshot seguente.

Dopo aver eseguito la query, se scorri verso il basso e selezioni il file Results scheda, è possibile visualizzare l'elenco dei record della tabella specificata come mostrato di seguito.

Il describeL'istruzione in Impala viene utilizzata per fornire la descrizione della tabella. Il risultato di questa istruzione contiene le informazioni su una tabella come i nomi delle colonne e i loro tipi di dati.

Sintassi

Di seguito è riportata la sintassi dell'Impala describe dichiarazione.

Describe table_name;

Esempio

Ad esempio, supponiamo di avere una tabella denominata customer a Impala, con i seguenti dati:

ID    NAME     AGE    ADDRESS     SALARY
--- --------- ----- ----------- -----------
1   Ramesh     32    Ahmedabad    20000
2   Khilan     25    Delhi        15000
3   Hardik     27    Bhopal       40000
4   Chaitali   25    Mumbai       35000
5   kaushik    23    Kota         30000
6   Komal      22    Mp           32000

È possibile ottenere la descrizione del file customer tabella utilizzando il describe dichiarazione come mostrato di seguito -

[quickstart.cloudera:21000] > describe customer;

Eseguendo la query precedente, Impala recupera il file metadata della tabella specificata e la visualizza come mostrato di seguito.

Query: describe customer
 
+---------+--------+---------+ 
| name    | type   | comment | 
+---------+--------+---------+ 
| id      | int    |         |                    
| name    | string |         | 
| age     | int    |         | 
| address | string |         | 
| salary  | bigint |         |
+---------+--------+---------+ 

Fetched 5 row(s) in 0.51s

Descrivere i record usando Hue

Apri l'editor di query di Impala e digita describe dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Dopo aver eseguito la query, se scorri verso il basso e selezioni il file Results scheda, puoi vedere i metadati della tabella come mostrato di seguito.

L'istruzione Alter table in Impala viene utilizzata per eseguire modifiche su una determinata tabella. Usando questa istruzione, possiamo aggiungere, eliminare o modificare colonne in una tabella esistente e possiamo anche rinominarla.

Questo capitolo spiega vari tipi di istruzioni alter con sintassi ed esempi. Prima di tutto supponiamo di avere una tabella denominatacustomers nel my_db database in Impala, con i seguenti dati

ID   NAME     AGE   ADDRESS    SALARY
--- --------- ----- ----------- --------
1   Ramesh    32    Ahmedabad   20000
2   Khilan    25    Delhi       15000
3   Hardik    27    Bhopal      40000
4   Chaitali  25    Mumbai      35000
5   kaushik   23    Kota        30000
6   Komal     22    Mp          32000

E, se ottieni l'elenco delle tabelle nel database my_db, puoi trovare il file customers tabella in esso come mostrato di seguito.

[quickstart.cloudera:21000] > show tables;

Query: show tables 
+-----------+ 
| name      | 
+-----------+ 
| customers | 
| employee  | 
| student   | 
| student1  | 
+-----------+

Modificare il nome di una tabella

Sintassi

La sintassi di base di ALTER TABLE per rinominare una tabella esistente è il seguente:

ALTER TABLE [old_db_name.]old_table_name RENAME TO [new_db_name.]new_table_name

Esempio

Di seguito è riportato un esempio di modifica del nome della tabella utilizzando l'estensione alterdichiarazione. Qui stiamo cambiando il nome della tabellacustomers agli utenti.

[quickstart.cloudera:21000] > ALTER TABLE my_db.customers RENAME TO my_db.users;

Dopo aver eseguito la query precedente, Impala cambia il nome della tabella come richiesto, visualizzando il seguente messaggio.

Query: alter TABLE my_db.customers RENAME TO my_db.users

È possibile verificare l'elenco delle tabelle nel database corrente utilizzando il show tablesdichiarazione. Puoi trovare la tabella denominatausers invece di customers.

Query: show tables 
+----------+ 
| name     | 
+----------+ 
| employee | 
| student  | 
| student1 | 
| users    | 
+----------+ 
Fetched 4 row(s) in 0.10s

Aggiunta di colonne a una tabella

Sintassi

La sintassi di base di ALTER TABLE per aggiungere colonne a una tabella esistente è il seguente:

ALTER TABLE name ADD COLUMNS (col_spec[, col_spec ...])

Esempio

La seguente query è un esempio che dimostra come aggiungere colonne a una tabella esistente. Qui stiamo aggiungendo due colonne account_no e phone_number (entrambe sono di tipo bigint) al fileusers tavolo.

[quickstart.cloudera:21000] > ALTER TABLE users ADD COLUMNS (account_no BIGINT, 
phone_no BIGINT);

Eseguendo la query precedente, aggiungerà le colonne specificate alla tabella denominata student, visualizzando il seguente messaggio.

Query: alter TABLE users ADD COLUMNS (account_no BIGINT, phone_no BIGINT)

Se verifichi lo schema della tabella users, puoi trovare le colonne appena aggiunte come mostrato di seguito.

quickstart.cloudera:21000] > describe users;
 
Query: describe users 
+------------+--------+---------+ 
| name       | type   | comment | 
+------------+--------+---------+ 
| id         | int    |         | 
| name       | string |         | 
| age        | int    |         |
| address    | string |         | 
| salary     | bigint |         | 
| account_no | bigint |         | 
| phone_no   | bigint |         | 
+------------+--------+---------+ 
Fetched 7 row(s) in 0.20s

Eliminazione di colonne da una tabella

Sintassi

La sintassi di base di ALTER TABLE su DROP COLUMN in una tabella esistente è la seguente:

ALTER TABLE name DROP [COLUMN] column_name

Esempio

La seguente query è un esempio di eliminazione di colonne da una tabella esistente. Qui stiamo eliminando la colonna denominataaccount_no.

[quickstart.cloudera:21000] > ALTER TABLE users DROP account_no;

All'esecuzione della query precedente, Impala elimina la colonna denominata account_no visualizzando il seguente messaggio.

Query: alter TABLE users DROP account_no

Se verifichi lo schema della tabella users, non riesci a trovare la colonna denominata account_no da quando è stato cancellato.

[quickstart.cloudera:21000] > describe users; 

Query: describe users 
+----------+--------+---------+ 
| name     | type   | comment | 
+----------+--------+---------+ 
| id       | int    |         | 
| name     | string |         | 
| age      | int    |         | 
| address  | string |         | 
| salary   | bigint |         | 
| phone_no | bigint |         |
+----------+--------+---------+ 
Fetched 6 row(s) in 0.11s

Modifica del nome e del tipo di una colonna

Sintassi

La sintassi di base di ALTER TABLE su change the name and datatype di una colonna in una tabella esistente è la seguente:

ALTER TABLE name CHANGE column_name new_name new_type

Esempio

Di seguito è riportato un esempio di modifica del nome e del tipo di dati di una colonna utilizzando l'istruzione alter. Qui stiamo cambiando il nome della colonnaphone_no to email e il suo tipo di dati a string.

[quickstart.cloudera:21000] > ALTER TABLE users CHANGE phone_no e_mail string;

Durante l'esecuzione della query precedente, Impala esegue le modifiche specificate, visualizzando il seguente messaggio.

Query: alter TABLE users CHANGE phone_no e_mail string

È possibile verificare i metadati degli utenti della tabella utilizzando il file describedichiarazione. È possibile osservare che Impala ha apportato le modifiche richieste alla colonna specificata.

[quickstart.cloudera:21000] > describe users; 
Query: describe users 
+----------+--------+---------+ 
| name     | type   | comment | 
+----------+--------+---------+ 
| id       | int    |         | 
| name     | string |         | 
| age      | int    |         | 
| address  | string |         | 
| salary   | bigint |         | 
| phone_no | bigint |         |
+----------+--------+---------+ 
Fetched 6 row(s) in 0.11s

Modifica di una tabella utilizzando la tonalità

Apri l'editor di query di Impala e digita alter dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Quando si esegue la query precedente, cambierà il nome della tabella customers per users. Allo stesso modo, possiamo eseguire tutti i filealter interrogazioni.

L'Impala drop tableviene utilizzata per eliminare una tabella esistente in Impala. Questa istruzione elimina anche i file HDFS sottostanti per le tabelle interne

NOTE - Devi stare attento quando usi questo comando perché una volta che una tabella viene eliminata, anche tutte le informazioni disponibili nella tabella andrebbero perse per sempre.

Sintassi

Di seguito è riportata la sintassi di DROP TABLEDichiarazione. Qui,IF EXISTSè una clausola facoltativa. Se usiamo questa clausola, una tabella con il nome dato viene cancellata, solo se esiste. In caso contrario, non verrà eseguita alcuna operazione.

DROP table database_name.table_name;

Se si tenta di eliminare una tabella che non esiste senza la clausola IF EXISTS, verrà generato un errore. Facoltativamente puoi specificaredatabase_name insieme a table_name.

Esempio

Verifichiamo prima l'elenco delle tabelle nel database my_db come mostrato di seguito.

[quickstart.cloudera:21000] > show tables;

Query: show tables 
+------------+ 
| name       | 
+------------+ 
| customers  | 
| employee   | 
| student    | 
+------------+ 
Fetched 3 row(s) in 0.11s

Dal risultato di cui sopra, puoi osservare che il database my_db contiene 3 tabelle

Di seguito è riportato un esempio di drop table statement. In questo esempio, stiamo eliminando la tabella denominatastudent dal database my_db.

[quickstart.cloudera:21000] > drop table if exists my_db.student;

Quando si esegue la query di cui sopra, una tabella con il nome specificato verrà cancellata, visualizzando il seguente output.

Query: drop table if exists student

Verifica

Il show Tablesquery fornisce un elenco delle tabelle nel database corrente in Impala. Pertanto, puoi verificare se una tabella viene eliminata, utilizzando ilShow Tables dichiarazione.

Prima di tutto, è necessario passare il contesto al database in cui esiste la tabella richiesta, come mostrato di seguito.

[quickstart.cloudera:21000] > use my_db; 
Query: use my_db

Quindi, se ottieni l'elenco delle tabelle utilizzando il show tables query, puoi osservare la tabella denominata student non è nell'elenco.

[quickstart.cloudera:21000] > show tables; 

Query: show tables 
+-----------+ 
| name      | 
+-----------+ 
| customers | 
| employee  | 
| student   | 
+-----------+ 
Fetched 3 row(s) in 0.11s

Creazione di un database utilizzando Hue Browser

Apri l'editor di query di Impala e digita drop TableDichiarazione in esso. E fai clic sul pulsante Esegui come mostrato nello screenshot seguente.

Verifica

Clicca sul drop down sotto il titolo DATABASEsul lato sinistro dell'editor. Lì puoi vedere un elenco di database; seleziona il databasemy_db come mostrato di seguito.

Alla selezione del database my_db, puoi vedere un elenco di tabelle come mostrato di seguito. Qui non puoi trovare la tabella eliminatastudent nell'elenco come mostrato di seguito.

Il Truncate Table L'istruzione di Impala viene utilizzata per rimuovere tutti i record da una tabella esistente.

È inoltre possibile utilizzare il comando DROP TABLE per eliminare una tabella completa, ma rimuoverà l'intera struttura della tabella dal database e sarà necessario ricreare questa tabella ancora una volta se si desidera memorizzare alcuni dati.

Sintassi

Di seguito è riportata la sintassi dell'istruzione truncate table.

truncate table_name;

Esempio

Supponiamo di avere una tabella denominata customersin Impala, e se verifichi il suo contenuto, ottieni il seguente risultato. Ciò significa che la tabella dei clienti contiene 6 record.

[quickstart.cloudera:21000] > select * from customers; 

Query: select * from customers 
+----+----------+-----+-----------+--------+--------+ 
| id | name     | age | address   | salary | e_mail | 
+----+----------+-----+-----------+--------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | NULL   | 
| 2  | Khilan   | 25  | Delhi     | 15000  | NULL   | 
| 3  | kaushik  | 23  | Kota      | 30000  | NULL   |
| 4  | Chaitali | 25  | Mumbai    | 35000  | NULL   | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | NULL   | 
| 6  | Komal    | 22  | MP        | 32000  | NULL   | 
+----+----------+-----+-----------+--------+--------+

Di seguito è riportato un esempio di troncamento di una tabella in Impala utilizzando truncate statement. Qui stiamo rimuovendo tutti i record della tabella denominatacustomers.

[quickstart.cloudera:21000] > truncate customers;

Eseguendo l'istruzione di cui sopra, Impala cancella tutti i record della tabella specificata, visualizzando il seguente messaggio.

Query: truncate customers 

Fetched 0 row(s) in 0.37s

Verifica

Se verifichi il contenuto della tabella clienti, dopo l'operazione di cancellazione, utilizzando select istruzione, otterrai una riga vuota come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers 

Fetched 0 row(s) in 0.12s

Troncamento di una tabella utilizzando il browser Hue

Apri l'editor di query di Impala e digita truncateDichiarazione in esso. E fai clic sul pulsante Esegui come mostrato nello screenshot seguente.

Dopo aver eseguito la query / istruzione, tutti i record dalla tabella vengono eliminati.

Il show tables L'istruzione in Impala viene utilizzata per ottenere l'elenco di tutte le tabelle esistenti nel database corrente.

Esempio

Di seguito è riportato un esempio di show tablesdichiarazione. Se vuoi ottenere l'elenco delle tabelle in un database particolare, prima di tutto, cambia il contesto nel database richiesto e ottieni l'elenco delle tabelle in esso usandoshow tables dichiarazione come mostrato di seguito.

[quickstart.cloudera:21000] > use my_db; 
Query: use my_db
[quickstart.cloudera:21000] > show tables;

Eseguendo la query precedente, Impala recupera l'elenco di tutte le tabelle nel database specificato e lo visualizza come mostrato di seguito.

Query: show tables 
+-----------+ 
| name      | 
+-----------+ 
| customers | 
| employee  | 
+-----------+ 
Fetched 2 row(s) in 0.10s

Elenco delle tabelle tramite Hue

Apri l'editor di query impala, seleziona il contesto come my_db e digita show tables dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Dopo aver eseguito la query, se scorri verso il basso e selezioni il file Results scheda, è possibile visualizzare l'elenco delle tabelle come mostrato di seguito.

Una vista non è altro che un'istruzione del linguaggio di query Impala archiviata nel database con un nome associato. È una composizione di una tabella sotto forma di una query SQL predefinita.

Una vista può contenere tutte le righe di una tabella o quelle selezionate. È possibile creare una vista da una o più tabelle. Le visualizzazioni consentono agli utenti di:

Struttura i dati in modo che gli utenti o le classi di utenti trovino naturali o intuitivi.
Limita l'accesso ai dati in modo che un utente possa vedere e (a volte) modificare esattamente ciò di cui ha bisogno e non di più.
Riepiloga i dati da varie tabelle che possono essere utilizzate per generare report.

È possibile creare una visualizzazione utilizzando il Create View dichiarazione di Impala.

Sintassi

Di seguito è riportata la sintassi dell'istruzione create view. IF NOT EXISTSè una clausola facoltativa. Se usiamo questa clausola, viene creata una tabella con il nome specificato, solo se non esiste una tabella esistente nel database specificato con lo stesso nome.

Create View IF NOT EXISTS view_name as Select statement

Esempio

Ad esempio, supponiamo di avere una tabella denominata customers nel my_db database in Impala, con i seguenti dati.

ID  NAME      AGE   ADDRESS     SALARY
--- --------- ----- ----------- --------
1   Ramesh    32    Ahmedabad   20000
2   Khilan    25    Delhi       15000
3   Hardik    27    Bhopal      40000
4   Chaitali  25    Mumbai      35000
5   kaushik   23    Kota        30000
6   Komal     22    MP          32000

Di seguito è riportato un esempio di Create View Statement. In questo esempio, stiamo creando una vista comecustomers tabella che contiene le colonne, il nome e l'età.

[quickstart.cloudera:21000] > CREATE VIEW IF NOT EXISTS customers_view AS 
select name, age from customers;

Eseguendo la query di cui sopra, viene creata una vista con le colonne desiderate, visualizzando il seguente messaggio.

Query: create VIEW IF NOT EXISTS sample AS select * from customers 
Fetched 0 row(s) in 0.33s

Verifica

Puoi verificare il contenuto della vista appena creata, utilizzando il select dichiarazione come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers_view;

Questo produrrà il seguente risultato.

Query: select * from customers_view 
+----------+-----+ 
| name     | age | 
+----------+-----+ 
| Komal    | 22  | 
| Khilan   | 25  | 
| Ramesh   | 32  | 
| Hardik   | 27  | 
| Chaitali | 25  | 
| kaushik  | 23  | 
+----------+-----+ 
Fetched 6 row(s) in 4.80s

Creazione di una vista utilizzando la tonalità

Apri l'editor di query Impala, seleziona il contesto come my_dbe digita Create View dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Dopo aver eseguito la query, se scorri verso il basso, puoi vedere il file view di nome sample creato nell'elenco delle tabelle come mostrato di seguito.

Il Alter ViewL'istruzione di Impala viene utilizzata per modificare una visualizzazione. Utilizzando questa istruzione, è possibile modificare il nome di una visualizzazione, modificare il database e la query ad esso associata.

Da view è un costrutto logico, nessun dato fisico sarà influenzato da alter view query.

Sintassi

Di seguito è riportata la sintassi di Alter View dichiarazione

ALTER VIEW database_name.view_name as Select statement

Esempio

Ad esempio, supponiamo di avere una vista denominata customers_view nel my_db database in Impala con i seguenti contenuti.

+----------+-----+ 
| name     | age | 
+----------+-----+ 
| Komal    | 22  | 
| Khilan   | 25  | 
| Ramesh   | 32  | 
| Hardik   | 27  | 
| Chaitali | 25  | 
| kaushik  | 23  | 
+----------+-----+

Di seguito è riportato un esempio di Alter View Statement. In questo esempio, includiamo le colonne id, name e salary invece di name ed age incustomers_view.

[quickstart.cloudera:21000] > Alter view customers_view as select id, name, 
salary from customers;

Eseguendo la query precedente, Impala apporta le modifiche specificate al file customers_view, visualizzando il seguente messaggio.

Query: alter view customers_view as select id, name, salary from customers

Verifica

Puoi verificare il contenuto del file view di nome customers_view, usando il select dichiarazione come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers_view;
Query: select * from customers_view

Questo produrrà il seguente risultato.

+----+----------+--------+ 
| id | name     | salary | 
+----+----------+--------+
| 3  | kaushik  | 30000  | 
| 2  | Khilan   | 15000  | 
| 5  | Hardik   | 40000  | 
| 6  | Komal    | 32000  | 
| 1  | Ramesh   | 20000  | 
| 4  | Chaitali | 35000  | 
+----+----------+--------+ 
Fetched 6 row(s) in 0.69s

Modifica di una vista utilizzando la tonalità

Apri l'editor di query Impala, seleziona il contesto come my_dbe digita Alter View dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Dopo aver eseguito la query, il view di nome sample sarà modificato di conseguenza.

Il Drop Viewquery di Impala viene utilizzata per eliminare una vista esistente. Daview è un costrutto logico, nessun dato fisico sarà influenzato da drop view query.

Sintassi

Di seguito è riportata la sintassi dell'istruzione drop view.

DROP VIEW database_name.view_name;

Esempio

Ad esempio, supponiamo di avere una vista denominata customers_view nel my_db database in Impala con i seguenti contenuti.

+----------+-----+ 
| name     | age | 
+----------+-----+ 
| Komal    | 22  | 
| Khilan   | 25  | 
| Ramesh   | 32  | 
| Hardik   | 27  | 
| Chaitali | 25  | 
| kaushik  | 23  | 
+----------+-----+

Di seguito è riportato un esempio di Drop View Statement. In questo esempio, stiamo cercando di eliminare il fileview di nome customers_view usando il drop view query.

[quickstart.cloudera:21000] > Drop view customers_view;

Quando si esegue la query precedente, Impala elimina la vista specificata, visualizzando il seguente messaggio.

Query: drop view customers_view

Verifica

Se verifichi l'elenco delle tabelle utilizzando show tables dichiarazione, puoi osservare che il file view di nome customers_view viene cancellato.

[quickstart.cloudera:21000] > show tables;

Questo produrrà il seguente risultato.

Query: show tables 
+-----------+ 
| name      | 
+-----------+ 
| customers | 
| employee  | 
| sample    | 
+-----------+ 
Fetched 3 row(s) in 0.10s

Eliminazione di una vista utilizzando la tonalità

Apri l'editor di query Impala, seleziona il contesto come my_dbe digita Drop view dichiarazione in esso e fare clic sul pulsante di esecuzione come mostrato nella seguente schermata.

Dopo aver eseguito la query, se scorri verso il basso, puoi vedere un elenco denominato TABLES. Questo elenco contiene tutti i filetables e viewsnel database corrente. Da questo elenco, puoi trovare che il file specificatoview è stato eliminato.

L'Impala ORDER BYla clausola viene utilizzata per ordinare i dati in ordine crescente o decrescente, in base a una o più colonne. Alcuni database ordinano i risultati della query in ordine crescente per impostazione predefinita.

Sintassi

Di seguito è riportata la sintassi della clausola ORDER BY.

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]

È possibile disporre i dati nella tabella in ordine crescente o decrescente utilizzando le parole chiave ASC o DESC rispettivamente.

Allo stesso modo, se usiamo NULLS FIRST, tutti i valori nulli nella tabella sono disposti nelle prime righe; e se usiamo NULLS LAST, le righe contenenti valori null verranno disposte per ultime.

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 1  | Ramesh   |  32 | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
+----+----------+-----+-----------+--------+ 
Fetched 6 row(s) in 0.51s

Di seguito è riportato un esempio di disposizione dei dati in customers tabella, in ordine crescente di loro id’s usando il order by clausola.

[quickstart.cloudera:21000] > Select * from customers ORDER BY id asc;

All'esecuzione, la query precedente produce il seguente output.

Query: select * from customers ORDER BY id asc 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
+----+----------+-----+-----------+--------+ 
Fetched 6 row(s) in 0.56s

Allo stesso modo, puoi organizzare i dati di customers tabella in ordine decrescente utilizzando il order by clausola come mostrato di seguito.

[quickstart.cloudera:21000] > Select * from customers ORDER BY id desc;

All'esecuzione, la query precedente produce il seguente output.

Query: select * from customers ORDER BY id desc 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 6  | Komal    | 22  | MP        | 32000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
+----+----------+-----+-----------+--------+ 
Fetched 6 row(s) in 0.54s

L'Impala GROUP BY la clausola viene utilizzata in collaborazione con l'istruzione SELECT per organizzare dati identici in gruppi.

Sintassi

Di seguito è riportata la sintassi della clausola GROUP BY.

select data from table_name Group BY col_name;

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers; 
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
+----+----------+-----+-----------+--------+ 
Fetched 6 row(s) in 0.51s

Puoi ottenere l'importo totale dello stipendio di ciascun cliente utilizzando la query GROUP BY come mostrato di seguito.

[quickstart.cloudera:21000] > Select name, sum(salary) from customers Group BY name;

All'esecuzione, la query precedente fornisce il seguente output.

Query: select name, sum(salary) from customers Group BY name 
+----------+-------------+ 
| name     | sum(salary) | 
+----------+-------------+ 
| Ramesh   | 20000       | 
| Komal    | 32000       | 
| Hardik   | 40000       | 
| Khilan   | 15000       | 
| Chaitali | 35000       | 
| kaushik  | 30000       |
+----------+-------------+ 
Fetched 6 row(s) in 1.75s

Supponi che questa tabella abbia più record come mostrato di seguito.

+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Ramesh   | 32  | Ahmedabad | 1000|  | 
| 3  | Khilan   | 25  | Delhi     | 15000  | 
| 4  | kaushik  | 23  | Kota      | 30000  | 
| 5  | Chaitali | 25  | Mumbai    | 35000  |
| 6  | Chaitali | 25  | Mumbai    | 2000   |
| 7  | Hardik   | 27  | Bhopal    | 40000  | 
| 8  | Komal    | 22  | MP        | 32000  | 
+----+----------+-----+-----------+--------+

Ora di nuovo, puoi ottenere l'importo totale degli stipendi dei dipendenti, considerando le registrazioni ripetute, utilizzando il Group By clausola come mostrato di seguito.

Select name, sum(salary) from customers Group BY name;

All'esecuzione, la query precedente fornisce il seguente output.

Query: select name, sum(salary) from customers Group BY name 
+----------+-------------+ 
| name     | sum(salary) | 
+----------+-------------+ 
| Ramesh   | 21000       | 
| Komal    | 32000       | 
| Hardik   | 40000       | 
| Khilan   | 15000       | 
| Chaitali | 37000       | 
| kaushik  | 30000       | 
+----------+-------------+
Fetched 6 row(s) in 1.75s

Il Having La clausola in Impala consente di specificare le condizioni che filtrano i risultati del gruppo visualizzati nei risultati finali.

In generale, il Having la clausola viene utilizzata insieme a group byclausola; pone condizioni sui gruppi creati dalla clausola GROUP BY.

Sintassi

Di seguito è riportata la sintassi di Havingclausola.

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers; 
Query: select * from customers 
+----+----------+-----+-------------+--------+ 
| id | name     | age | address     | salary | 
+----+----------+-----+-------------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad   | 20000  |
| 2  | Khilan   | 25  | Delhi       | 15000  | 
| 3  | kaushik  | 23  | Kota        | 30000  | 
| 4  | Chaitali | 25  | Mumbai      | 35000  | 
| 5  | Hardik   | 27  | Bhopal      | 40000  | 
| 6  | Komal    | 22  | MP          | 32000  | 
| 7  | ram      | 25  | chennai     | 23000  | 
| 8  | rahim    | 22  | vizag       | 31000  | 
| 9  | robert   | 23  | banglore    | 28000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.51s

Di seguito è riportato un esempio di utilizzo di Having clausola in Impala -

[quickstart.cloudera:21000] > select max(salary) from customers group by age having max(salary) > 20000;

Questa query inizialmente raggruppa la tabella in base all'età e seleziona gli stipendi massimi di ciascun gruppo e visualizza gli stipendi, che sono maggiori di 20000 come mostrato di seguito.

20000 
+-------------+ 
| max(salary) |
+-------------+ 
| 30000       |
| 35000       | 
| 40000       | 
| 32000       | 
+-------------+ 
Fetched 4 row(s) in 1.30s

Il limit La clausola in Impala viene utilizzata per limitare il numero di righe di un gruppo di risultati a un numero desiderato, ovvero il gruppo di risultati della query non contiene i record oltre il limite specificato.

Sintassi

Di seguito è riportata la sintassi di Limit clausola in Impala.

select * from table_name order by id limit numerical_expression;

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers; 
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 8  | ram      | 22  | vizag     | 31000  | 
| 9  | robert   | 23  | banglore  | 28000  | 
| 7  | ram      | 25  | chennai   | 23000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.51s

Puoi disporre i record nella tabella in ordine crescente dei loro ID usando il order by clausola come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers order by id; 
Query: select * from customers order by id 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 7  | ram      | 25  | chennai   | 23000  | 
| 8  | ram      | 22  | vizag     | 31000  |
| 9  | robert   | 23  | banglore  | 28000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.54s

Ora, usando il limit è possibile limitare il numero di record dell'output a 4, utilizzando la clausola limit clausola come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers order by id limit 4;

All'esecuzione, la query precedente fornisce il seguente output.

Query: select * from customers order by id limit 4 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
+----+----------+-----+-----------+--------+ 
Fetched 4 row(s) in 0.64s

In generale, le righe nel gruppo di risultati di un file select la query inizia da 0. Utilizzando l'estensione offsetclausola, possiamo decidere da dove considerare l'output. Ad esempio, se scegliamo l'offset come 0, il risultato sarà come al solito e se scegliamo l'offset come 5, il risultato inizia dalla quinta riga.

Sintassi

Di seguito è riportata la sintassi di offsetclausola in Impala.

select data from table_name Group BY col_name;

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers; 
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 8  | ram      | 22  | vizag     | 31000  | 
| 9  | robert   | 23  | banglore  | 28000  |
| 7  | ram      | 25  | chennai   | 23000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.51s

È possibile disporre i record nella tabella in ordine crescente dei loro ID e limitare il numero di record a 4, utilizzando limit e order by clausole come mostrato di seguito.

Query: select * from customers order by id limit 4 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
+----+----------+-----+-----------+--------+ 
Fetched 4 row(s) in 0.64s

Di seguito è riportato un esempio di offsetclausola. Qui stiamo ottenendo i record nel filecustomerstavolo in ordine di id e stampando le prime quattro righe a partire dalla 0 ^esima riga.

[quickstart.cloudera:21000] > select * from customers order by id limit 4 offset 0;

All'esecuzione, la query precedente fornisce il seguente risultato.

Query: select * from customers order by id limit 4 offset 0 
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
+----+----------+-----+-----------+--------+ 
Fetched 4 row(s) in 0.62s

Allo stesso modo, puoi ottenere quattro record dal file customers tabella a partire dalla riga avente offset 5 come mostrato di seguito.

[quickstart.cloudera:21000] > select * from customers order by id limit 4 offset 5; 
Query: select * from customers order by id limit 4 offset 5 
+----+--------+-----+----------+--------+ 
| id | name   | age | address  | salary | 
+----+--------+-----+----------+--------+ 
| 6  | Komal  | 22  | MP       | 32000  | 
| 7  | ram    | 25  | chennai  | 23000  | 
| 8  | ram    | 22  | vizag    | 31000  |
| 9  | robert | 23  | banglore | 28000  | 
+----+--------+-----+----------+--------+ 
Fetched 4 row(s) in 0.52s

Puoi combinare i risultati di due query utilizzando il Union clausola di Impala.

Sintassi

Di seguito è riportata la sintassi di Union clausola in Impala.

query1 union query2;

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers; 
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 9  | robert   | 23  | banglore  | 28000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 7  | ram      | 25  | chennai   | 23000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 8  | ram      | 22  | vizag     | 31000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.59s

Allo stesso modo, supponiamo di avere un'altra tabella denominata employee e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from employee; 
Query: select * from employee 
+----+---------+-----+---------+--------+ 
| id | name    | age | address | salary | 
+----+---------+-----+---------+--------+ 
| 3  | mahesh  | 54  | Chennai | 55000  | 
| 2  | ramesh  | 44  | Chennai | 50000  | 
| 4  | Rupesh  | 64  | Delhi   | 60000  | 
| 1  | subhash | 34  | Delhi   | 40000  | 
+----+---------+-----+---------+--------+ 
Fetched 4 row(s) in 0.59s

Di seguito è riportato un esempio di unionclausola in Impala. In questo esempio, disponiamo i record in entrambe le tabelle nell'ordine dei loro ID e limitiamo il loro numero a 3 utilizzando due query separate e unendo queste query utilizzando ilUNION clausola.

[quickstart.cloudera:21000] > select * from customers order by id limit 3
 union select * from employee order by id limit 3;

All'esecuzione, la query precedente fornisce il seguente output.

Query: select * from customers order by id limit 3 union select 
   * from employee order by id limit 3 
+----+---------+-----+-----------+--------+ 
| id | name    | age | address   | salary | 
+----+---------+-----+-----------+--------+ 
| 2  | Khilan  | 25  | Delhi     | 15000  |
| 3  | mahesh  | 54  | Chennai   | 55000  | 
| 1  | subhash | 34  | Delhi     | 40000  | 
| 2  | ramesh  | 44  | Chennai   | 50000  | 
| 3  | kaushik | 23  | Kota      | 30000  | 
| 1  | Ramesh  | 32  | Ahmedabad | 20000  | 
+----+---------+-----+-----------+--------+ 
Fetched 6 row(s) in 3.11s

Nel caso in cui una query sia troppo complessa, possiamo definirla aliases a parti complesse e includerle nella query utilizzando il with clausola di Impala.

Sintassi

Di seguito è riportata la sintassi di with clausola in Impala.

with x as (select 1), y as (select 2) (select * from x union y);

Esempio

Supponiamo di avere una tabella denominata customers nel database my_db e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers 
+----+----------+-----+-----------+--------+ 
| id | name     | age | address   | salary | 
+----+----------+-----+-----------+--------+ 
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | 
| 9  | robert   | 23  | banglore  | 28000  | 
| 2  | Khilan   | 25  | Delhi     | 15000  | 
| 4  | Chaitali | 25  | Mumbai    | 35000  | 
| 7  | ram      | 25  | chennai   | 23000  | 
| 6  | Komal    | 22  | MP        | 32000  | 
| 8  | ram      | 22  | vizag     | 31000  | 
| 5  | Hardik   | 27  | Bhopal    | 40000  | 
| 3  | kaushik  | 23  | Kota      | 30000  | 
+----+----------+-----+-----------+--------+ 
Fetched 9 row(s) in 0.59s

Allo stesso modo, supponiamo di avere un'altra tabella denominata employee e il suo contenuto è il seguente:

[quickstart.cloudera:21000] > select * from employee; 
Query: select * from employee 
+----+---------+-----+---------+--------+ 
| id | name    | age | address | salary | 
+----+---------+-----+---------+--------+ 
| 3  | mahesh  | 54  | Chennai | 55000  | 
| 2  | ramesh  | 44  | Chennai | 50000  | 
| 4  | Rupesh  | 64  | Delhi   | 60000  | 
| 1  | subhash | 34  | Delhi   | 40000  | 
+----+---------+-----+---------+--------+ 
Fetched 4 row(s) in 0.59s

Di seguito è riportato un esempio di withclausola in Impala. In questo esempio, stiamo visualizzando i record di entrambiemployee e customers la cui età è maggiore di 25 utilizzando with clausola.

[quickstart.cloudera:21000] > 
   with t1 as (select * from customers where age>25), 
   t2 as (select * from employee where age>25) 
   (select * from t1 union select * from t2);

All'esecuzione, la query precedente fornisce il seguente output.

Query: with t1 as (select * from customers where age>25), t2 as (select * from employee where age>25) 
   (select * from t1 union select * from t2)
+----+---------+-----+-----------+--------+ 
| id | name    | age | address   | salary | 
+----+---------+-----+-----------+--------+ 
| 3  | mahesh  | 54  | Chennai   | 55000  | 
| 1  | subhash | 34  | Delhi     | 40000  | 
| 2  | ramesh  | 44  | Chennai   | 50000  | 
| 5  | Hardik  | 27  | Bhopal    | 40000  | 
| 4  | Rupesh  | 64  | Delhi     | 60000  | 
| 1  | Ramesh  | 32  | Ahmedabad | 20000  | 
+----+---------+-----+-----------+--------+ 
Fetched 6 row(s) in 1.73s

Il distinct L'operatore in Impala viene utilizzato per ottenere i valori univoci rimuovendo i duplicati.

Sintassi

Di seguito è riportata la sintassi di distinct operatore.

select distinct columns… from table_name;

Esempio

Supponiamo di avere una tabella denominata customers in Impala e il suo contenuto sono i seguenti:

[quickstart.cloudera:21000] > select distinct id, name, age, salary from customers; 
Query: select distinct id, name, age, salary from customers

Qui puoi osservare lo stipendio dei clienti Ramesh e Chaitali inseriti due volte e utilizzando il distinct operatore, possiamo selezionare i valori univoci come mostrato di seguito.

[quickstart.cloudera:21000] > select distinct name, age, address from customers;

All'esecuzione, la query precedente fornisce il seguente output.

Query: select distinct id, name from customers
+----------+-----+-----------+ 
| name     | age | address   | 
+----------+-----+-----------+ 
| Ramesh   | 32  | Ahmedabad |
| Khilan   | 25  | Delhi     | 
| kaushik  | 23  | Kota      | 
| Chaitali | 25  | Mumbai    |
| Hardik   | 27  | Bhopal    |
| Komal    | 22  | MP        | 
+----------+-----+-----------+
Fetched 9 row(s) in 1.46s

↰ Previous page Next page ↱