Impala - Guide rapide

Qu'est-ce qu'Impala?

Impala est un moteur de requête SQL MPP (Massive Parallel Processing) pour traiter d'énormes volumes de données stockées dans un cluster Hadoop. Il s'agit d'un logiciel open source écrit en C ++ et Java. Il offre des performances élevées et une faible latence par rapport aux autres moteurs SQL pour Hadoop.

En d'autres termes, Impala est le moteur SQL le plus performant (offrant une expérience semblable à un SGBDR) qui offre le moyen le plus rapide d'accéder aux données stockées dans Hadoop Distributed File System.

Pourquoi Impala?

Impala combine la prise en charge SQL et les performances multi-utilisateurs d'une base de données analytique traditionnelle avec l'évolutivité et la flexibilité d'Apache Hadoop, en utilisant des composants standard tels que HDFS, HBase, Metastore, YARN et Sentry.

  • Avec Impala, les utilisateurs peuvent communiquer avec HDFS ou HBase à l'aide de requêtes SQL d'une manière plus rapide par rapport à d'autres moteurs SQL comme Hive.

  • Impala peut lire presque tous les formats de fichiers tels que Parquet, Avro, RCFile utilisés par Hadoop.

Impala utilise les mêmes métadonnées, syntaxe SQL (Hive SQL), pilote ODBC et interface utilisateur (Hue Beeswax) qu'Apache Hive, fournissant une plate-forme familière et unifiée pour les requêtes orientées batch ou en temps réel.

Contrairement à Apache Hive, Impala is not based on MapReduce algorithms. Il implémente une architecture distribuée basée surdaemon processes qui sont responsables de tous les aspects de l'exécution des requêtes qui s'exécutent sur les mêmes machines.

Ainsi, cela réduit la latence d'utilisation de MapReduce et cela rend Impala plus rapide qu'Apache Hive.

Avantages d'Impala

Voici une liste de quelques avantages notés de Cloudera Impala.

  • Grâce à impala, vous pouvez traiter les données stockées dans HDFS à une vitesse fulgurante grâce aux connaissances SQL traditionnelles.

  • Étant donné que le traitement des données est effectué là où les données résident (sur le cluster Hadoop), la transformation et le déplacement des données ne sont pas nécessaires pour les données stockées sur Hadoop, tout en travaillant avec Impala.

  • À l'aide d'Impala, vous pouvez accéder aux données stockées dans HDFS, HBase et Amazon s3 sans la connaissance de Java (tâches MapReduce). Vous pouvez y accéder avec une idée de base des requêtes SQL.

  • Pour écrire des requêtes dans les outils métier, les données doivent passer par un cycle ETL (extraction-transform-load) compliqué. Mais, avec Impala, cette procédure est raccourcie. Les étapes chronophages du chargement et de la réorganisation sont surmontées avec les nouvelles techniques telles queexploratory data analysis & data discovery rendre le processus plus rapide.

  • Impala est le pionnier de l'utilisation du format de fichier Parquet, une disposition de stockage en colonnes optimisée pour les requêtes à grande échelle typiques des scénarios d'entrepôt de données.

Caractéristiques d'Impala

Ci-dessous sont les caractéristiques de cloudera Impala -

  • Impala est disponible gratuitement en open source sous la licence Apache.

  • Impala prend en charge le traitement des données en mémoire, c'est-à-dire qu'il accède / analyse les données stockées sur les nœuds de données Hadoop sans mouvement de données.

  • Vous pouvez accéder aux données à l'aide d'Impala à l'aide de requêtes de type SQL.

  • Impala offre un accès plus rapide aux données dans HDFS par rapport aux autres moteurs SQL.

  • En utilisant Impala, vous pouvez stocker des données dans des systèmes de stockage tels que HDFS, Apache HBase et Amazon s3.

  • Vous pouvez intégrer Impala à des outils de Business Intelligence tels que Tableau, Pentaho, Micro Strategy et Zoom Data.

  • Impala prend en charge différents formats de fichiers tels que LZO, Sequence File, Avro, RCFile et Parquet.

  • Impala utilise les métadonnées, le pilote ODBC et la syntaxe SQL d'Apache Hive.

Bases de données relationnelles et Impala

Impala utilise un langage de requête similaire à SQL et HiveQL. Le tableau suivant décrit certaines des différences clés entre SQL et le langage de requête Impala.

Impala Bases de données relationnelles
Impala utilise un langage de requête similaire à SQL qui est similaire à HiveQL. Les bases de données relationnelles utilisent le langage SQL.
Dans Impala, vous ne pouvez pas mettre à jour ou supprimer des enregistrements individuels. Dans les bases de données relationnelles, il est possible de mettre à jour ou de supprimer des enregistrements individuels.
Impala ne prend pas en charge les transactions. Les bases de données relationnelles prennent en charge les transactions.
Impala ne prend pas en charge l'indexation. Les bases de données relationnelles prennent en charge l'indexation.
Impala stocke et gère de grandes quantités de données (pétaoctets). Les bases de données relationnelles gèrent de plus petites quantités de données (téraoctets) par rapport à Impala.

Hive, Hbase et Impala

Bien que Cloudera Impala utilise le même langage de requête, le même métastore et l'interface utilisateur que Hive, il diffère de Hive et HBase sur certains aspects. Le tableau suivant présente une analyse comparative entre HBase, Hive et Impala.

HBase Ruche Impala
HBase est une base de données de magasin à colonnes larges basée sur Apache Hadoop. Il utilise les concepts de BigTable. Hive est un logiciel d'entrepôt de données. Grâce à cela, nous pouvons accéder et gérer de grands ensembles de données distribués, construits sur Hadoop. Impala est un outil pour gérer, analyser les données stockées sur Hadoop.
Le modèle de données de HBase est un grand magasin de colonnes. Hive suit le modèle relationnel. Impala suit le modèle relationnel.
HBase est développé en utilisant le langage Java. Hive est développé en utilisant le langage Java. Impala est développé en C ++.
Le modèle de données de HBase est sans schéma. Le modèle de données de Hive est basé sur un schéma. Le modèle de données d'Impala est basé sur un schéma.
HBase fournit des API Java, RESTful et Thrift. Hive fournit des API JDBC, ODBC et Thrift. Impala fournit des API JDBC et ODBC.
Prend en charge les langages de programmation tels que C, C #, C ++, Groovy, Java PHP, Python et Scala. Prend en charge les langages de programmation tels que C ++, Java, PHP et Python. Impala prend en charge tous les langages prenant en charge JDBC / ODBC.
HBase prend en charge les déclencheurs. Hive ne fournit aucun support pour les déclencheurs. Impala ne fournit aucun support pour les déclencheurs.

Toutes ces trois bases de données -

  • Sont des bases de données NOSQL.

  • Disponible en open source.

  • Prise en charge des scripts côté serveur.

  • Suivez les propriétés ACID comme la durabilité et la concurrence.

  • Utilisation sharding pour partitioning.

Inconvénients de l'Impala

Certains des inconvénients de l'utilisation d'Impala sont les suivants:

  • Impala ne fournit aucun support pour la sérialisation et la désérialisation.
  • Impala ne peut lire que des fichiers texte, pas des fichiers binaires personnalisés.
  • Chaque fois que de nouveaux enregistrements / fichiers sont ajoutés au répertoire de données dans HDFS, la table doit être actualisée.

Ce chapitre explique les prérequis pour l'installation d'Impala, comment télécharger, installer et configurer Impala dans votre système.

Semblable à Hadoop et à son logiciel d'écosystème, nous devons installer Impala sur le système d'exploitation Linux. Depuis que cloudera a expédié l'Impala, il est disponible avecCloudera Quick Start VM.

Ce chapitre décrit comment télécharger Cloudera Quick Start VM et démarrez Impala.

Téléchargement de la VM de démarrage rapide de Cloudera

Suivez les étapes ci-dessous pour télécharger la dernière version de Cloudera QuickStartVM.

Étape 1

Ouvrez la page d'accueil du site Web de Cloudera http://www.cloudera.com/. Vous obtiendrez la page comme indiqué ci-dessous.

Étape 2

Clique le Sign in lien sur la page d'accueil de cloudera, qui vous redirigera vers la page de connexion comme indiqué ci-dessous.

Si vous n'êtes pas encore inscrit, cliquez sur le Register Now lien qui vous donnera Account Registrationforme. Inscrivez-vous là-bas et connectez-vous au compte cloudera.

Étape 3

Après vous être connecté, ouvrez la page de téléchargement du site Web de cloudera en cliquant sur le Downloads lien mis en évidence dans l'instantané suivant.

Étape 4 - Téléchargez QuickStartVM

Téléchargez la cloudera QuickStartVM en cliquant sur le Download Now bouton, comme mis en évidence dans l'instantané suivant

Cela vous redirigera vers la page de téléchargement de QuickStart VM.

Clique le Get ONE NOW , acceptez le contrat de licence et cliquez sur le bouton Soumettre comme indiqué ci-dessous.

Cloudera fournit ses VMware, KVM et VIRTUALBOX compatibles VM. Sélectionnez la version requise. Ici, dans notre tutoriel, nous démontrons leCloudera QuickStartVM configuration à l'aide de la boîte virtuelle, cliquez donc sur le VIRTUALBOX DOWNLOAD bouton, comme indiqué dans l'instantané ci-dessous.

Cela commencera à télécharger un fichier nommé cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf qui est un fichier image de boîte virtuelle.

Importation de Cloudera QuickStartVM

Après avoir téléchargé le cloudera-quickstart-vm-5.5.0-0-virtualbox.ovffichier, nous devons l'importer à l'aide de la boîte virtuelle. Pour cela, tout d'abord, vous devez installer Virtual Box dans votre système. Suivez les étapes ci-dessous pour importer le fichier image téléchargé.

Étape 1

Téléchargez la boîte virtuelle à partir du lien suivant et installez-la https://www.virtualbox.org/

Étape 2

Ouvrez le logiciel de la boîte virtuelle. Cliquez surFile et choisissez Import Appliance, comme indiqué ci-dessous.

Étape 3

En cliquant Import Appliance, vous obtiendrez la fenêtre Importer une appliance virtuelle. Sélectionnez l'emplacement du fichier image téléchargé comme indiqué ci-dessous.

Après l'importation Cloudera QuickStartVMimage, démarrez la machine virtuelle. Cette machine virtuelle a Hadoop, cloudera Impala et tous les logiciels requis installés. L'instantané de la machine virtuelle est illustré ci-dessous.

Démarrage d'Impala Shell

Pour démarrer Impala, ouvrez le terminal et exécutez la commande suivante.

[[email protected] ~] $ impala-shell

Cela démarrera l'Impala Shell, affichant le message suivant.

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 - Nous discuterons de toutes les commandes impala-shell dans les chapitres suivants.

Éditeur de requête Impala

En plus de Impala shell, vous pouvez communiquer avec Impala à l'aide du navigateur Hue. Après avoir installé CDH5 et démarré Impala, si vous ouvrez votre navigateur, vous obtiendrez la page d'accueil de cloudera comme indiqué ci-dessous.

Maintenant, cliquez sur le signet Huepour ouvrir le navigateur Hue. En cliquant, vous pouvez voir la page de connexion du navigateur Hue, en vous connectant avec les informations d'identification cloudera et cloudera.

Dès que vous vous connectez au navigateur Hue, vous pouvez voir l'assistant de démarrage rapide du navigateur Hue comme indiqué ci-dessous.

En cliquant sur le Query Editors menu déroulant, vous obtiendrez la liste des éditeurs pris en charge par Impala comme indiqué dans la capture d'écran suivante.

En cliquant Impala dans le menu déroulant, vous obtiendrez l'éditeur de requête Impala comme indiqué ci-dessous.

Impala est un moteur d'exécution de requêtes MPP (Massive Parallel Processing) qui s'exécute sur un certain nombre de systèmes du cluster Hadoop. Contrairement aux systèmes de stockage traditionnels, impala est découplé de son moteur de stockage. Il a trois composants principaux à savoir, Impala daemon (Impalad) , Impala Statestore et métadonnées ou métastore Impala.

Démon Impala ( Impalad )

Démon Impala (également connu sous le nom de impalad) s'exécute sur chaque nœud sur lequel Impala est installé. Il accepte les requêtes provenant de différentes interfaces comme impala shell, navigateur hue, etc.… et les traite.

Chaque fois qu'une requête est soumise à un impalade sur un nœud particulier, ce nœud sert de "coordinator node”Pour cette requête. Plusieurs requêtes sont également servies par Impalad s'exécutant sur d'autres nœuds. Après avoir accepté la requête, Impalad lit et écrit dans des fichiers de données et met en parallèle les requêtes en distribuant le travail aux autres nœuds Impala du cluster Impala. Lorsque des requêtes sont traitées sur différentes instances d'Impalad , toutes renvoient le résultat au nœud central de coordination.

Selon les besoins, les requêtes peuvent être soumises à un Impalad dédié ou de manière équilibrée en charge à un autre Impalad de votre cluster.

Magasin d'État Impala

Impala a un autre composant important appelé Impala State store, qui est chargé de vérifier la santé de chaque Impalad , puis de relayer fréquemment la santé de chaque démon Impala aux autres démons. Cela peut s'exécuter sur le même nœud où le serveur Impala ou un autre nœud du cluster est en cours d'exécution.

Le nom du processus démon de stockage d'état Impala est Stocké d' état . Impalad signale son état de santé au démon de stockage Impala State, c'est-à-dire l' état stocké .

En cas de défaillance d'un nœud pour une raison quelconque, Statestore met à jour tous les autres nœuds à propos de cette défaillance et une fois qu'une telle notification est disponible pour l'autre impalad , aucun autre démon Impala n'attribue d'autres requêtes au nœud affecté.

Metadata & Meta Store Impala

Les métadonnées et le magasin de méta d'Impala sont un autre composant important. Impala utilise des bases de données MySQL ou PostgreSQL traditionnelles pour stocker les définitions de table. Les détails importants tels que les informations de table et de colonne et les définitions de table sont stockés dans une base de données centralisée connue sous le nom de méta-magasin.

Chaque nœud Impala met en cache toutes les métadonnées localement. Lorsqu'il s'agit d'une très grande quantité de données et / ou de nombreuses partitions, l'obtention de métadonnées spécifiques à une table peut prendre un temps considérable. Ainsi, un cache de métadonnées stocké localement aide à fournir ces informations instantanément.

Lorsqu'une définition de table ou des données de table sont mises à jour, les autres démons Impala doivent mettre à jour leur cache de métadonnées en récupérant les dernières métadonnées avant d'émettre une nouvelle requête sur la table en question.

Interfaces de traitement des requêtes

Pour traiter les requêtes, Impala fournit trois interfaces comme indiqué ci-dessous.

  • Impala-shell - Après avoir configuré Impala à l'aide de la VM Cloudera, vous pouvez démarrer le shell Impala en tapant la commande impala-shelldans l'éditeur. Nous en discuterons plus sur le shell Impala dans les prochains chapitres.

  • Hue interface- Vous pouvez traiter les requêtes Impala à l'aide du navigateur Hue. Dans le navigateur Hue, vous avez l'éditeur de requêtes Impala où vous pouvez taper et exécuter les requêtes impala. Pour accéder à cet éditeur, vous devez tout d'abord vous connecter au navigateur Hue.

  • ODBC/JDBC drivers- Tout comme les autres bases de données, Impala fournit des pilotes ODBC / JDBC. En utilisant ces pilotes, vous pouvez vous connecter à impala via des langages de programmation prenant en charge ces pilotes et créer des applications qui traitent des requêtes dans impala à l'aide de ces langages de programmation.

Procédure d'exécution des requêtes

Chaque fois que les utilisateurs passent une requête à l'aide de l'une des interfaces fournies, cela est accepté par l'un des Impalads du cluster. Cet Impalad est traité comme un coordinateur pour cette requête particulière.

Après avoir reçu la requête, le coordinateur de requêtes vérifie si la requête est appropriée, en utilisant le Table Schemadu méta-boutique Hive. Plus tard, il recueille les informations sur l'emplacement des données nécessaires pour exécuter la requête, à partir du nœud de nom HDFS et envoie ces informations à d'autres impalades afin d'exécuter la requête.

Tous les autres démons Impala lisent le bloc de données spécifié et traitent la requête. Dès que tous les démons ont terminé leurs tâches, le coordinateur de requêtes récupère le résultat et le remet à l'utilisateur.

Dans les chapitres précédents, nous avons vu l'installation d'Impala en utilisant cloudera et son architecture.

  • Shell Impala (invite de commande)
  • Hue (interface utilisateur)
  • ODBC et JDBC (bibliothèques tierces)

Ce chapitre explique comment démarrer Impala Shell et les différentes options du shell.

Référence des commandes Impala Shell

Les commandes du shell Impala sont classées comme general commands, query specific options, et table and database specific options, comme expliqué ci-dessous.

Commandes générales

  • help
  • version
  • history
  • shell (ou)!
  • connect
  • sortir | quitter

Requête des options spécifiques

  • Set/unset
  • Profile
  • Explain

Options spécifiques aux tables et aux bases de données

  • Alter
  • describe
  • drop
  • insert
  • select
  • show
  • use

Démarrage d'Impala Shell

Ouvrez le terminal cloudera, connectez-vous en tant que superutilisateur et saisissez cloudera comme mot de passe comme indiqué ci-dessous.

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

Démarrez le shell Impala en tapant la commande suivante -

[[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 - Commandes à usage général

Les commandes générales d'Impala sont expliquées ci-dessous -

commande help

le help commande du shell Impala vous donne une liste des commandes disponibles dans 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

commande de version

le version La commande vous donne la version actuelle d'Impala, comme indiqué ci-dessous.

[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)

commande historique

le historyLa commande d'Impala affiche les 10 dernières commandes exécutées dans le shell. Voici l'exemple duhistorycommander. Ici, nous avons exécuté 5 commandes, à savoir la version, l'aide, l'affichage, l'utilisation et l'historique.

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

commande quit / exit

Vous pouvez sortir du shell Impala en utilisant le quit ou exit commande, comme indiqué ci-dessous.

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

commande connect

le connectLa commande est utilisée pour se connecter à une instance donnée d'Impala. Si vous ne spécifiez aucune instance, il se connecte au port par défaut21000 comme indiqué ci-dessous.

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

Options spécifiques à la requête Impala

Les commandes spécifiques à la requête d'Impala acceptent une requête. Ils sont expliqués ci-dessous -

Explique

le explain La commande renvoie le plan d'exécution pour la requête donnée.

[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

Profil

le profileLa commande affiche les informations de bas niveau sur la requête récente. Cette commande est utilisée pour le diagnostic et le réglage des performances d'une requête. Voici l'exemple d'unprofilecommander. Dans ce scénario, leprofile commande renvoie les informations de bas niveau de explain requete.

[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

Options spécifiques aux tables et aux bases de données

Le tableau suivant répertorie le tableau et les options spécifiques aux données dans Impala.

Sr.Non Commande et explication
1

Alter

le alter La commande est utilisée pour changer la structure et le nom d'une table dans Impala.

2

Describe

le describeLa commande d'Impala donne les métadonnées d'une table. Il contient des informations telles que des colonnes et leurs types de données. ledescribe la commande a desc comme un raccourci.

3

Drop

le drop La commande est utilisée pour supprimer une construction d'Impala, où une construction peut être une table, une vue ou une fonction de base de données.

4

insert

le insert la commande d'Impala est utilisée pour,

  • Ajoutez des données (colonnes) dans un tableau.
  • Remplacez les données d'une table existante.
  • Remplacez les données d'une table existante.
5

select

le selectinstruction est utilisée pour effectuer une opération souhaitée sur un ensemble de données particulier. Il spécifie l'ensemble de données sur lequel effectuer une action. Vous pouvez imprimer ou stocker (dans un fichier) le résultat de l'instruction select.

6

show

le show L'instruction d'Impala est utilisée pour afficher le métastore de diverses constructions telles que des tables, des bases de données et des tables.

sept

use

le use La déclaration d'Impala est utilisée pour changer le contexte actuel vers la base de données souhaitée.

Types de données Impala

Le tableau suivant décrit les types de données Impala.

Sr.Non Type de données et description
1

BIGINT

Ce type de données stocke des valeurs numériques et la plage de ce type de données va de -9223372036854775808 à 9223372036854775807. Ce type de données est utilisé dans les instructions create table et alter table.

2

BOOLEAN

Ce type de données stocke uniquement true ou false values ​​et il est utilisé dans la définition de colonne de l'instruction create table.

3

CHAR

Ce type de données est un stockage de longueur fixe, il est rempli d'espaces, vous pouvez stocker jusqu'à une longueur maximale de 255.

4

DECIMAL

Ce type de données est utilisé pour stocker les valeurs décimales et il est utilisé dans les instructions create table et alter table.

5

DOUBLE

Ce type de données est utilisé pour stocker les valeurs à virgule flottante dans la plage positive ou négative 4,94065645841246544e-324d -1,79769313486231570e + 308.

6

FLOAT

Ce type de données est utilisé pour stocker des types de données à valeur flottante simple précision dans la plage positive ou négative 1.40129846432481707e-45 .. 3.40282346638528860e + 38.

sept

INT

Ce type de données est utilisé pour stocker un entier de 4 octets dans la plage de -2147483648 à 2147483647.

8

SMALLINT

Ce type de données est utilisé pour stocker un entier de 2 octets dans la plage de -32768 à 32767.

9

STRING

Ceci est utilisé pour stocker des valeurs de chaîne.

dix

TIMESTAMP

Ce type de données est utilisé pour représenter un point dans un temps.

11

TINYINT

Ce type de données est utilisé pour stocker une valeur entière de 1 octet dans la plage de -128 à 127.

12

VARCHAR

Ce type de données est utilisé pour stocker des caractères de longueur variable jusqu'à la longueur maximale 65 535.

13

ARRAY

Il s'agit d'un type de données complexe et il est utilisé pour stocker un nombre variable d'éléments ordonnés.

14

Map

Il s'agit d'un type de données complexe utilisé pour stocker un nombre variable de paires clé-valeur.

15

Struct

Il s'agit d'un type de données complexe utilisé pour représenter plusieurs champs d'un même élément.

Commentaires dans Impala

Les commentaires dans Impala sont similaires à ceux de SQL. En général, nous avons deux types de commentaires dans les langages de programmation, à savoir les commentaires sur une seule ligne et les commentaires sur plusieurs lignes.

Single-line comments- Chaque ligne suivie de "-" est considérée comme un commentaire dans Impala. Voici un exemple de commentaires sur une seule ligne dans Impala.

-- Hello welcome to tutorials point.

Multiline comments - Toutes les lignes entre /* et */sont considérés comme des commentaires multilignes dans Impala. Voici un exemple de commentaires multilignes dans Impala.

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

Les opérateurs d'Impala sont similaires à ceux de SQL. Référez-vous à notre tutoriel SQL en cliquant sur le lien suivantopérateurs sql.

Impala - Créer une base de données

Dans Impala, une base de données est une construction qui contient des tables, des vues et des fonctions liées dans leurs espaces de noms. Il est représenté sous la forme d'une arborescence de répertoires dans HDFS; il contient des partitions de tables et des fichiers de données. Ce chapitre explique comment créer une base de données dans Impala.

Instruction CREATE DATABASE

le CREATE DATABASE Statement est utilisé pour créer une nouvelle base de données dans Impala.

Syntaxe

Voici la syntaxe du CREATE DATABASE Déclaration.

CREATE DATABASE IF NOT EXISTS database_name;

Ici, IF NOT EXISTSest une clause facultative. Si nous utilisons cette clause, une base de données avec le nom donné est créée, uniquement s'il n'y a pas de base de données existante avec le même nom.

Exemple

Voici un exemple de create database statement. Dans cet exemple, nous avons créé une base de données avec le nommy_database.

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

Lors de l'exécution de la requête ci-dessus dans cloudera impala-shell, vous obtiendrez la sortie suivante.

Query: create DATABASE my_database 

Fetched 0 row(s) in 0.21s

Vérification

le SHOW DATABASES query donne la liste des bases de données dans Impala, vous pouvez donc vérifier si la base de données est créée, en utilisant le SHOWInstruction DATABASES. Ici vous pouvez observer la base de données nouvellement crééemy_db dans la liste.

[quickstart.cloudera:21000] > show databases; 

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

Chemin Hdfs

Pour créer une base de données dans le système de fichiers HDFS, vous devez spécifier l'emplacement où la base de données doit être créée.

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Création d'une base de données à l'aide du navigateur Hue

Ouvrez l'éditeur de requête Impala et saisissez le CREATE DATABASEdéclaration dedans. Ensuite, cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, déplacez doucement le curseur vers le haut du menu déroulant et vous trouverez un symbole d'actualisation. Si vous cliquez sur le symbole d'actualisation, la liste des bases de données sera actualisée et les modifications récentes y seront appliquées.

Vérification

Clique le drop-down box sous le titre DATABASEsur le côté gauche de l'éditeur. Vous pouvez y voir une liste des bases de données du système. Ici vous pouvez observer la base de données nouvellement crééemy_db comme indiqué ci-dessous.

Si vous observez attentivement, vous ne pouvez voir qu'une seule base de données, à savoir, my_db dans la liste avec la base de données par défaut.

le DROP DATABASE Statementd'Impala est utilisé pour supprimer une base de données d'Impala. Avant de supprimer la base de données, il est recommandé d'en supprimer toutes les tables.

Syntaxe

Voici la syntaxe de DROP DATABASE Déclaration.

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

Ici, IF EXISTSest une clause facultative. Si nous utilisons cette clause lorsqu'une base de données avec le nom donné existe, elle sera supprimée. Et s'il n'y a pas de base de données existante avec le nom donné, aucune opération n'est effectuée.

Exemple

Voici un exemple de DROP DATABASEdéclaration. Supposons que vous ayez une base de données dans Impala avec le nomsample_database.

Et, si vous vérifiez la liste des bases de données à l'aide du SHOW DATABASES déclaration, vous observerez le nom dedans.

[quickstart.cloudera:21000] > SHOW DATABASES;

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

Maintenant, vous pouvez supprimer cette base de données en utilisant le DROP DATABASE Statement comme indiqué ci-dessous.

< DROP DATABASE IF EXISTS sample_database;

Cela supprimera la base de données spécifiée et vous donnera la sortie suivante.

Query: drop DATABASE IF EXISTS sample_database;

Vérification

Vous pouvez vérifier si la base de données donnée est supprimée, en utilisant le SHOW DATABASESdéclaration. Ici, vous pouvez observer que la base de données nomméesample_database est supprimé de la liste des bases de données.

[quickstart.cloudera:21000] > SHOW DATABASES;

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

Cascade

En général, pour supprimer une base de données, vous devez supprimer manuellement toutes les tables qu'elle contient. Si vous utilisez la cascade, Impala supprime les tables de la base de données spécifiée avant de la supprimer.

Exemple

Supposons qu'il existe une base de données dans Impala nommée sample, et il contient deux tableaux, à savoir, student et test. Si vous essayez de supprimer cette base de données directement, vous obtiendrez une erreur comme indiqué ci-dessous.

[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.

En utilisant cascade, vous pouvez supprimer cette base de données directement (sans supprimer manuellement son contenu) comme indiqué ci-dessous.

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

Note - Vous ne pouvez pas supprimer le "current database»Dans Impala. Par conséquent, avant de supprimer une base de données, vous devez vous assurer que le contexte actuel est défini sur la base de données autre que celle que vous allez supprimer.

Suppression d'une base de données à l'aide du navigateur Hue

Ouvrez l'éditeur de requête Impala et saisissez le DELETE DATABASEet cliquez sur le bouton Exécuter comme indiqué ci-dessous. Supposons qu'il existe trois bases de données, à savoir,my_db, my_database, et sample_databaseavec la base de données par défaut. Ici, nous supprimons la base de données nommée my_database.

Après avoir exécuté la requête, déplacez doucement le curseur vers le haut du menu déroulant. Ensuite, vous trouverez un symbole d'actualisation comme indiqué dans la capture d'écran ci-dessous. Si vous cliquez sur le symbole d'actualisation, la liste des bases de données sera actualisée et les modifications récentes apportées lui seront appliquées.

Vérification

Clique sur le drop down sous le titre DATABASEsur le côté gauche de l'éditeur. Là, vous pouvez voir une liste de bases de données dans le système. Ici vous pouvez observer la base de données nouvellement crééemy_db comme indiqué ci-dessous.

Si vous observez attentivement, vous ne pouvez voir qu'une seule base de données, à savoir, my_db dans la liste avec la base de données par défaut.

Une fois connecté à Impala, il est nécessaire d'en sélectionner une parmi les bases de données disponibles. leUSE DATABASE Statement d'Impala est utilisé pour basculer la session en cours vers une autre base de données.

Syntaxe

Voici la syntaxe de USE Déclaration.

USE db_name;

Exemple

Voici un exemple de USE statement. Tout d'abord, créons une base de données avec le nomsample_database comme indiqué ci-dessous.

> CREATE DATABASE IF NOT EXISTS sample_database;

Cela créera une nouvelle base de données et vous donnera la sortie suivante.

Query: create DATABASE IF NOT EXISTS my_db2

Fetched 0 row(s) in 2.73s

Si vous vérifiez la liste des bases de données à l'aide du SHOW DATABASES déclaration, vous pouvez y observer le nom de la base de données nouvellement créée.

> SHOW DATABASES;

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

Maintenant, basculons la session vers la base de données nouvellement créée (sample_database) en utilisant le USE Déclaration comme indiqué ci-dessous.

> USE sample_database;

Cela changera le contexte actuel en sample_database et affichera un message comme indiqué ci-dessous.

Query: use sample_database

Sélection d'une base de données à l'aide du navigateur Hue

Sur le côté gauche du Query Editor d'Impala, vous trouverez un menu déroulant comme indiqué dans la capture d'écran suivante.

Si vous cliquez sur le menu déroulant, vous trouverez la liste de toutes les bases de données d'Impala comme indiqué ci-dessous.

Sélectionnez simplement la base de données dans laquelle vous devez modifier le contexte actuel.

le CREATE TABLEL'instruction est utilisée pour créer une nouvelle table dans la base de données requise dans Impala. La création d'une table de base implique de nommer la table et de définir ses colonnes et le type de données de chaque colonne.

Syntaxe

Voici la syntaxe du CREATE TABLEDéclaration. Ici,IF NOT EXISTSest une clause facultative. Si nous utilisons cette clause, une table avec le nom donné est créée, uniquement s'il n'y a pas de table existante dans la base de données spécifiée avec le même nom.

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

CREATE TABLE est le mot-clé qui demande au système de base de données de créer une nouvelle table. Le nom ou l'identificateur unique de la table suit l'instruction CREATE TABLE. Vous pouvez éventuellement spécifierdatabase_name de même que table_name.

Exemple

Voici un exemple de l'instruction create table. Dans cet exemple, nous avons créé une table nomméestudent dans la base de données my_db.

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

Lors de l'exécution de l'instruction ci-dessus, une table avec le nom spécifié sera créée, affichant la sortie suivante.

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

Fetched 0 row(s) in 0.48s

Vérification

le show Tablesquery donne une liste des tables de la base de données courante dans Impala. Par conséquent, vous pouvez vérifier si la table est créée à l'aide duShow Tables déclaration.

Tout d'abord, vous devez basculer le contexte vers la base de données dans laquelle la table requise existe, comme indiqué ci-dessous.

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

Ensuite, si vous obtenez la liste des tables en utilisant le show tables requête, vous pouvez observer la table nommée student dedans comme indiqué ci-dessous.

[quickstart.cloudera:21000] > show tables;

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

Chemin HDFS

Pour créer une base de données dans le système de fichiers HDFS, vous devez spécifier l'emplacement où la base de données doit être créée comme indiqué ci-dessous.

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Création d'une base de données à l'aide du navigateur Hue

Ouvrez l'éditeur de requête impala et tapez le CREATE TableDéclaration dedans. Et cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, déplacez doucement le curseur vers le haut du menu déroulant et vous trouverez un symbole d'actualisation. Si vous cliquez sur le symbole d'actualisation, la liste des bases de données sera actualisée et les modifications récentes apportées lui seront appliquées.

Vérification

Clique sur le drop down sous le titre DATABASEsur le côté gauche de l'éditeur. Là, vous pouvez voir une liste de bases de données. Sélectionnez la base de donnéesmy_db comme indiqué ci-dessous.

Sur la sélection de la base de données my_dbvous pouvez y voir une liste de tableaux comme indiqué ci-dessous. Ici vous pouvez trouver la table nouvellement crééestudent comme indiqué ci-dessous.

le INSERT La déclaration d'Impala comporte deux clauses - into et overwrite. Insérer une déclaration avecinto La clause est utilisée pour ajouter de nouveaux enregistrements dans une table existante dans une base de données.

Syntaxe

Il existe deux syntaxes de base de INSERT déclaration comme suit -

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

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

Ici, colonne1, colonne2, ... colonneN sont les noms des colonnes du tableau dans lesquelles vous souhaitez insérer des données.

Vous pouvez également ajouter des valeurs sans spécifier les noms de colonne mais, pour cela, vous devez vous assurer que l'ordre des valeurs est dans le même ordre que les colonnes du tableau comme indiqué ci-dessous.

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

CREATE TABLE est le mot-clé indiquant au système de base de données de créer une nouvelle table. Le nom ou l'identificateur unique de la table suit l'instruction CREATE TABLE. Vous pouvez éventuellement spécifierdatabase_name avec le table_name.

Exemple

Supposons que nous ayons créé une table nommée student dans Impala comme indiqué ci-dessous.

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

Voici un exemple de création d'un enregistrement dans la table nommée employee.

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

Lors de l'exécution de l'instruction ci-dessus, un enregistrement est inséré dans la table nommée employee affichant le message suivant.

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

Vous pouvez insérer un autre enregistrement sans spécifier les noms de colonne comme indiqué ci-dessous.

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

Lors de l'exécution de l'instruction ci-dessus, un enregistrement est inséré dans la table nommée employee affichant le message suivant.

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

Vous pouvez insérer quelques enregistrements supplémentaires dans le tableau des employés comme indiqué ci-dessous.

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 );

Après avoir inséré les valeurs, le employee table dans Impala sera comme indiqué ci-dessous.

+----+----------+-----+-----------+--------+
| 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  |
+----+----------+-----+-----------+--------+

Écraser les données dans une table

Nous pouvons écraser les enregistrements d'une table en utilisant la clause overwrite. Les enregistrements écrasés seront définitivement supprimés de la table. Voici la syntaxe d'utilisation de la clause overwrite.

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

Exemple

Voici un exemple d'utilisation de la clause overwrite.

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

Lors de l'exécution de la requête ci-dessus, cela écrasera les données de la table par l'enregistrement spécifié affichant le message suivant.

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

En vérifiant la table, vous pouvez observer que tous les enregistrements de la table employee sont écrasés par de nouveaux enregistrements comme indiqué ci-dessous.

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

Insertion de données à l'aide du navigateur Hue

Ouvrez l'éditeur de requête Impala et saisissez le insertDéclaration dedans. Et cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête / l'instruction, cet enregistrement est ajouté à la table.

Impala SELECTL'instruction est utilisée pour récupérer les données d'une ou plusieurs tables d'une base de données. Cette requête renvoie des données sous forme de tables.

Syntaxe

Voici la syntaxe de l'Impala select déclaration.

SELECT column1, column2, columnN from table_name;

Ici, colonne1, colonne2 ... sont les champs d'une table dont vous voulez récupérer les valeurs. Si vous souhaitez récupérer tous les champs disponibles dans le champ, vous pouvez utiliser la syntaxe suivante -

SELECT * FROM table_name;

Exemple

Supposons que nous ayons une table nommée customers à Impala, avec les données suivantes -

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

Vous pouvez récupérer le id, name, et age de tous les enregistrements du customers table utilisant select déclaration comme indiqué ci-dessous -

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

Lors de l'exécution de la requête ci-dessus, Impala récupère l'identifiant, le nom, l'âge de tous les enregistrements de la table spécifiée et les affiche comme indiqué ci-dessous.

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

Vous pouvez également récupérer all les enregistrements du customers table en utilisant le select requête comme indiqué ci-dessous.

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

Lors de l'exécution de la requête ci-dessus, Impala récupère et affiche tous les enregistrements de la table spécifiée comme indiqué ci-dessous.

+----+----------+-----+-----------+--------+
| 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

Récupération des enregistrements à l'aide de Hue

Ouvrez l'éditeur de requête Impala et saisissez le selectDéclaration dedans. Et cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, si vous faites défiler vers le bas et sélectionnez le Results onglet, vous pouvez voir la liste des enregistrements de la table spécifiée comme indiqué ci-dessous.

le describeL'instruction dans Impala est utilisée pour donner la description de la table. Le résultat de cette instruction contient les informations sur une table, telles que les noms de colonnes et leurs types de données.

Syntaxe

Voici la syntaxe de l'Impala describe déclaration.

Describe table_name;

Exemple

Par exemple, supposons que nous ayons une table nommée customer à Impala, avec les données suivantes -

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

Vous pouvez obtenir la description du customer table en utilisant le describe déclaration comme indiqué ci-dessous -

[quickstart.cloudera:21000] > describe customer;

Lors de l'exécution de la requête ci-dessus, Impala récupère le metadata du tableau spécifié et l'affiche comme indiqué ci-dessous.

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

Fetched 5 row(s) in 0.51s

Décrire les enregistrements à l'aide de Hue

Ouvrez l'éditeur de requête Impala et saisissez le describe et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, si vous faites défiler vers le bas et sélectionnez le Results onglet, vous pouvez voir les métadonnées du tableau comme indiqué ci-dessous.

L'instruction Alter table dans Impala est utilisée pour effectuer des modifications sur une table donnée. En utilisant cette instruction, nous pouvons ajouter, supprimer ou modifier des colonnes dans une table existante et nous pouvons également la renommer.

Ce chapitre explique différents types d'instructions alter avec une syntaxe et des exemples. Supposons tout d'abord que nous avons une table nomméecustomers dans le my_db base de données dans Impala, avec les données suivantes

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

Et, si vous obtenez la liste des tables de la base de données my_db, vous pouvez trouver le customers table comme indiqué ci-dessous.

[quickstart.cloudera:21000] > show tables;

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

Modifier le nom d'une table

Syntaxe

La syntaxe de base de ALTER TABLE pour renommer une table existante est comme suit -

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

Exemple

Voici un exemple de modification du nom de la table à l'aide du alterdéclaration. Ici, nous changeons le nom de la tablecustomers aux utilisateurs.

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

Après avoir exécuté la requête ci-dessus, Impala modifie le nom de la table selon les besoins, affichant le message suivant.

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

Vous pouvez vérifier la liste des tables de la base de données actuelle en utilisant le show tablesdéclaration. Vous pouvez trouver la table nomméeusers au lieu de customers.

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

Ajouter des colonnes à une table

Syntaxe

La syntaxe de base de ALTER TABLE pour ajouter des colonnes à une table existante est comme suit -

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

Exemple

La requête suivante est un exemple montrant comment ajouter des colonnes à une table existante. Ici, nous ajoutons deux colonnes account_no et phone_number (les deux sont de type bigint) à lausers table.

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

Lors de l'exécution de la requête ci-dessus, il ajoutera les colonnes spécifiées à la table nommée student, affichant le message suivant.

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

Si vous vérifiez le schéma de la table users, vous pouvez y trouver les nouvelles colonnes ajoutées comme indiqué ci-dessous.

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

Supprimer des colonnes d'une table

Syntaxe

La syntaxe de base d'ALTER TABLE pour DROP COLUMN dans une table existante est la suivante -

ALTER TABLE name DROP [COLUMN] column_name

Exemple

La requête suivante est un exemple de suppression de colonnes d'une table existante. Ici, nous supprimons la colonne nomméeaccount_no.

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

Lors de l'exécution de la requête ci-dessus, Impala supprime la colonne nommée account_no affichant le message suivant.

Query: alter TABLE users DROP account_no

Si vous vérifiez le schéma de la table users, vous ne trouvez pas la colonne nommée account_no depuis qu'il a été supprimé.

[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

Changer le nom et le type d'une colonne

Syntaxe

La syntaxe de base d'ALTER TABLE pour change the name and datatype d'une colonne dans une table existante est la suivante -

ALTER TABLE name CHANGE column_name new_name new_type

Exemple

Voici un exemple de modification du nom et du type de données d'une colonne à l'aide de l'instruction alter. Ici, nous changeons le nom de la colonnephone_no to email et son type de données à string.

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

Lors de l'exécution de la requête ci-dessus, Impala effectue les modifications spécifiées, affichant le message suivant.

Query: alter TABLE users CHANGE phone_no e_mail string

Vous pouvez vérifier les métadonnées des utilisateurs de la table à l'aide du describedéclaration. Vous pouvez observer qu'Impala a apporté les modifications requises à la colonne spécifiée.

[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

Modifier un tableau à l'aide de Hue

Ouvrez l'éditeur de requête Impala et saisissez le alter et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Lors de l'exécution de la requête ci-dessus, cela changera le nom de la table customers à users. De la même manière, nous pouvons exécuter tous lesalter requêtes.

L'Impala drop tableest utilisée pour supprimer une table existante dans Impala. Cette instruction supprime également les fichiers HDFS sous-jacents pour les tables internes

NOTE - Vous devez être prudent lorsque vous utilisez cette commande car une fois qu'une table est supprimée, toutes les informations disponibles dans la table seront également perdues à jamais.

Syntaxe

Voici la syntaxe du DROP TABLEDéclaration. Ici,IF EXISTSest une clause facultative. Si nous utilisons cette clause, une table portant le nom donné est supprimée, uniquement si elle existe. Sinon, aucune opération ne sera effectuée.

DROP table database_name.table_name;

Si vous essayez de supprimer une table qui n'existe pas sans la clause IF EXISTS, une erreur sera générée. Vous pouvez éventuellement spécifierdatabase_name avec table_name.

Exemple

Vérifions d'abord la liste des tables de la base de données my_db comme indiqué ci-dessous.

[quickstart.cloudera:21000] > show tables;

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

À partir du résultat ci-dessus, vous pouvez observer que la base de données my_db contient 3 tableaux

Voici un exemple de drop table statement. Dans cet exemple, nous supprimons la table nomméestudent de la base de données my_db.

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

Lors de l'exécution de la requête ci-dessus, une table avec le nom spécifié sera supprimée, affichant la sortie suivante.

Query: drop table if exists student

Vérification

le show Tablesquery donne une liste des tables de la base de données courante dans Impala. Par conséquent, vous pouvez vérifier si une table est supprimée à l'aide duShow Tables déclaration.

Tout d'abord, vous devez basculer le contexte vers la base de données dans laquelle la table requise existe, comme indiqué ci-dessous.

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

Ensuite, si vous obtenez la liste des tables en utilisant le show tables requête, vous pouvez observer la table nommée student n'est pas dans la liste.

[quickstart.cloudera:21000] > show tables; 

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

Création d'une base de données à l'aide du navigateur Hue

Ouvrez l'éditeur de requête Impala et saisissez le drop TableDéclaration dedans. Et cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, déplacez doucement le curseur vers le haut du menu déroulant et vous trouverez un symbole d'actualisation. Si vous cliquez sur le symbole d'actualisation, la liste des bases de données sera actualisée et les modifications récentes apportées lui seront appliquées.

Vérification

Clique sur le drop down sous le titre DATABASEsur le côté gauche de l'éditeur. Là, vous pouvez voir une liste de bases de données; sélectionnez la base de donnéesmy_db comme indiqué ci-dessous.

Sur la sélection de la base de données my_db, vous pouvez y voir une liste de tableaux comme indiqué ci-dessous. Ici, vous ne trouvez pas la table suppriméestudent dans la liste comme indiqué ci-dessous.

le Truncate Table La déclaration d'Impala est utilisée pour supprimer tous les enregistrements d'une table existante.

Vous pouvez également utiliser la commande DROP TABLE pour supprimer une table complète, mais cela supprimerait la structure de table complète de la base de données et vous devrez recréer cette table une fois de plus si vous souhaitez stocker des données.

Syntaxe

Voici la syntaxe de l'instruction de table tronquée.

truncate table_name;

Exemple

Supposons que nous ayons une table nommée customersdans Impala, et si vous vérifiez son contenu, vous obtenez le résultat suivant. Cela signifie que la table des clients contient 6 enregistrements.

[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   | 
+----+----------+-----+-----------+--------+--------+

Voici un exemple de troncature d'une table dans Impala à l'aide de truncate statement. Ici, nous supprimons tous les enregistrements de la table nomméecustomers.

[quickstart.cloudera:21000] > truncate customers;

Lors de l'exécution de l'instruction ci-dessus, Impala supprime tous les enregistrements de la table spécifiée, affichant le message suivant.

Query: truncate customers 

Fetched 0 row(s) in 0.37s

Vérification

Si vous vérifiez le contenu de la table des clients, après l'opération de suppression, utilisez select déclaration, vous obtiendrez une ligne vide comme indiqué ci-dessous.

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

Fetched 0 row(s) in 0.12s

Tronquer une table à l'aide du navigateur Hue

Ouvrez l'éditeur de requête Impala et saisissez le truncateDéclaration dedans. Et cliquez sur le bouton d'exécution comme indiqué dans la capture d'écran suivante.

Après l'exécution de la requête / instruction, tous les enregistrements de la table sont supprimés.

le show tables L'instruction dans Impala est utilisée pour obtenir la liste de toutes les tables existantes dans la base de données courante.

Exemple

Voici un exemple de show tablesdéclaration. Si vous souhaitez obtenir la liste des tables dans une base de données particulière, tout d'abord, changez le contexte de la base de données requise et obtenez la liste des tables qu'elle contientshow tables comme indiqué ci-dessous.

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

Lors de l'exécution de la requête ci-dessus, Impala récupère la liste de toutes les tables de la base de données spécifiée et l'affiche comme indiqué ci-dessous.

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

Lister les tables à l'aide de Hue

Ouvrez l'éditeur de requête impala, sélectionnez le contexte comme my_db et tapez le show tables et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, si vous faites défiler vers le bas et sélectionnez le Results onglet, vous pouvez voir la liste des tableaux comme indiqué ci-dessous.

Une vue n'est rien de plus qu'une instruction du langage de requête Impala qui est stockée dans la base de données avec un nom associé. Il s'agit d'une composition d'une table sous la forme d'une requête SQL prédéfinie.

Une vue peut contenir toutes les lignes d'un tableau ou celles sélectionnées. Une vue peut être créée à partir d'une ou de plusieurs tables. Les vues permettent aux utilisateurs de -

  • Structurez les données d'une manière que les utilisateurs ou les classes d'utilisateurs trouvent naturelle ou intuitive.

  • Restreignez l'accès aux données afin qu'un utilisateur puisse voir et (parfois) modifier exactement ce dont il a besoin et rien de plus.

  • Résumez les données de diverses tables qui peuvent être utilisées pour générer des rapports.

Vous pouvez créer une vue à l'aide du Create View déclaration d'Impala.

Syntaxe

Voici la syntaxe de l'instruction create view. IF NOT EXISTSest une clause facultative. Si nous utilisons cette clause, une table avec le nom donné est créée, uniquement s'il n'y a pas de table existante dans la base de données spécifiée avec le même nom.

Create View IF NOT EXISTS view_name as Select statement

Exemple

Par exemple, supposons que nous ayons une table nommée customers dans le my_db base de données dans Impala, avec les données suivantes.

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

Voici un exemple de Create View Statement. Dans cet exemple, nous créons une vue commecustomers table qui contient les colonnes, le nom et l'âge.

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

Lors de l'exécution de la requête ci-dessus, une vue avec les colonnes souhaitées est créée, affichant le message suivant.

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

Vérification

Vous pouvez vérifier le contenu de la vue que vous venez de créer, en utilisant le select comme indiqué ci-dessous.

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

Cela produira le résultat suivant.

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

Création d'une vue à l'aide de Hue

Ouvrez l'éditeur de requête Impala, sélectionnez le contexte comme my_dbet tapez le Create View et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, si vous faites défiler vers le bas, vous pouvez voir le view nommé sample créé dans la liste des tableaux comme indiqué ci-dessous.

le Alter ViewLa déclaration d'Impala est utilisée pour changer une vue. À l'aide de cette instruction, vous pouvez modifier le nom d'une vue, modifier la base de données et la requête qui lui est associée.

Depuis un view est une construction logique, aucune donnée physique ne sera affectée par le alter view requete.

Syntaxe

Voici la syntaxe du Alter View déclaration

ALTER VIEW database_name.view_name as Select statement

Exemple

Par exemple, supposons que nous ayons une vue nommée customers_view dans le my_db base de données dans Impala avec le contenu suivant.

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

Voici un exemple de Alter View Statement. Dans cet exemple, nous incluons les colonnes id, nom et salaire au lieu du nom et de l'âge dans lecustomers_view.

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

Lors de l'exécution de la requête ci-dessus, Impala apporte les modifications spécifiées au customers_view, affichant le message suivant.

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

Vérification

Vous pouvez vérifier le contenu du view nommé customers_view, en utilisant le select comme indiqué ci-dessous.

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

Cela produira le résultat suivant.

+----+----------+--------+ 
| 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

Modification d'une vue à l'aide de Hue

Ouvrez l'éditeur de requête Impala, sélectionnez le contexte comme my_dbet tapez le Alter View et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, le view nommé sample sera modifié en conséquence.

le Drop ViewLa requête d'Impala est utilisée pour supprimer une vue existante. Depuis unview est une construction logique, aucune donnée physique ne sera affectée par le drop view requete.

Syntaxe

Voici la syntaxe de l'instruction drop view.

DROP VIEW database_name.view_name;

Exemple

Par exemple, supposons que nous ayons une vue nommée customers_view dans le my_db base de données dans Impala avec le contenu suivant.

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

Voici un exemple de Drop View Statement. Dans cet exemple, nous essayons de supprimer leview nommé customers_view en utilisant le drop view requete.

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

Lors de l'exécution de la requête ci-dessus, Impala supprime la vue spécifiée, affichant le message suivant.

Query: drop view customers_view

Vérification

Si vous vérifiez la liste des tables en utilisant show tables déclaration, vous pouvez observer que le view nommé customers_view est supprimé.

[quickstart.cloudera:21000] > show tables;

Cela produira le résultat suivant.

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

Suppression d'une vue à l'aide de Hue

Ouvrez l'éditeur de requête Impala, sélectionnez le contexte comme my_dbet tapez le Drop view et cliquez sur le bouton Exécuter comme indiqué dans la capture d'écran suivante.

Après avoir exécuté la requête, si vous faites défiler vers le bas, vous pouvez voir une liste nommée TABLES. Cette liste contient tous lestables et viewsdans la base de données actuelle. Dans cette liste, vous pouvez trouver que le spécifiéview A été supprimée.

L'Impala ORDER BYLa clause est utilisée pour trier les données dans un ordre croissant ou décroissant, en fonction d'une ou plusieurs colonnes. Par défaut, certaines bases de données trient les résultats de la requête par ordre croissant.

Syntaxe

Voici la syntaxe de la clause ORDER BY.

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

Vous pouvez organiser les données du tableau par ordre croissant ou décroissant à l'aide des mots-clés ASC ou DESC respectivement.

De la même manière, si nous utilisons NULLS FIRST, toutes les valeurs nulles du tableau sont disposées dans les premières lignes; et si nous utilisons NULLS LAST, les lignes contenant des valeurs nulles seront arrangées en dernier.

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

Voici un exemple d'organisation des données dans le customers table, dans l'ordre croissant de leur id’s en utilisant le order by clause.

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

Lors de l'exécution, la requête ci-dessus produit la sortie suivante.

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

De la même manière, vous pouvez organiser les données de customers tableau dans l'ordre décroissant à l'aide du order by clause comme indiqué ci-dessous.

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

Lors de l'exécution, la requête ci-dessus produit la sortie suivante.

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 clause est utilisée en collaboration avec l'instruction SELECT pour organiser des données identiques en groupes.

Syntaxe

Voici la syntaxe de la clause GROUP BY.

select data from table_name Group BY col_name;

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

Vous pouvez obtenir le montant total du salaire de chaque client en utilisant la requête GROUP BY comme indiqué ci-dessous.

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

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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

Supposons que cette table comporte plusieurs enregistrements comme indiqué ci-dessous.

+----+----------+-----+-----------+--------+ 
| 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  | 
+----+----------+-----+-----------+--------+

Maintenant encore, vous pouvez obtenir le montant total des salaires des employés, compte tenu des entrées répétées d'enregistrements, en utilisant le Group By clause comme indiqué ci-dessous.

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

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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

le Having clause dans Impala vous permet de spécifier des conditions qui filtrent les résultats de groupe qui apparaissent dans les résultats finaux.

En général, le Having clause est utilisée avec group byclause; il place des conditions sur les groupes créés par la clause GROUP BY.

Syntaxe

Voici la syntaxe du Havingclause.

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

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

Voici un exemple d'utilisation Having clause dans Impala -

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

Cette requête regroupe initialement la table par âge et sélectionne les salaires maximums de chaque groupe et affiche les salaires supérieurs à 20000, comme indiqué ci-dessous.

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

le limit dans Impala est utilisée pour limiter le nombre de lignes d'un jeu de résultats à un nombre souhaité, c'est-à-dire que le jeu de résultats de la requête ne contient pas les enregistrements au-delà de la limite spécifiée.

Syntaxe

Voici la syntaxe du Limit clause dans Impala.

select * from table_name order by id limit numerical_expression;

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

Vous pouvez organiser les enregistrements de la table dans l'ordre croissant de leurs identifiants en utilisant le order by clause comme indiqué ci-dessous.

[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

Maintenant, en utilisant le limit , vous pouvez limiter le nombre d'enregistrements de la sortie à 4, en utilisant la limit clause comme indiqué ci-dessous.

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

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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

En général, les lignes du jeu de résultats d'un select la requête commence à 0. L'utilisation de offsetclause, nous pouvons décider d'où la sortie doit être considérée. Par exemple, si nous choisissons le décalage sur 0, le résultat sera comme d'habitude et si nous choisissons le décalage sur 5, le résultat commence à partir de la cinquième ligne.

Syntaxe

Voici la syntaxe du offsetclause dans Impala.

select data from table_name Group BY col_name;

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

Vous pouvez organiser les enregistrements de la table dans l'ordre croissant de leurs identifiants et limiter le nombre d'enregistrements à 4, en utilisant limit et order by clauses comme indiqué ci-dessous.

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

Voici un exemple de offsetclause. Ici, nous obtenons les enregistrements dans lecustomerstable dans l'ordre de leurs identifiants et en imprimant les quatre premières lignes à partir de la 0 ème ligne.

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

Lors de l'exécution, la requête ci-dessus donne le résultat suivant.

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

De la même manière, vous pouvez obtenir quatre enregistrements du customers table à partir de la ligne ayant le décalage 5 comme indiqué ci-dessous.

[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

Vous pouvez combiner les résultats de deux requêtes en utilisant le Union clause d'Impala.

Syntaxe

Voici la syntaxe du Union clause dans Impala.

query1 union query2;

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

De la même manière, supposons que nous ayons une autre table nommée employee et son contenu est le suivant -

[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

Voici un exemple de unionclause dans Impala. Dans cet exemple, nous organisons les enregistrements dans les deux tables dans l'ordre de leurs identifiants et limitons leur nombre par 3 en utilisant deux requêtes distinctes et en joignant ces requêtes à l'aide duUNION clause.

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

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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

Dans le cas où une requête est beaucoup trop complexe, nous pouvons définir aliases à des pièces complexes et les inclure dans la requête à l'aide du with clause d'Impala.

Syntaxe

Voici la syntaxe du with clause dans Impala.

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

Exemple

Supposons que nous ayons une table nommée customers dans la base de données my_db et son contenu est le suivant -

[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

De la même manière, supposons que nous ayons une autre table nommée employee et son contenu est le suivant -

[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

Voici un exemple de withclause dans Impala. Dans cet exemple, nous affichons les enregistrements des deuxemployee et customers dont l'âge est supérieur à 25 en utilisant with clause.

[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);

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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

le distinct L'opérateur dans Impala est utilisé pour obtenir les valeurs uniques en supprimant les doublons.

Syntaxe

Voici la syntaxe du distinct opérateur.

select distinct columns… from table_name;

Exemple

Supposons que nous ayons une table nommée customers dans Impala et son contenu est le suivant -

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

Ici vous pouvez observer le salaire des clients Ramesh et Chaitali entrés deux fois et en utilisant le distinct opérateur, nous pouvons sélectionner les valeurs uniques comme indiqué ci-dessous.

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

Lors de l'exécution, la requête ci-dessus donne la sortie suivante.

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