Hive - Guide rapide

Le terme `` Big Data '' est utilisé pour les collections de grands ensembles de données comprenant un volume énorme, une vitesse élevée et une variété de données qui augmentent de jour en jour. En utilisant les systèmes de gestion de données traditionnels, il est difficile de traiter le Big Data. Par conséquent, l'Apache Software Foundation a introduit un cadre appelé Hadoop pour résoudre les problèmes de gestion et de traitement des Big Data.

Hadoop

Hadoop est un framework open-source pour stocker et traiter le Big Data dans un environnement distribué. Il contient deux modules, l'un est MapReduce et l'autre est Hadoop Distributed File System (HDFS).

MapReduce: Il s'agit d'un modèle de programmation parallèle pour le traitement de grandes quantités de données structurées, semi-structurées et non structurées sur de grands groupes de matériel de base.
HDFS:Le système de fichiers distribués Hadoop fait partie du framework Hadoop, utilisé pour stocker et traiter les ensembles de données. Il fournit un système de fichiers tolérant aux pannes à exécuter sur du matériel standard.

L'écosystème Hadoop contient différents sous-projets (outils) tels que Sqoop, Pig et Hive qui sont utilisés pour aider les modules Hadoop.

Sqoop: Il est utilisé pour importer et exporter des données entre HDFS et RDBMS.
Pig: Il s'agit d'une plateforme de langage procédural utilisée pour développer un script pour les opérations MapReduce.
Hive: Il s'agit d'une plateforme utilisée pour développer des scripts de type SQL pour effectuer des opérations MapReduce.

Note: Il existe différentes manières d'exécuter des opérations MapReduce:

L'approche traditionnelle utilisant le programme Java MapReduce pour les données structurées, semi-structurées et non structurées.
L'approche de script pour MapReduce pour traiter des données structurées et semi-structurées à l'aide de Pig.
Le langage de requête Hive (HiveQL ou HQL) pour MapReduce pour traiter des données structurées à l'aide de Hive.

Qu'est-ce que la ruche

Hive est un outil d'infrastructure d'entrepôt de données pour traiter des données structurées dans Hadoop. Il réside au-dessus de Hadoop pour résumer le Big Data et facilite les requêtes et l'analyse.

Initialement, Hive a été développé par Facebook, plus tard, la Apache Software Foundation l'a repris et l'a développé en tant qu'open source sous le nom d'Apache Hive. Il est utilisé par différentes entreprises. Par exemple, Amazon l'utilise dans Amazon Elastic MapReduce.

Hive n'est pas

Une base de données relationnelle
Une conception pour le traitement des transactions en ligne (OLTP)
Un langage pour les requêtes en temps réel et les mises à jour au niveau des lignes

Caractéristiques de Hive

Il stocke le schéma dans une base de données et les données traitées dans HDFS.
Il est conçu pour OLAP.
Il fournit un langage de type SQL pour les requêtes appelé HiveQL ou HQL.
Il est familier, rapide, évolutif et extensible.

Architecture de la ruche

Le diagramme de composants suivant décrit l'architecture de Hive:

Ce diagramme de composants contient différentes unités. Le tableau suivant décrit chaque unité:

Nom de l'unité	Opération
Interface utilisateur	Hive est un logiciel d'infrastructure d'entrepôt de données qui peut créer une interaction entre l'utilisateur et HDFS. Les interfaces utilisateur prises en charge par Hive sont l'interface utilisateur Web Hive, la ligne de commande Hive et Hive HD Insight (dans le serveur Windows).
Meta Store	Hive choisit les serveurs de base de données respectifs pour stocker le schéma ou les métadonnées des tables, bases de données, colonnes d'une table, leurs types de données et le mappage HDFS.
Moteur de processus HiveQL	HiveQL est similaire à SQL pour interroger les informations de schéma sur le Metastore. C'est l'un des remplacements de l'approche traditionnelle du programme MapReduce. Au lieu d'écrire le programme MapReduce en Java, nous pouvons écrire une requête pour le travail MapReduce et le traiter.
Moteur d'exécution	La partie conjointe de HiveQL Process Engine et MapReduce est Hive Execution Engine. Le moteur d'exécution traite la requête et génère des résultats identiques aux résultats MapReduce. Il utilise la saveur de MapReduce.
HDFS ou HBASE	Le système de fichiers distribué Hadoop ou HBASE sont les techniques de stockage de données pour stocker les données dans le système de fichiers.

Fonctionnement de la ruche

Le diagramme suivant illustre le flux de travail entre Hive et Hadoop.

Le tableau suivant définit comment Hive interagit avec le framework Hadoop:

Étape No.	Opération
1	Execute Query L'interface Hive telle que la ligne de commande ou l'interface utilisateur Web envoie une requête au pilote (tout pilote de base de données tel que JDBC, ODBC, etc.) à exécuter.
2	Get Plan Le pilote prend l'aide du compilateur de requêtes qui analyse la requête pour vérifier la syntaxe et le plan de requête ou l'exigence de la requête.
3	Get Metadata Le compilateur envoie une demande de métadonnées à Metastore (n'importe quelle base de données).
4	Send Metadata Metastore envoie des métadonnées en réponse au compilateur.
5	Send Plan Le compilateur vérifie l'exigence et renvoie le plan au pilote. Jusqu'ici, l'analyse et la compilation d'une requête sont terminées.
6	Execute Plan Le pilote envoie le plan d'exécution au moteur d'exécution.
sept	Execute Job En interne, le processus d'exécution du travail est un travail MapReduce. Le moteur d'exécution envoie le travail à JobTracker, qui se trouve dans le nœud Nom et affecte ce travail à TaskTracker, qui se trouve dans le nœud Données. Ici, la requête exécute le travail MapReduce.
7,1	Metadata Ops Pendant l'exécution, le moteur d'exécution peut exécuter des opérations de métadonnées avec Metastore.
8	Fetch Result Le moteur d'exécution reçoit les résultats des nœuds de données.
9	Send Results Le moteur d'exécution envoie ces valeurs résultantes au pilote.
dix	Send Results Le pilote envoie les résultats aux interfaces Hive.

Tous les sous-projets Hadoop tels que Hive, Pig et HBase prennent en charge le système d'exploitation Linux. Par conséquent, vous devez installer n'importe quel système d'exploitation Linux. Les étapes simples suivantes sont exécutées pour l'installation de Hive:

Étape 1: Vérification de l'installation JAVA

Java doit être installé sur votre système avant d'installer Hive. Vérifions l'installation de java à l'aide de la commande suivante:

$ java –version

Si Java est déjà installé sur votre système, vous obtenez la réponse suivante:

java version "1.7.0_71" 
Java(TM) SE Runtime Environment (build 1.7.0_71-b13) 
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)

Si java n'est pas installé sur votre système, suivez les étapes ci-dessous pour installer java.

Installer Java

Étape I:

Téléchargez java (JDK <dernière version> - X64.tar.gz) en visitant le lien suivant http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html.

Ensuite, jdk-7u71-linux-x64.tar.gz sera téléchargé sur votre système.

Étape II:

En général, vous trouverez le fichier java téléchargé dans le dossier Téléchargements. Vérifiez-le et extrayez le fichier jdk-7u71-linux-x64.gz à l'aide des commandes suivantes.

$ cd Downloads/
$ ls jdk-7u71-linux-x64.gz $ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gz

Étape III:

Pour rendre java disponible à tous les utilisateurs, vous devez le déplacer vers l'emplacement «/ usr / local /». Ouvrez root et saisissez les commandes suivantes.

$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exit

Étape IV:

Pour configurer les variables PATH et JAVA_HOME, ajoutez les commandes suivantes au fichier ~ / .bashrc.

export JAVA_HOME=/usr/local/jdk1.7.0_71
export PATH=PATH:$JAVA_HOME/bin

Vérifiez maintenant l'installation en utilisant la commande java -version depuis le terminal comme expliqué ci-dessus.

Étape 2: vérification de l'installation de Hadoop

Hadoop doit être installé sur votre système avant d'installer Hive. Vérifions l'installation de Hadoop à l'aide de la commande suivante:

$ hadoop version

Si Hadoop est déjà installé sur votre système, vous obtiendrez la réponse suivante:

Hadoop 2.4.1 Subversion https://svn.apache.org/repos/asf/hadoop/common -r 1529768 
Compiled by hortonmu on 2013-10-07T06:28Z 
Compiled with protoc 2.5.0 
From source with checksum 79e53ce7994d1628b240f09af91e1af4

Si Hadoop n'est pas installé sur votre système, procédez comme suit:

Téléchargement de Hadoop

Téléchargez et extrayez Hadoop 2.4.1 depuis Apache Software Foundation à l'aide des commandes suivantes.

$ su
password:
# cd /usr/local
# wget http://apache.claz.org/hadoop/common/hadoop-2.4.1/
hadoop-2.4.1.tar.gz
# tar xzf hadoop-2.4.1.tar.gz
# mv hadoop-2.4.1/* to hadoop/
# exit

Installation de Hadoop en mode pseudo distribué

Les étapes suivantes permettent d'installer Hadoop 2.4.1 en mode pseudo distribué.

Étape I: Configurer Hadoop

Vous pouvez définir des variables d'environnement Hadoop en ajoutant les commandes suivantes à ~/.bashrc fichier.

export HADOOP_HOME=/usr/local/hadoop 
export HADOOP_MAPRED_HOME=$HADOOP_HOME 
export HADOOP_COMMON_HOME=$HADOOP_HOME export HADOOP_HDFS_HOME=$HADOOP_HOME 
export YARN_HOME=$HADOOP_HOME export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native export
PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin

Appliquez maintenant toutes les modifications dans le système en cours d'exécution.

$ source ~/.bashrc

Étape II: Configuration Hadoop

Vous pouvez trouver tous les fichiers de configuration Hadoop à l'emplacement «$ HADOOP_HOME / etc / hadoop». Vous devez apporter les modifications appropriées à ces fichiers de configuration en fonction de votre infrastructure Hadoop.

$ cd $HADOOP_HOME/etc/hadoop

Afin de développer des programmes Hadoop en utilisant java, vous devez réinitialiser les variables d'environnement java dans hadoop-env.sh fichier en remplaçant JAVA_HOME value avec l'emplacement de java dans votre système.

export JAVA_HOME=/usr/local/jdk1.7.0_71

Vous trouverez ci-dessous la liste des fichiers que vous devez modifier pour configurer Hadoop.

core-site.xml

le core-site.xml Le fichier contient des informations telles que le numéro de port utilisé pour l'instance Hadoop, la mémoire allouée pour le système de fichiers, la limite de mémoire pour stocker les données et la taille des tampons de lecture / écriture.

Ouvrez le fichier core-site.xml et ajoutez les propriétés suivantes entre les balises <configuration> et </configuration>.

<configuration>

   <property> 
      <name>fs.default.name</name> 
      <value>hdfs://localhost:9000</value> 
   </property>
   
</configuration>

hdfs-site.xml

le hdfs-site.xmlLe fichier contient des informations telles que la valeur des données de réplication, le chemin du namenode et le chemin du datanode de vos systèmes de fichiers locaux. Cela signifie l'endroit où vous souhaitez stocker l'infra Hadoop.

Supposons les données suivantes.

dfs.replication (data replication value) = 1

(In the following path /hadoop/ is the user name.
hadoopinfra/hdfs/namenode is the directory created by hdfs file system.)

namenode path = //home/hadoop/hadoopinfra/hdfs/namenode

(hadoopinfra/hdfs/datanode is the directory created by hdfs file system.)
datanode path = //home/hadoop/hadoopinfra/hdfs/datanode

Ouvrez ce fichier et ajoutez les propriétés suivantes entre les balises <configuration>, </configuration> de ce fichier.

<configuration>

   <property> 
      <name>dfs.replication</name> 
      <value>1</value> 
   </property> 
   <property> 
      <name>dfs.name.dir</name> 
      <value>file:///home/hadoop/hadoopinfra/hdfs/namenode </value> 
   </property> 
   <property> 
      <name>dfs.data.dir</name>
      <value>file:///home/hadoop/hadoopinfra/hdfs/datanode </value > 
   </property>
   
</configuration>

Note: Dans le fichier ci-dessus, toutes les valeurs de propriété sont définies par l'utilisateur et vous pouvez apporter des modifications en fonction de votre infrastructure Hadoop.

yarn-site.xml

Ce fichier est utilisé pour configurer le fil dans Hadoop. Ouvrez le fichier yarn-site.xml et ajoutez les propriétés suivantes entre les balises <configuration>, </configuration> de ce fichier.

<configuration>

   <property> 
      <name>yarn.nodemanager.aux-services</name> 
      <value>mapreduce_shuffle</value> 
   </property>
   
</configuration>

mapred-site.xml

Ce fichier est utilisé pour spécifier le framework MapReduce que nous utilisons. Par défaut, Hadoop contient un modèle de yarn-site.xml. Tout d'abord, vous devez copier le fichier de mapred-site, xml.template vers le fichier mapred-site.xml à l'aide de la commande suivante.

$ cp mapred-site.xml.template mapred-site.xml

Ouvert mapred-site.xml et ajoutez les propriétés suivantes entre les balises <configuration>, </configuration> de ce fichier.

<configuration>

   <property> 
      <name>mapreduce.framework.name</name> 
      <value>yarn</value> 
   </property>

</configuration>

Vérification de l'installation de Hadoop

Les étapes suivantes permettent de vérifier l'installation de Hadoop.

Étape I: configuration du nœud de nom

Configurez le namenode en utilisant la commande «hdfs namenode -format» comme suit.

$ cd ~ $ hdfs namenode -format

Le résultat attendu est le suivant.

10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG: 
/************************************************************ 
STARTUP_MSG: Starting NameNode 
STARTUP_MSG: host = localhost/192.168.1.11 
STARTUP_MSG: args = [-format] 
STARTUP_MSG: version = 2.4.1 
... 
... 
10/24/14 21:30:56 INFO common.Storage: Storage directory 
/home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted. 
10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to 
retain 1 images with txid >= 0 
10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0
10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG: 
/************************************************************ 
SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11
 ************************************************************/

Étape II: vérification des fichiers DFS Hadoop

La commande suivante est utilisée pour démarrer dfs. L'exécution de cette commande démarrera votre système de fichiers Hadoop.

$ start-dfs.sh

Le résultat attendu est le suivant:

10/24/14 21:37:56 
Starting namenodes on [localhost] 
localhost: starting namenode, logging to /home/hadoop/hadoop-2.4.1/logs/hadoop-hadoop-namenode-localhost.out 
localhost: starting datanode, logging to /home/hadoop/hadoop-2.4.1/logs/hadoop-hadoop-datanode-localhost.out 
Starting secondary namenodes [0.0.0.0]

Étape III: vérification du script de fil

La commande suivante est utilisée pour démarrer le script de fil. L'exécution de cette commande démarrera vos démons yarn.

$ start-yarn.sh

Le résultat attendu est le suivant:

starting yarn daemons 
starting resourcemanager, logging to /home/hadoop/hadoop-2.4.1/logs/yarn-hadoop-resourcemanager-localhost.out 
localhost: starting nodemanager, logging to /home/hadoop/hadoop-2.4.1/logs/yarn-hadoop-nodemanager-localhost.out

Étape IV: Accéder à Hadoop sur le navigateur

Le numéro de port par défaut pour accéder à Hadoop est 50070. Utilisez l'url suivante pour obtenir les services Hadoop sur votre navigateur.

http://localhost:50070/

Étape V: vérifier toutes les applications pour le cluster

Le numéro de port par défaut pour accéder à toutes les applications du cluster est 8088. Utilisez l'url suivante pour visiter ce service.

http://localhost:8088/

Étape 3: Téléchargement de Hive

Nous utilisons hive-0.14.0 dans ce tutoriel. Vous pouvez le télécharger en visitant le lien suivanthttp://apache.petsads.us/hive/hive-0.14.0/.Supposons qu'il soit téléchargé dans le répertoire / Downloads. Ici, nous téléchargeons l'archive Hive nommée «apache-hive-0.14.0-bin.tar.gz» pour ce tutoriel. La commande suivante est utilisée pour vérifier le téléchargement:

$ cd Downloads $ ls

Lors du téléchargement réussi, vous obtenez la réponse suivante:

apache-hive-0.14.0-bin.tar.gz

Étape 4: Installation de Hive

Les étapes suivantes sont nécessaires pour installer Hive sur votre système. Supposons que l'archive Hive soit téléchargée dans le répertoire / Downloads.

Extraction et vérification de l'archive Hive

La commande suivante est utilisée pour vérifier le téléchargement et extraire l'archive de la ruche:

$ tar zxvf apache-hive-0.14.0-bin.tar.gz $ ls

Lors du téléchargement réussi, vous obtenez la réponse suivante:

apache-hive-0.14.0-bin apache-hive-0.14.0-bin.tar.gz

Copie de fichiers dans le répertoire / usr / local / hive

Nous devons copier les fichiers du super utilisateur «su -». Les commandes suivantes sont utilisées pour copier les fichiers du répertoire extrait vers le répertoire / usr / local / hive ”.

$ su -
passwd:

# cd /home/user/Download
# mv apache-hive-0.14.0-bin /usr/local/hive
# exit

Configuration de l'environnement pour Hive

Vous pouvez configurer l'environnement Hive en ajoutant les lignes suivantes à ~/.bashrc fichier:

export HIVE_HOME=/usr/local/hive
export PATH=$PATH:$HIVE_HOME/bin export CLASSPATH=$CLASSPATH:/usr/local/Hadoop/lib/*:.
export CLASSPATH=$CLASSPATH:/usr/local/hive/lib/*:.

La commande suivante est utilisée pour exécuter le fichier ~ / .bashrc.

$ source ~/.bashrc

Étape 5: Configuration de Hive

Pour configurer Hive avec Hadoop, vous devez modifier le hive-env.sh fichier, qui est placé dans le $HIVE_HOME/confannuaire. Les commandes suivantes redirigent vers Hiveconfig dossier et copiez le fichier modèle:

$ cd $HIVE_HOME/conf $ cp hive-env.sh.template hive-env.sh

Modifier le hive-env.sh fichier en ajoutant la ligne suivante:

export HADOOP_HOME=/usr/local/hadoop

L'installation de Hive est terminée avec succès. Vous avez maintenant besoin d'un serveur de base de données externe pour configurer Metastore. Nous utilisons la base de données Apache Derby.

Étape 6: Téléchargement et installation d'Apache Derby

Suivez les étapes ci-dessous pour télécharger et installer Apache Derby:

Téléchargement d'Apache Derby

La commande suivante est utilisée pour télécharger Apache Derby. Le téléchargement prend un certain temps.

$ cd ~ $ wget http://archive.apache.org/dist/db/derby/db-derby-10.4.2.0/db-derby-10.4.2.0-bin.tar.gz

La commande suivante est utilisée pour vérifier le téléchargement:

$ ls

Lors du téléchargement réussi, vous obtenez la réponse suivante:

db-derby-10.4.2.0-bin.tar.gz

Extraction et vérification de l'archive Derby

Les commandes suivantes sont utilisées pour extraire et vérifier l'archive Derby:

$ tar zxvf db-derby-10.4.2.0-bin.tar.gz
$ ls

Lors du téléchargement réussi, vous obtenez la réponse suivante:

db-derby-10.4.2.0-bin db-derby-10.4.2.0-bin.tar.gz

Copie de fichiers dans le répertoire / usr / local / derby

Nous devons copier depuis le super utilisateur «su -». Les commandes suivantes sont utilisées pour copier les fichiers du répertoire extrait vers le répertoire / usr / local / derby:

$ su -
passwd:
# cd /home/user
# mv db-derby-10.4.2.0-bin /usr/local/derby
# exit

Configuration de l'environnement pour Derby

Vous pouvez configurer l'environnement Derby en ajoutant les lignes suivantes à ~/.bashrc fichier:

export DERBY_HOME=/usr/local/derby
export PATH=$PATH:$DERBY_HOME/bin
Apache Hive
18
export CLASSPATH=$CLASSPATH:$DERBY_HOME/lib/derby.jar:$DERBY_HOME/lib/derbytools.jar

La commande suivante est utilisée pour exécuter ~/.bashrc fichier:

$ source ~/.bashrc

Créer un répertoire pour stocker Metastore

Créez un répertoire nommé data dans le répertoire $ DERBY_HOME pour stocker les données Metastore.

$ mkdir $DERBY_HOME/data

L'installation de Derby et la configuration de l'environnement sont maintenant terminées.

Étape 7: Configuration du métastore de Hive

Configurer Metastore signifie spécifier à Hive où la base de données est stockée. Vous pouvez le faire en éditant le fichier hive-site.xml, qui se trouve dans le répertoire $ HIVE_HOME / conf. Tout d'abord, copiez le fichier modèle à l'aide de la commande suivante:

$ cd $HIVE_HOME/conf
$ cp hive-default.xml.template hive-site.xml

Éditer hive-site.xml et ajoutez les lignes suivantes entre les balises <configuration> et </configuration>:

<property>
   <name>javax.jdo.option.ConnectionURL</name>
   <value>jdbc:derby://localhost:1527/metastore_db;create=true </value>
   <description>JDBC connect string for a JDBC metastore </description>
</property>

Créez un fichier nommé jpox.properties et ajoutez-y les lignes suivantes:

javax.jdo.PersistenceManagerFactoryClass =

org.jpox.PersistenceManagerFactoryImpl
org.jpox.autoCreateSchema = false
org.jpox.validateTables = false
org.jpox.validateColumns = false
org.jpox.validateConstraints = false
org.jpox.storeManagerType = rdbms
org.jpox.autoCreateSchema = true
org.jpox.autoStartMechanismMode = checked
org.jpox.transactionIsolation = read_committed
javax.jdo.option.DetachAllOnCommit = true
javax.jdo.option.NontransactionalRead = true
javax.jdo.option.ConnectionDriverName = org.apache.derby.jdbc.ClientDriver
javax.jdo.option.ConnectionURL = jdbc:derby://hadoop1:1527/metastore_db;create = true
javax.jdo.option.ConnectionUserName = APP
javax.jdo.option.ConnectionPassword = mine

Étape 8: vérification de l'installation de Hive

Avant d'exécuter Hive, vous devez créer le /tmpdossier et un dossier Hive distinct dans HDFS. Ici, nous utilisons le/user/hive/warehousedossier. Vous devez définir l'autorisation d'écriture pour ces dossiers nouvellement créés comme indiqué ci-dessous:

chmod g+w

Maintenant, définissez-les dans HDFS avant de vérifier Hive. Utilisez les commandes suivantes:

$ $HADOOP_HOME/bin/hadoop fs -mkdir /tmp $ $HADOOP_HOME/bin/hadoop fs -mkdir /user/hive/warehouse $ $HADOOP_HOME/bin/hadoop fs -chmod g+w /tmp $ $HADOOP_HOME/bin/hadoop fs -chmod g+w /user/hive/warehouse

Les commandes suivantes sont utilisées pour vérifier l'installation de Hive:

$ cd $HIVE_HOME $ bin/hive

Une fois l'installation réussie de Hive, vous obtenez la réponse suivante:

Logging initialized using configuration in jar:file:/home/hadoop/hive-0.9.0/lib/hive-common-0.9.0.jar!/hive-log4j.properties 
Hive history file=/tmp/hadoop/hive_job_log_hadoop_201312121621_1494929084.txt
………………….
hive>

L'exemple de commande suivant est exécuté pour afficher toutes les tables:

hive> show tables; 
OK 
Time taken: 2.798 seconds 
hive>

Ce chapitre vous présente les différents types de données dans Hive, qui sont impliqués dans la création de la table. Tous les types de données dans Hive sont classés en quatre types, comme suit:

Types de colonnes
Literals
Valeurs nulles
Types complexes

Types de colonnes

Le type de colonne est utilisé comme type de données de colonne de Hive. Ils sont les suivants:

Types intégraux

Les données de type entier peuvent être spécifiées à l'aide de types de données intégraux, INT. Lorsque la plage de données dépasse la plage de INT, vous devez utiliser BIGINT et si la plage de données est inférieure à INT, vous utilisez SMALLINT. TINYINT est plus petit que SMALLINT.

Le tableau suivant décrit différents types de données INT:

Type	Postfix	Exemple
TINYINT	Oui	10 ans
PETITE MENTHE	S	10S
INT	-	dix
GRAND	L	10 L

Types de chaînes

Les types de données de type chaîne peuvent être spécifiés à l'aide de guillemets simples ('') ou doubles (""). Il contient deux types de données: VARCHAR et CHAR. Hive suit les caractères d'échappement de type C.

Le tableau suivant décrit différents types de données CHAR:

Type de données	Longueur
VARCHAR	1 à 65355
CARBONISER	255

Horodatage

Il prend en charge l'horodatage UNIX traditionnel avec une précision nanoseconde en option. Il prend en charge le format java.sql.Timestamp «AAAA-MM-JJ HH: MM: SS.fffffffff» et le format «aaaa-mm-jj hh: mm: ss.ffffffffff».

Rendez-vous

Les valeurs DATE sont décrites au format année / mois / jour sous la forme {{AAAA-MM-JJ}}.

Décimales

Le type DECIMAL dans Hive est identique au format Big Decimal de Java. Il est utilisé pour représenter une précision arbitraire immuable. La syntaxe et l'exemple sont les suivants:

DECIMAL(precision, scale)
decimal(10,0)

Types d'union

Union est un ensemble de types de données hétérogènes. Vous pouvez créer une instance en utilisantcreate union. La syntaxe et l'exemple sont les suivants:

UNIONTYPE<int, double, array<string>, struct<a:int,b:string>>

{0:1} 
{1:2.0} 
{2:["three","four"]} 
{3:{"a":5,"b":"five"}} 
{2:["six","seven"]} 
{3:{"a":8,"b":"eight"}} 
{0:9} 
{1:10.0}

Littéraux

Les littéraux suivants sont utilisés dans Hive:

Types de virgule flottante

Les types à virgule flottante ne sont rien d'autre que des nombres avec des points décimaux. Généralement, ce type de données est composé de type de données DOUBLE.

Type décimal

^-308 ³⁰⁸

Valeur nulle

Les valeurs manquantes sont représentées par la valeur spéciale NULL.

Types complexes

Les types de données complexes Hive sont les suivants:

Tableaux

Les tableaux dans Hive sont utilisés de la même manière qu'ils sont utilisés dans Java.

Syntaxe: ARRAY <data_type>

Plans

Les cartes dans Hive sont similaires aux cartes Java.

Syntaxe: MAP <primitive_type, data_type>

Structs

Structs dans Hive est similaire à l'utilisation de données complexes avec des commentaires.

Syntaxe: STRUCT <nom_col: type_données [commentaire_col_ COMMENTAIRE], ...>

Hive est une technologie de base de données qui peut définir des bases de données et des tables pour analyser des données structurées. Le thème de l'analyse des données structurées est de stocker les données sous forme de tableau et de passer des requêtes pour les analyser. Ce chapitre explique comment créer une base de données Hive. Hive contient une base de données par défaut nomméedefault.

Créer une déclaration de base de données

Create Database est une instruction utilisée pour créer une base de données dans Hive. Une base de données dans Hive est unnamespaceou une collection de tableaux. lesyntax pour cette déclaration est la suivante:

CREATE DATABASE|SCHEMA [IF NOT EXISTS] <database name>

Ici, IF NOT EXISTS est une clause facultative, qui notifie à l'utilisateur qu'une base de données portant le même nom existe déjà. Nous pouvons utiliser SCHEMA à la place de DATABASE dans cette commande. La requête suivante est exécutée pour créer une base de données nomméeuserdb:

hive> CREATE DATABASE [IF NOT EXISTS] userdb;

hive> CREATE SCHEMA userdb;

La requête suivante est utilisée pour vérifier une liste de bases de données:

hive> SHOW DATABASES;
default
userdb

Programme JDBC

Le programme JDBC pour créer une base de données est donné ci-dessous.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet; 4. CREATE DATABASE
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveCreateDb {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/default", "", "");
      Statement stmt = con.createStatement();
      stmt.executeQuery("CREATE DATABASE userdb");
      System.out.println(“Database userdb created successfully.”);
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveCreateDb.java. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

$ javac HiveCreateDb.java $ java HiveCreateDb

Production:

Database userdb created successfully.

Ce chapitre décrit comment supprimer une base de données dans Hive. L'utilisation de SCHEMA et DATABASE est la même.

Drop Database Statement

Drop Database est une instruction qui supprime toutes les tables et supprime la base de données. Sa syntaxe est la suivante:

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

Les requêtes suivantes sont utilisées pour supprimer une base de données. Supposons que le nom de la base de données soituserdb.

hive> DROP DATABASE IF EXISTS userdb;

La requête suivante supprime la base de données en utilisant CASCADE. Cela signifie supprimer les tables respectives avant de supprimer la base de données.

hive> DROP DATABASE IF EXISTS userdb CASCADE;

La requête suivante supprime la base de données en utilisant SCHEMA.

hive> DROP SCHEMA userdb;

Cette clause a été ajoutée dans Hive 0.6.

Programme JDBC

Le programme JDBC pour supprimer une base de données est indiqué ci-dessous.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager; 5. DROP DATABASE

public class HiveDropDb {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/default", "", "");
      Statement stmt = con.createStatement();
      stmt.executeQuery("DROP DATABASE userdb");
      System.out.println(“Drop userdb database successful.”);
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveDropDb.java. Ci-dessous sont les commandes pour compiler et exécuter ce programme.

$ javac HiveDropDb.java $ java HiveDropDb

Production:

Drop userdb database successful.

Ce chapitre explique comment créer un tableau et comment y insérer des données. Les conventions de création d'une table dans HIVE sont assez similaires à la création d'une table à l'aide de SQL.

Créer une instruction de table

Create Table est une instruction utilisée pour créer une table dans Hive. La syntaxe et l'exemple sont les suivants:

Syntaxe

CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.] table_name

[(col_name data_type [COMMENT col_comment], ...)]
[COMMENT table_comment]
[ROW FORMAT row_format]
[STORED AS file_format]

Exemple

Supposons que vous ayez besoin de créer une table nommée employee en utilisant CREATE TABLEdéclaration. Le tableau suivant répertorie les champs et leurs types de données dans la table des employés:

Sr.Non	Nom de domaine	Type de données
1	Eid	int
2	Nom	Chaîne
3	Un salaire	Flotte
4	La désignation	chaîne

Les données suivantes sont un commentaire, des champs au format de ligne tels que le terminateur de champ, le terminateur de lignes et le type de fichier stocké.

COMMENT ‘Employee details’
FIELDS TERMINATED BY ‘\t’
LINES TERMINATED BY ‘\n’
STORED IN TEXT FILE

La requête suivante crée une table nommée employee en utilisant les données ci-dessus.

hive> CREATE TABLE IF NOT EXISTS employee ( eid int, name String,
> salary String, destination String)
> COMMENT ‘Employee details’
> ROW FORMAT DELIMITED
> FIELDS TERMINATED BY ‘\t’
> LINES TERMINATED BY ‘\n’
> STORED AS TEXTFILE;

Si vous ajoutez l'option IF NOT EXISTS, Hive ignore l'instruction au cas où la table existe déjà.

Lors de la création réussie de la table, vous obtenez la réponse suivante:

OK
Time taken: 5.905 seconds
hive>

Programme JDBC

Le programme JDBC pour créer une table est donné par exemple.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveCreateTable {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("CREATE TABLE IF NOT EXISTS "
      +" employee ( eid int, name String, "
      +" salary String, destignation String)"
      +" COMMENT ‘Employee details’"
      +" ROW FORMAT DELIMITED"
      +" FIELDS TERMINATED BY ‘\t’"
      +" LINES TERMINATED BY ‘\n’"
      +" STORED AS TEXTFILE;");
      System.out.println(“ Table employee created.”);
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveCreateDb.java. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

$ javac HiveCreateDb.java $ java HiveCreateDb

Production

Table employee created.

Charger la déclaration de données

Généralement, après avoir créé une table en SQL, nous pouvons insérer des données à l'aide de l'instruction Insert. Mais dans Hive, nous pouvons insérer des données à l'aide de l'instruction LOAD DATA.

Lors de l'insertion de données dans Hive, il est préférable d'utiliser LOAD DATA pour stocker des enregistrements en bloc. Il existe deux manières de charger des données: l'une provient du système de fichiers local et la seconde du système de fichiers Hadoop.

Syntex

La syntaxe des données de chargement est la suivante:

LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename 
[PARTITION (partcol1=val1, partcol2=val2 ...)]

LOCAL est l'identifiant pour spécifier le chemin local. C'est facultatif.
OVERWRITE est facultatif pour écraser les données de la table.
LA PARTITION est facultative.

Exemple

Nous insérerons les données suivantes dans le tableau. C'est un fichier texte nommésample.txt dans /home/user annuaire.

1201  Gopal       45000    Technical manager
1202  Manisha     45000    Proof reader
1203  Masthanvali 40000    Technical writer
1204  Krian       40000    Hr Admin
1205  Kranthi     30000    Op Admin

La requête suivante charge le texte donné dans la table.

hive> LOAD DATA LOCAL INPATH '/home/user/sample.txt'
> OVERWRITE INTO TABLE employee;

Lors du téléchargement réussi, vous obtenez la réponse suivante:

OK
Time taken: 15.905 seconds
hive>

Programme JDBC

Ci-dessous, le programme JDBC pour charger des données données dans la table.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveLoadData {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("LOAD DATA LOCAL INPATH '/home/user/sample.txt'"
      +"OVERWRITE INTO TABLE employee;");
      System.out.println("Load Data into employee successful");
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveLoadData.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveLoadData.java $ java HiveLoadData

Production:

Load Data into employee successful

Ce chapitre explique comment modifier les attributs d'une table, comme changer son nom de table, changer les noms de colonne, ajouter des colonnes et supprimer ou remplacer des colonnes.

Instruction Alter Table

Il est utilisé pour modifier une table dans Hive.

Syntaxe

L'instruction prend l'une des syntaxes suivantes en fonction des attributs que nous souhaitons modifier dans une table.

ALTER TABLE name RENAME TO new_name
ALTER TABLE name ADD COLUMNS (col_spec[, col_spec ...])
ALTER TABLE name DROP [COLUMN] column_name
ALTER TABLE name CHANGE column_name new_name new_type
ALTER TABLE name REPLACE COLUMNS (col_spec[, col_spec ...])

Renommer en… Instruction

La requête suivante renomme la table de employee à emp.

hive> ALTER TABLE employee RENAME TO emp;

Programme JDBC

Le programme JDBC pour renommer une table est le suivant.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet; 
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveAlterRenameTo {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("ALTER TABLE employee RENAME TO emp;");
      System.out.println("Table Renamed Successfully");
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveAlterRenameTo.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveAlterRenameTo.java $ java HiveAlterRenameTo

Production:

Table renamed successfully.

Déclaration de changement

Le tableau suivant contient les champs de employee table et il montre les champs à modifier (en gras).

Nom de domaine	Convertir à partir du type de données	Changer le nom du champ	Convertir en type de données
eid	int	eid	int
name	Chaîne	ename	Chaîne
un salaire	Float	un salaire	Double
la désignation	Chaîne	la désignation	Chaîne

Les requêtes suivantes renomment le nom de la colonne et le type de données de la colonne à l'aide des données ci-dessus:

hive> ALTER TABLE employee CHANGE name ename String;
hive> ALTER TABLE employee CHANGE salary salary Double;

Programme JDBC

Ci-dessous, le programme JDBC pour modifier une colonne.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveAlterChangeColumn {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("ALTER TABLE employee CHANGE name ename String;");
      stmt.executeQuery("ALTER TABLE employee CHANGE salary salary Double;");
      System.out.println("Change column successful.");
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveAlterChangeColumn.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveAlterChangeColumn.java $ java HiveAlterChangeColumn

Production:

Change column successful.

Instruction Add Columns

La requête suivante ajoute une colonne nommée dept à la table des employés.

hive> ALTER TABLE employee ADD COLUMNS ( 
   > dept STRING COMMENT 'Department name');

Programme JDBC

Le programme JDBC pour ajouter une colonne à une table est donné ci-dessous.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveAlterAddColumn {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
     // create statement
     Statement stmt = con.createStatement();
     // execute statement
     stmt.executeQuery("ALTER TABLE employee ADD COLUMNS "
     +" (dept STRING COMMENT 'Department name');");
     System.out.prinln("Add column successful.");
     con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveAlterAddColumn.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveAlterAddColumn.java $ java HiveAlterAddColumn

Production:

Add column successful.

Remplacer l'instruction

La requête suivante supprime toutes les colonnes du employee table et la remplace par emp et name Colonnes:

hive> ALTER TABLE employee REPLACE COLUMNS ( 
   > eid INT empid Int, 
   > ename STRING name String);

Programme JDBC

Ci-dessous, le programme JDBC à remplacer eid colonne avec empid et ename colonne avec name.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveAlterReplaceColumn {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("ALTER TABLE employee REPLACE COLUMNS "
      +" (eid INT empid Int,"
      +" ename STRING name String);");
      System.out.println(" Replace column successful");
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveAlterReplaceColumn.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveAlterReplaceColumn.java $ java HiveAlterReplaceColumn

Production:

Replace column successful.

Ce chapitre décrit comment supprimer une table dans Hive. Lorsque vous supprimez une table de Hive Metastore, cela supprime les données de table / colonne et leurs métadonnées. Il peut s'agir d'une table normale (stockée dans Metastore) ou d'une table externe (stockée dans le système de fichiers local); Hive traite les deux de la même manière, quels que soient leurs types.

Instruction Drop Table

La syntaxe est la suivante:

DROP TABLE [IF EXISTS] table_name;

La requête suivante supprime une table nommée employee:

hive> DROP TABLE IF EXISTS employee;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

OK
Time taken: 5.3 seconds
hive>

Programme JDBC

Le programme JDBC suivant supprime la table des employés.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveDropTable {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      stmt.executeQuery("DROP TABLE IF EXISTS employee;");
     System.out.println("Drop table successful.");
     con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveDropTable.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveDropTable.java $ java HiveDropTable

Production:

Drop table successful

La requête suivante permet de vérifier la liste des tables:

hive> SHOW TABLES;
emp
ok
Time taken: 2.1 seconds
hive>

Hive organise les tables en partitions. C'est un moyen de diviser une table en parties liées en fonction des valeurs de colonnes partitionnées telles que la date, la ville et le département. En utilisant la partition, il est facile d'interroger une partie des données.

Les tables ou partitions sont subdivisées en buckets,pour fournir une structure supplémentaire aux données qui peuvent être utilisées pour une interrogation plus efficace. Le compartimentage fonctionne en fonction de la valeur de la fonction de hachage d'une colonne d'une table.

Par exemple, une table nommée Tab1contient des données sur les employés telles que l'identifiant, le nom, le service et le yoj (c'est-à-dire l'année de l'adhésion). Supposons que vous ayez besoin de récupérer les détails de tous les employés qui se sont joints en 2012. Une requête recherche dans toute la table les informations requises. Cependant, si vous partitionnez les données des employés avec l'année et les stockez dans un fichier séparé, cela réduit le temps de traitement des requêtes. L'exemple suivant montre comment partitionner un fichier et ses données:

Le fichier suivant contient le tableau des données sur l'emploi.

/ tab1 / employeedata / file1

identifiant, nom, département, yoj

1, gopal, TP, 2012

2, kiran, RH, 2012

3, kaleel, SC, 2013

4, Prasanth, SC, 2013

Les données ci-dessus sont partitionnées en deux fichiers en utilisant l'année.

/ tab1 / employeedata / 2012 / file2

1, gopal, TP, 2012

2, kiran, RH, 2012

/ tab1 / employeedata / 2013 / file3

3, kaleel, SC, 2013

4, Prasanth, SC, 2013

Ajouter une partition

Nous pouvons ajouter des partitions à une table en modifiant la table. Supposons que nous ayons une table appeléeemployee avec des champs tels que Id, Nom, Salaire, Désignation, Département et yoj.

Syntaxe:

ALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION partition_spec
[LOCATION 'location1'] partition_spec [LOCATION 'location2'] ...;

partition_spec:
: (p_column = p_col_value, p_column = p_col_value, ...)

La requête suivante est utilisée pour ajouter une partition à la table des employés.

hive> ALTER TABLE employee
> ADD PARTITION (year=’2012’)
> location '/2012/part2012';

Renommer une partition

La syntaxe de cette commande est la suivante.

ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;

La requête suivante est utilisée pour renommer une partition:

hive> ALTER TABLE employee PARTITION (year=’1203’)
   > RENAME TO PARTITION (Yoj=’1203’);

Supprimer une partition

La syntaxe suivante est utilisée pour supprimer une partition:

ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec, PARTITION partition_spec,...;

La requête suivante est utilisée pour supprimer une partition:

hive> ALTER TABLE employee DROP [IF EXISTS]
   > PARTITION (year=’1203’);

Ce chapitre explique les opérateurs intégrés de Hive. Il existe quatre types d'opérateurs dans Hive:

Opérateurs relationnels
Opérateurs arithmétiques
Opérateurs logiques
Opérateurs complexes

Opérateurs relationnels

Ces opérateurs permettent de comparer deux opérandes. Le tableau suivant décrit les opérateurs relationnels disponibles dans Hive:

Opérateur	Opérande	La description
A = B	tous les types primitifs	TRUE si l'expression A est équivalente à l'expression B sinon FALSE.
A! = B	tous les types primitifs	TRUE si l'expression A n'est pas équivalente à l'expression B sinon FALSE.
A <B	tous les types primitifs	TRUE si l'expression A est inférieure à l'expression B sinon FALSE.
A <= B	tous les types primitifs	TRUE si l'expression A est inférieure ou égale à l'expression B sinon FALSE.
A> B	tous les types primitifs	TRUE si l'expression A est supérieure à l'expression B sinon FALSE.
A> = B	tous les types primitifs	TRUE si l'expression A est supérieure ou égale à l'expression B sinon FALSE.
A EST NULL	tous les types	TRUE si l'expression A est évaluée à NULL sinon FALSE.
A N'EST PAS NULL	tous les types	FALSE si l'expression A est évaluée à NULL sinon TRUE.
A COMME B	Cordes	TRUE si le modèle de chaîne A correspond à B sinon FALSE.
A RLIKE B	Cordes	NULL si A ou B est NULL, TRUE si une sous-chaîne de A correspond à l'expression régulière Java B, sinon FALSE.
UN REGEXP B	Cordes	Identique à RLIKE.

Exemple

Supposons que le employeeLa table est composée de champs nommés Id, Nom, Salaire, Désignation et Département comme indiqué ci-dessous. Générez une requête pour récupérer les détails de l'employé dont l'ID est 1205.

+-----+--------------+--------+---------------------------+------+
| Id  | Name         | Salary | Designation               | Dept |
+-----+--------------+------------------------------------+------+
|1201 | Gopal        | 45000  | Technical manager         | TP   |
|1202 | Manisha      | 45000  | Proofreader               | PR   |
|1203 | Masthanvali  | 40000  | Technical writer          | TP   |
|1204 | Krian        | 40000  | Hr Admin                  | HR   |
|1205 | Kranthi      | 30000  | Op Admin                  | Admin|
+-----+--------------+--------+---------------------------+------+

La requête suivante est exécutée pour récupérer les détails de l'employé à l'aide du tableau ci-dessus:

hive> SELECT * FROM employee WHERE Id=1205;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+-----+-----------+-----------+----------------------------------+
| ID  | Name      | Salary    | Designation              | Dept  |
+-----+---------------+-------+----------------------------------+
|1205 | Kranthi   | 30000     | Op Admin                 | Admin |
+-----+-----------+-----------+----------------------------------+

La requête suivante est exécutée pour récupérer les détails de l'employé dont le salaire est supérieur ou égal à Rs 40000.

hive> SELECT * FROM employee WHERE Salary>=40000;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+-----+------------+--------+----------------------------+------+
| ID  | Name       | Salary | Designation                | Dept |
+-----+------------+--------+----------------------------+------+
|1201 | Gopal      | 45000  | Technical manager          | TP   |
|1202 | Manisha    | 45000  | Proofreader                | PR   |
|1203 | Masthanvali| 40000  | Technical writer           | TP   |
|1204 | Krian      | 40000  | Hr Admin                   | HR   |
+-----+------------+--------+----------------------------+------+

Opérateurs arithmétiques

Ces opérateurs prennent en charge diverses opérations arithmétiques courantes sur les opérandes. Tous renvoient des types de nombres. Le tableau suivant décrit les opérateurs arithmétiques disponibles dans Hive:

Les opérateurs	Opérande	La description
A + B	tous les types de nombres	Donne le résultat de l'ajout de A et B.
UN B	tous les types de nombres	Donne le résultat de la soustraction de B de A.
UN B	tous les types de nombres	Donne le résultat de la multiplication de A et B.
UN B	tous les types de nombres	Donne le résultat de la division de B de A.
UN B	tous les types de nombres	Donne le rappel résultant de la division de A par B.
UN B	tous les types de nombres	Donne le résultat du ET au niveau du bit de A et B.
A \| B	tous les types de nombres	Donne le résultat du OU au niveau du bit de A et B.
A ^ B	tous les types de nombres	Donne le résultat du XOR bit à bit de A et B.
~ Un	tous les types de nombres	Donne le résultat de PAS au niveau du bit de A.

Exemple

La requête suivante ajoute deux nombres, 20 et 30.

hive> SELECT 20+30 ADD FROM temp;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+--------+
|   ADD  |
+--------+
|   50   |
+--------+

Opérateurs logiques

Les opérateurs sont des expressions logiques. Tous renvoient VRAI ou FAUX.

Les opérateurs	Opérandes	La description
A ET B	booléen	TRUE si A et B sont tous deux VRAI, sinon FAUX.
UN B	booléen	Identique à A ET B.
A OU B	booléen	TRUE si A ou B ou les deux sont TRUE, sinon FALSE.
A \|\| B	booléen	Identique à A OU B.
PAS UN	booléen	TRUE si A est FALSE, sinon FALSE.
!UNE	booléen	Identique à NOT A.

Exemple

La requête suivante est utilisée pour récupérer les détails des employés dont le département est TP et le salaire est supérieur à Rs 40000.

hive> SELECT * FROM employee WHERE Salary>40000 && Dept=TP;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1201  | Gopal        | 45000       | Technical manager | TP     |
+------+--------------+-------------+-------------------+--------+

Opérateurs complexes

Ces opérateurs fournissent une expression pour accéder aux éléments des types complexes.

Opérateur	Opérande	La description
Un]	A est un tableau et n est un int	Il renvoie le nième élément du tableau A. Le premier élément a l'index 0.
M [clé]	M est une carte <K, V> et la clé est de type K	Il renvoie la valeur correspondant à la clé dans la carte.
Sx	S est une structure	Il renvoie le champ x de S.

Hive Query Language (HiveQL) est un langage de requête permettant à Hive de traiter et d'analyser des données structurées dans un Metastore. Ce chapitre explique comment utiliser l'instruction SELECT avec la clause WHERE.

L'instruction SELECT est utilisée pour récupérer les données d'une table. La clause WHERE fonctionne comme une condition. Il filtre les données en utilisant la condition et vous donne un résultat fini. Les opérateurs et fonctions intégrés génèrent une expression qui remplit la condition.

Syntaxe

Voici la syntaxe de la requête SELECT:

SELECT [ALL | DISTINCT] select_expr, select_expr, ... 
FROM table_reference 
[WHERE where_condition] 
[GROUP BY col_list] 
[HAVING having_condition] 
[CLUSTER BY col_list | [DISTRIBUTE BY col_list] [SORT BY col_list]] 
[LIMIT number];

Exemple

Prenons un exemple pour la clause SELECT… WHERE. Supposons que nous ayons le tableau des employés comme indiqué ci-dessous, avec des champs nommés Id, Nom, Salaire, Désignation et Département.

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1201  | Gopal        | 45000       | Technical manager | TP     |
|1202  | Manisha      | 45000       | Proofreader       | PR     |
|1203  | Masthanvali  | 40000       | Technical writer  | TP     |
|1204  | Krian        | 40000       | Hr Admin          | HR     |
|1205  | Kranthi      | 30000       | Op Admin          | Admin  | 
+------+--------------+-------------+-------------------+--------+

La requête suivante récupère les détails de l'employé à l'aide du scénario ci-dessus:

hive> SELECT * FROM employee WHERE salary>30000;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1201  | Gopal        | 45000       | Technical manager | TP     |
|1202  | Manisha      | 45000       | Proofreader       | PR     |
|1203  | Masthanvali  | 40000       | Technical writer  | TP     |
|1204  | Krian        | 40000       | Hr Admin          | HR     |
+------+--------------+-------------+-------------------+--------+

Programme JDBC

Le programme JDBC à appliquer la clause where pour l'exemple donné est le suivant.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveQLWhere {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      Resultset res = stmt.executeQuery("SELECT * FROM employee WHERE
      salary>30000;");
      System.out.println("Result:");
      System.out.println(" ID \t Name \t Salary \t Designation \t Dept ");
      while (res.next()) {
         System.out.println(res.getInt(1)+" "+ res.getString(2)+" "+
         res.getDouble(3)+" "+ res.getString(4)+" "+ res.getString(5));
      }
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveQLWhere.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveQLWhere.java $ java HiveQLWhere

Production:

ID       Name           Salary      Designation          Dept
1201     Gopal          45000       Technical manager    TP
1202     Manisha        45000       Proofreader          PR
1203     Masthanvali    40000       Technical writer     TP
1204     Krian          40000       Hr Admin             HR

Ce chapitre explique comment utiliser la clause ORDER BY dans une instruction SELECT. La clause ORDER BY est utilisée pour récupérer les détails en fonction d'une colonne et trier le jeu de résultats par ordre croissant ou décroissant.

Syntaxe

Vous trouverez ci-dessous la syntaxe de la clause ORDER BY:

SELECT [ALL | DISTINCT] select_expr, select_expr, ... 
FROM table_reference 
[WHERE where_condition] 
[GROUP BY col_list] 
[HAVING having_condition] 
[ORDER BY col_list]] 
[LIMIT number];

Exemple

Prenons un exemple pour la clause SELECT ... ORDER BY. Supposons la table des employés comme indiqué ci-dessous, avec les champs nommés Id, Nom, Salaire, Désignation et Service. Générez une requête pour récupérer les détails de l'employé dans l'ordre en utilisant le nom du service.

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1201  | Gopal        | 45000       | Technical manager | TP     |
|1202  | Manisha      | 45000       | Proofreader       | PR     |
|1203  | Masthanvali  | 40000       | Technical writer  | TP     |
|1204  | Krian        | 40000       | Hr Admin          | HR     |
|1205  | Kranthi      | 30000       | Op Admin          | Admin  |
+------+--------------+-------------+-------------------+--------+

La requête suivante récupère les détails de l'employé à l'aide du scénario ci-dessus:

hive> SELECT Id, Name, Dept FROM employee ORDER BY DEPT;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1205  | Kranthi      | 30000       | Op Admin          | Admin  |
|1204  | Krian        | 40000       | Hr Admin          | HR     |
|1202  | Manisha      | 45000       | Proofreader       | PR     |
|1201  | Gopal        | 45000       | Technical manager | TP     |
|1203  | Masthanvali  | 40000       | Technical writer  | TP     |
+------+--------------+-------------+-------------------+--------+

Programme JDBC

Voici le programme JDBC pour appliquer la clause Order By pour l'exemple donné.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveQLOrderBy {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement 
      Statement stmt = con.createStatement();
      // execute statement
      Resultset res = stmt.executeQuery("SELECT * FROM employee ORDER BY
      DEPT;");
      System.out.println(" ID \t Name \t Salary \t Designation \t Dept ");
      while (res.next()) {
         System.out.println(res.getInt(1)+" "+ res.getString(2)+" "+
         res.getDouble(3)+" "+ res.getString(4)+" "+ res.getString(5));
      }
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveQLOrderBy.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveQLOrderBy.java $ java HiveQLOrderBy

Production:

ID       Name           Salary      Designation          Dept
1205     Kranthi        30000       Op Admin             Admin
1204     Krian          40000       Hr Admin             HR
1202     Manisha        45000       Proofreader          PR
1201     Gopal          45000       Technical manager    TP
1203     Masthanvali    40000       Technical writer     TP
1204     Krian          40000       Hr Admin             HR

Ce chapitre explique les détails de la clause GROUP BY dans une instruction SELECT. La clause GROUP BY est utilisée pour regrouper tous les enregistrements dans un jeu de résultats à l'aide d'une colonne de collection particulière. Il est utilisé pour interroger un groupe d'enregistrements.

Syntaxe

La syntaxe de la clause GROUP BY est la suivante:

SELECT [ALL | DISTINCT] select_expr, select_expr, ... 
FROM table_reference 
[WHERE where_condition] 
[GROUP BY col_list] 
[HAVING having_condition] 
[ORDER BY col_list]] 
[LIMIT number];

Exemple

Prenons un exemple de clause SELECT… GROUP BY. Supposons que la table des employés soit indiquée ci-dessous, avec les champs Id, Nom, Salaire, Désignation et Département. Générez une requête pour récupérer le nombre d'employés dans chaque service.

+------+--------------+-------------+-------------------+--------+ 
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+ 
|1201  | Gopal        | 45000       | Technical manager | TP     | 
|1202  | Manisha      | 45000       | Proofreader       | PR     | 
|1203  | Masthanvali  | 40000       | Technical writer  | TP     | 
|1204  | Krian        | 45000       | Proofreader       | PR     | 
|1205  | Kranthi      | 30000       | Op Admin          | Admin  |
+------+--------------+-------------+-------------------+--------+

La requête suivante récupère les détails de l'employé à l'aide du scénario ci-dessus.

hive> SELECT Dept,count(*) FROM employee GROUP BY DEPT;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

+------+--------------+ 
| Dept | Count(*)     | 
+------+--------------+ 
|Admin |    1         | 
|PR    |    2         | 
|TP    |    3         | 
+------+--------------+

Programme JDBC

Vous trouverez ci-dessous le programme JDBC pour appliquer la clause Group By pour l'exemple donné.

import java.sql.SQLException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.DriverManager;

public class HiveQLGroupBy {
   private static String driverName =
   "org.apache.hadoop.hive.jdbc.HiveDriver";
   public static void main(String[] args) throws SQLException {
      // Register driver and create driver instance
      Class.forName(driverName);
      // get connection
      Connection con = DriverManager.
      getConnection("jdbc:hive://localhost:10000/userdb", "", "");
      // create statement
      Statement stmt = con.createStatement();
      // execute statement
      Resultset res = stmt.executeQuery(“SELECT Dept,count(*) ”
      +“FROM employee GROUP BY DEPT; ”);
      System.out.println(" Dept \t count(*)");
      while (res.next()) {
         System.out.println(res.getString(1)+" "+ res.getInt(2)); 
      }
      con.close();
   }
}

Enregistrez le programme dans un fichier nommé HiveQLGroupBy.java. Utilisez les commandes suivantes pour compiler et exécuter ce programme.

$ javac HiveQLGroupBy.java $ java HiveQLGroupBy

Production:

Dept     Count(*)
 Admin       1
 PR          2
 TP          3

JOINS est une clause utilisée pour combiner des champs spécifiques de deux tables en utilisant des valeurs communes à chacune. Il est utilisé pour combiner des enregistrements de deux ou plusieurs tables de la base de données.

Syntaxe

join_table:

   table_reference JOIN table_factor [join_condition]
   | table_reference {LEFT|RIGHT|FULL} [OUTER] JOIN table_reference
   join_condition
   | table_reference LEFT SEMI JOIN table_reference join_condition
   | table_reference CROSS JOIN table_reference [join_condition]

Exemple

Nous utiliserons les deux tableaux suivants dans ce chapitre. Considérez le tableau suivant nommé CLIENTS.

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

Considérez une autre table ORDERS comme suit:

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

Il existe différents types de jointures comme suit:

JOIN
JOINTURE EXTERNE GAUCHE
JOINTURE EXTÉRIEURE DROITE
JOINTURE EXTÉRIEURE COMPLÈTE

JOINDRE

La clause JOIN est utilisée pour combiner et récupérer les enregistrements de plusieurs tables. JOIN est identique à OUTER JOIN en SQL. Une condition JOIN doit être levée à l'aide des clés primaires et des clés étrangères des tables.

La requête suivante exécute JOIN sur les tables CUSTOMER et ORDER et récupère les enregistrements:

hive> SELECT c.ID, c.NAME, c.AGE, o.AMOUNT 
   > FROM CUSTOMERS c JOIN ORDERS o 
   > ON (c.ID = o.CUSTOMER_ID);

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

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

JOINTURE EXTERNE GAUCHE

HiveQL LEFT OUTER JOIN renvoie toutes les lignes de la table de gauche, même s'il n'y a aucune correspondance dans la table de droite. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de droite, la jointure renvoie toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de droite.

Un LEFT JOIN renvoie toutes les valeurs de la table de gauche, plus les valeurs correspondantes de la table de droite, ou NULL en cas d'absence de prédicat JOIN correspondant.

La requête suivante illustre la jointure externe gauche entre les tables CUSTOMER et ORDER:

hive> SELECT c.ID, c.NAME, o.AMOUNT, o.DATE 
   > FROM CUSTOMERS c 
   > LEFT OUTER JOIN ORDERS o 
   > ON (c.ID = o.CUSTOMER_ID);

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

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

JOINTURE EXTÉRIEURE DROITE

HiveQL RIGHT OUTER JOIN renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche. Si la clause ON correspond à 0 (zéro) enregistrements dans la table de gauche, la jointure renvoie toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de gauche.

Un RIGHT JOIN renvoie toutes les valeurs de la table de droite, plus les valeurs correspondantes de la table de gauche, ou NULL en cas d'absence de prédicat de jointure correspondant.

La requête suivante illustre RIGHT OUTER JOIN entre les tables CUSTOMER et ORDER.

hive> SELECT c.ID, c.NAME, o.AMOUNT, o.DATE 
   > FROM CUSTOMERS c 
   > RIGHT OUTER JOIN ORDERS o 
   > ON (c.ID = o.CUSTOMER_ID);

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

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

JOINTURE EXTÉRIEURE COMPLÈTE

HiveQL FULL OUTER JOIN combine les enregistrements des tables externes gauche et droite qui remplissent la condition JOIN. La table jointe contient tous les enregistrements des deux tables ou remplit des valeurs NULL pour les correspondances manquantes de chaque côté.

La requête suivante montre une jointure externe complète entre les tables CUSTOMER et ORDER:

hive> SELECT c.ID, c.NAME, o.AMOUNT, o.DATE 
   > FROM CUSTOMERS c 
   > FULL OUTER JOIN ORDERS o 
   > ON (c.ID = o.CUSTOMER_ID);

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

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

Ce chapitre explique les fonctions intégrées disponibles dans Hive. Les fonctions sont assez similaires aux fonctions SQL, à l'exception de leur utilisation.

Fonctions intégrées

Hive prend en charge les fonctions intégrées suivantes:

Type de retour	Signature	La description
GRAND	rond (double a)	Il renvoie la valeur BIGINT arrondie du double.
GRAND	étage (double a)	Il renvoie la valeur BIGINT maximale égale ou inférieure au double.
GRAND	ceil (double a)	Il renvoie la valeur BIGINT minimale égale ou supérieure au double.
double	rand (), rand (int graine)	Il renvoie un nombre aléatoire qui change de ligne en ligne.
chaîne	concat (chaîne A, chaîne B, ...)	Il renvoie la chaîne résultant de la concaténation de B après A.
chaîne	substr (chaîne A, début int)	Il renvoie la sous-chaîne de A à partir de la position de départ jusqu'à la fin de la chaîne A.
chaîne	substr (chaîne A, début int, longueur int)	Il renvoie la sous-chaîne de A à partir de la position de départ avec la longueur donnée.
chaîne	supérieur (chaîne A)	Il renvoie la chaîne résultant de la conversion de tous les caractères de A en majuscules.
chaîne	ucase (chaîne A)	Comme ci-dessus.
chaîne	inférieur (chaîne A)	Il renvoie la chaîne résultant de la conversion de tous les caractères de B en minuscules.
chaîne	lcase (chaîne A)	Comme ci-dessus.
chaîne	trim (chaîne A)	Il renvoie la chaîne résultant de la réduction des espaces aux deux extrémités de A.
chaîne	ltrim (chaîne A)	Il renvoie la chaîne résultant du découpage des espaces depuis le début (côté gauche) de A.
chaîne	rtrim (chaîne A)	rtrim (string A) Il renvoie la chaîne résultant de la réduction des espaces à partir de la fin (côté droit) de A.
chaîne	regexp_replace (chaîne A, chaîne B, chaîne C)	Il renvoie la chaîne résultant du remplacement de toutes les sous-chaînes de B qui correspondent à la syntaxe d'expression régulière Java par C.
int	taille (carte <KV>)	Il renvoie le nombre d'éléments dans le type de carte.
int	taille (Array <T>)	Il renvoie le nombre d'éléments dans le type de tableau.
valeur de <type>	cast (<expr> comme <type>)	Il convertit les résultats de l'expression expr en <type>, par exemple cast ('1' as BIGINT) convertit la chaîne '1' en une représentation intégrale. Un NULL est renvoyé si la conversion échoue.
chaîne	from_unixtime (int unixtime)	convertir le nombre de secondes de l'époque Unix (1970-01-01 00:00:00 UTC) en une chaîne représentant l'horodatage de ce moment dans le fuseau horaire système actuel au format "1970-01-01 00:00: 00 "
chaîne	to_date (chaîne d'horodatage)	Il renvoie la partie date d'une chaîne d'horodatage: to_date ("1970-01-01 00:00:00") = "1970-01-01"
int	année (date de chaîne)	Il renvoie la partie année d'une date ou d'une chaîne d'horodatage: year ("1970-01-01 00:00:00") = 1970, year ("1970-01-01") = 1970
int	mois (date de chaîne)	Il renvoie la partie mois d'une date ou d'une chaîne d'horodatage: month ("1970-11-01 00:00:00") = 11, month ("1970-11-01") = 11
int	jour (chaîne date)	Il renvoie la partie jour d'une date ou d'une chaîne d'horodatage: day ("1970-11-01 00:00:00") = 1, day ("1970-11-01") = 1
chaîne	get_json_object (chaîne json_string, chemin de chaîne)	Il extrait l'objet json d'une chaîne json en fonction du chemin json spécifié et renvoie la chaîne json de l'objet json extrait. Il renvoie NULL si la chaîne json d'entrée n'est pas valide.

Exemple

Les requêtes suivantes illustrent certaines fonctions intégrées:

fonction round ()

hive> SELECT round(2.6) from temp;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

3.0

fonction floor ()

hive> SELECT floor(2.6) from temp;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

2.0

fonction ceil ()

hive> SELECT ceil(2.6) from temp;

Lors de l'exécution réussie de la requête, vous obtenez la réponse suivante:

3.0

Fonctions d'agrégation

Hive prend en charge les éléments intégrés suivants aggregate functions. L'utilisation de ces fonctions est identique à celle des fonctions d'agrégation SQL.

Type de retour	Signature	La description
GRAND	count (*), count (expr),	count (*) - Renvoie le nombre total de lignes extraites.
DOUBLE	sum (col), sum (DISTINCT col)	Il renvoie la somme des éléments du groupe ou la somme des valeurs distinctes de la colonne du groupe.
DOUBLE	avg (col), avg (DISTINCT col)	Il renvoie la moyenne des éléments du groupe ou la moyenne des valeurs distinctes de la colonne du groupe.
DOUBLE	min (col)	Il renvoie la valeur minimale de la colonne dans le groupe.
DOUBLE	max (col)	Il renvoie la valeur maximale de la colonne dans le groupe.

Ce chapitre décrit comment créer et gérer des vues. Les vues sont générées en fonction des besoins des utilisateurs. Vous pouvez enregistrer toutes les données d'ensemble de résultats sous forme de vue. L'utilisation de la vue dans Hive est la même que celle de la vue dans SQL. C'est un concept de SGBDR standard. Nous pouvons exécuter toutes les opérations DML sur une vue.

Créer une vue

Vous pouvez créer une vue au moment de l'exécution d'une instruction SELECT. La syntaxe est la suivante:

CREATE VIEW [IF NOT EXISTS] view_name [(column_name [COMMENT column_comment], ...) ]
[COMMENT table_comment]
AS SELECT ...

Exemple

Prenons un exemple pour vue. Supposons la table des employés comme donnée ci-dessous, avec les champs Id, Nom, Salaire, Désignation et Département. Générez une requête pour récupérer les détails des employés qui gagnent un salaire de plus de Rs 30000. Nous stockons le résultat dans une vue nomméeemp_30000.

+------+--------------+-------------+-------------------+--------+
| ID   | Name         | Salary      | Designation       | Dept   |
+------+--------------+-------------+-------------------+--------+
|1201  | Gopal        | 45000       | Technical manager | TP     |
|1202  | Manisha      | 45000       | Proofreader       | PR     |
|1203  | Masthanvali  | 40000       | Technical writer  | TP     |
|1204  | Krian        | 40000       | Hr Admin          | HR     |
|1205  | Kranthi      | 30000       | Op Admin          | Admin  |
+------+--------------+-------------+-------------------+--------+

La requête suivante récupère les détails de l'employé à l'aide du scénario ci-dessus:

hive> CREATE VIEW emp_30000 AS
   > SELECT * FROM employee
   > WHERE salary>30000;

Supprimer une vue

Utilisez la syntaxe suivante pour supprimer une vue:

DROP VIEW view_name

La requête suivante supprime une vue nommée emp_30000:

hive> DROP VIEW emp_30000;

Créer un index

Un index n'est rien d'autre qu'un pointeur sur une colonne particulière d'une table. Créer un index signifie créer un pointeur sur une colonne particulière d'une table. Sa syntaxe est la suivante:

CREATE INDEX index_name
ON TABLE base_table_name (col_name, ...)
AS 'index.handler.class.name'
[WITH DEFERRED REBUILD]
[IDXPROPERTIES (property_name=property_value, ...)]
[IN TABLE index_table_name]
[PARTITIONED BY (col_name, ...)]
[
   [ ROW FORMAT ...] STORED AS ...
   | STORED BY ...
]
[LOCATION hdfs_path]
[TBLPROPERTIES (...)]

Exemple

Prenons un exemple pour l'index. Utilisez la même table d'employés que celle que nous avons utilisée précédemment avec les champs Id, Nom, Salaire, Désignation et Service. Créez un index nommé index_salary sur la colonne Salaire de la table Employé.

La requête suivante crée un index:

hive> CREATE INDEX inedx_salary ON TABLE employee(salary)
   > AS 'org.apache.hadoop.hive.ql.index.compact.CompactIndexHandler';

C'est un pointeur vers la colonne des salaires. Si la colonne est modifiée, les modifications sont stockées à l'aide d'une valeur d'index.

Supprimer un index

La syntaxe suivante est utilisée pour supprimer un index:

DROP INDEX <index_name> ON <table_name>

La requête suivante supprime un index nommé index_salary:

hive> DROP INDEX index_salary ON employee;