Hive - Guia rápido

O termo 'Big Data' é usado para coleções de grandes conjuntos de dados que incluem grande volume, alta velocidade e uma variedade de dados que aumentam dia a dia. Usando sistemas tradicionais de gerenciamento de dados, é difícil processar Big Data. Portanto, a Apache Software Foundation introduziu uma estrutura chamada Hadoop para resolver os desafios de gerenciamento e processamento de Big Data.

Hadoop

Hadoop é uma estrutura de código aberto para armazenar e processar Big Data em um ambiente distribuído. Ele contém dois módulos, um é MapReduce e outro é Hadoop Distributed File System (HDFS).

• MapReduce: É um modelo de programação paralela para processar grandes quantidades de dados estruturados, semiestruturados e não estruturados em grandes clusters de hardware comum.

• HDFS:O Hadoop Distributed File System é uma parte da estrutura do Hadoop, usado para armazenar e processar os conjuntos de dados. Ele fornece um sistema de arquivos tolerante a falhas para execução em hardware comum.

O ecossistema Hadoop contém diferentes subprojetos (ferramentas), como Sqoop, Pig e Hive, que são usados ​​para ajudar os módulos do Hadoop.

• Sqoop: É usado para importar e exportar dados de e para o HDFS e RDBMS.

• Pig: É uma plataforma de linguagem procedural usada para desenvolver um script para operações MapReduce.

• Hive: É uma plataforma usada para desenvolver scripts do tipo SQL para fazer operações MapReduce.

Note: Existem várias maneiras de executar operações MapReduce:

• A abordagem tradicional usando o programa Java MapReduce para dados estruturados, semiestruturados e não estruturados.
• A abordagem de script para MapReduce para processar dados estruturados e semiestruturados usando Pig.
• O Hive Query Language (HiveQL ou HQL) para MapReduce para processar dados estruturados usando Hive.

O que é Hive

Hive é uma ferramenta de infraestrutura de data warehouse para processar dados estruturados no Hadoop. Ele reside no Hadoop para resumir Big Data e facilita a consulta e a análise.

Inicialmente, o Hive foi desenvolvido pelo Facebook, mais tarde a Apache Software Foundation o adotou e o desenvolveu ainda mais como um código aberto sob o nome de Apache Hive. É usado por diferentes empresas. Por exemplo, a Amazon o usa no Amazon Elastic MapReduce.

Hive não é

• Um banco de dados relacional
• Um design para processamento de transações OnLine (OLTP)
• Uma linguagem para consultas em tempo real e atualizações em nível de linha

Características do Hive

• Ele armazena o esquema em um banco de dados e os dados processados ​​no HDFS.
• Ele é projetado para OLAP.
• Ele fornece uma linguagem de tipo SQL para consultas chamadas HiveQL ou HQL.
• É familiar, rápido, escalonável e extensível.

Arquitetura de Hive

O diagrama de componentes a seguir descreve a arquitetura do Hive:

Este diagrama de componentes contém unidades diferentes. A tabela a seguir descreve cada unidade:

Nome da Unidade	Operação
Interface de usuário	Hive é um software de infraestrutura de data warehouse que pode criar interação entre o usuário e o HDFS. As interfaces de usuário que o Hive suporta são Hive Web UI, linha de comando Hive e Hive HD Insight (no servidor Windows).
Meta Store	O Hive escolhe os respectivos servidores de banco de dados para armazenar o esquema ou metadados de tabelas, bancos de dados, colunas em uma tabela, seus tipos de dados e mapeamento HDFS.
HiveQL Process Engine	HiveQL é semelhante a SQL para consultar informações de esquema no Metastore. É uma das substituições da abordagem tradicional para o programa MapReduce. Em vez de escrever o programa MapReduce em Java, podemos escrever uma consulta para o trabalho MapReduce e processá-lo.
Execution Engine	A parte conjunta do mecanismo de processo HiveQL e MapReduce é o mecanismo de execução Hive. O mecanismo de execução processa a consulta e gera resultados iguais aos resultados do MapReduce. Ele usa o sabor do MapReduce.
HDFS ou HBASE	O sistema de arquivos distribuídos Hadoop ou HBASE são as técnicas de armazenamento de dados para armazenar dados no sistema de arquivos.

Trabalho da Colmeia

O diagrama a seguir descreve o fluxo de trabalho entre Hive e Hadoop.

A tabela a seguir define como o Hive interage com a estrutura do Hadoop:

Etapa No.	Operação
1	Execute Query A interface do Hive, como Linha de Comando ou IU da Web, envia uma consulta ao Driver (qualquer driver de banco de dados, como JDBC, ODBC, etc.) para execução.
2	Get Plan O driver tem a ajuda de um compilador de consulta que analisa a consulta para verificar a sintaxe e o plano da consulta ou a necessidade da consulta.
3	Get Metadata O compilador envia uma solicitação de metadados ao Metastore (qualquer banco de dados).
4	Send Metadata O Metastore envia metadados como resposta ao compilador.
5	Send Plan O compilador verifica o requisito e reenvia o plano ao driver. Até aqui, a análise e compilação de uma consulta estão completas.
6	Execute Plan O driver envia o plano de execução para o mecanismo de execução.
7	Execute Job Internamente, o processo de execução do trabalho é um trabalho MapReduce. O mecanismo de execução envia o trabalho para JobTracker, que está no nó Nome e atribui esse trabalho ao TaskTracker, que está no nó Dados. Aqui, a consulta executa o trabalho MapReduce.
7,1	Metadata Ops Enquanto isso, na execução, o mecanismo de execução pode executar operações de metadados com Metastore.
8	Fetch Result O mecanismo de execução recebe os resultados dos nós de dados.
9	Send Results O mecanismo de execução envia esses valores resultantes para o driver.
10	Send Results O driver envia os resultados às interfaces do Hive.

Todos os subprojetos do Hadoop, como Hive, Pig e HBase, oferecem suporte ao sistema operacional Linux. Portanto, você precisa instalar qualquer SO com sabor Linux. As seguintes etapas simples são executadas para a instalação do Hive:

Etapa 1: Verificação da instalação JAVA

Java deve ser instalado em seu sistema antes de instalar o Hive. Vamos verificar a instalação do java usando o seguinte comando:

$ java –version

Se o Java já estiver instalado em seu sistema, você verá a seguinte resposta:

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)

Se o java não estiver instalado em seu sistema, siga as etapas abaixo para instalar o java.

Instalando Java

Etapa I:

Baixe o java (JDK <versão mais recente> - X64.tar.gz) visitando o seguinte link http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html.

Em seguida, jdk-7u71-linux-x64.tar.gz será baixado em seu sistema.

Etapa II:

Geralmente, você encontrará o arquivo java baixado na pasta Downloads. Verifique-o e extraia o arquivo jdk-7u71-linux-x64.gz usando os comandos a seguir.

$ 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

Etapa III:

Para disponibilizar o java a todos os usuários, você deve movê-lo para o local “/ usr / local /”. Abra o root e digite os seguintes comandos.

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

Etapa IV:

Para configurar as variáveis ​​PATH e JAVA_HOME, adicione os seguintes comandos ao arquivo ~ / .bashrc.

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

Agora verifique a instalação usando o comando java -version do terminal conforme explicado acima.

Etapa 2: Verificar a instalação do Hadoop

O Hadoop deve ser instalado em seu sistema antes de instalar o Hive. Vamos verificar a instalação do Hadoop usando o seguinte comando:

$ hadoop version

Se o Hadoop já estiver instalado em seu sistema, você receberá a seguinte resposta:

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

Se o Hadoop não estiver instalado em seu sistema, prossiga com as seguintes etapas:

Baixando Hadoop

Baixe e extraia o Hadoop 2.4.1 da Apache Software Foundation usando os comandos a seguir.

$ 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

Instalando o Hadoop no modo pseudo-distribuído

As etapas a seguir são usadas para instalar o Hadoop 2.4.1 no modo pseudo distribuído.

Etapa I: Configurando o Hadoop

Você pode definir variáveis ​​de ambiente Hadoop anexando os seguintes comandos a ~/.bashrc Arquivo.

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

Agora aplique todas as alterações no sistema em execução atual.

$ source ~/.bashrc

Etapa II: Configuração do Hadoop

Você pode encontrar todos os arquivos de configuração do Hadoop no local “$ HADOOP_HOME / etc / hadoop”. Você precisa fazer as alterações adequadas nesses arquivos de configuração de acordo com sua infraestrutura Hadoop.

$ cd $HADOOP_HOME/etc/hadoop

Para desenvolver programas Hadoop usando java, você deve redefinir as variáveis ​​de ambiente java em hadoop-env.sh arquivo substituindo JAVA_HOME valor com a localização de java em seu sistema.

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

A seguir está a lista de arquivos que você deve editar para configurar o Hadoop.

core-site.xml

o core-site.xml arquivo contém informações como o número da porta usado para a instância do Hadoop, memória alocada para o sistema de arquivos, limite de memória para armazenar os dados e o tamanho dos buffers de leitura / gravação.

Abra o core-site.xml e adicione as seguintes propriedades entre as tags <configuration> e </configuration>.

<configuration>

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

hdfs-site.xml

o hdfs-site.xmlO arquivo contém informações como o valor dos dados de replicação, o caminho do namenode e o caminho do datanode dos sistemas de arquivos locais. Significa o local onde você deseja armazenar o infra Hadoop.

Vamos supor os seguintes dados.

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

Abra este arquivo e adicione as seguintes propriedades entre as marcas <configuration>, </configuration> neste arquivo.

<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: No arquivo acima, todos os valores de propriedade são definidos pelo usuário e você pode fazer alterações de acordo com sua infraestrutura Hadoop.

yarn-site.xml

Este arquivo é usado para configurar o yarn no Hadoop. Abra o arquivo yarn-site.xml e adicione as seguintes propriedades entre as marcas <configuration>, </configuration> neste arquivo.

<configuration>

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

mapred-site.xml

Este arquivo é usado para especificar qual estrutura MapReduce estamos usando. Por padrão, o Hadoop contém um modelo de yarn-site.xml. Em primeiro lugar, você precisa copiar o arquivo mapred-site, xml.template para o arquivo mapred-site.xml usando o seguinte comando.

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

Abrir mapred-site.xml arquivo e adicione as seguintes propriedades entre as marcas <configuration>, </configuration> neste arquivo.

<configuration>

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

</configuration>

Verificando a instalação do Hadoop

As etapas a seguir são usadas para verificar a instalação do Hadoop.

Etapa I: Configuração do Nó de Nome

Configure o namenode usando o comando “hdfs namenode -format” como segue.

$ cd ~ $ hdfs namenode -format

O resultado esperado é o seguinte.

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
 ************************************************************/

Etapa II: verificar Hadoop dfs

O seguinte comando é usado para iniciar o dfs. Executar este comando iniciará seu sistema de arquivos Hadoop.

$ start-dfs.sh

A saída esperada é a seguinte:

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]

Etapa III: Verificando o script do Yarn

O seguinte comando é usado para iniciar o script yarn. Executar este comando iniciará seus daemons de yarn.

$ start-yarn.sh

A saída esperada é a seguinte:

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

Etapa IV: Acessando o Hadoop no navegador

O número da porta padrão para acessar o Hadoop é 50070. Use o seguinte url para obter os serviços do Hadoop em seu navegador.

http://localhost:50070/

Etapa V: verificar todos os aplicativos do cluster

O número da porta padrão para acessar todos os aplicativos do cluster é 8088. Use o seguinte url para visitar este serviço.

http://localhost:8088/

Etapa 3: baixando o Hive

Usamos hive-0.14.0 neste tutorial. Você pode baixá-lo visitando o seguinte linkhttp://apache.petsads.us/hive/hive-0.14.0/.Suponhamos que ele seja baixado no diretório / Downloads. Aqui, baixamos o arquivo Hive denominado “apache-hive-0.14.0-bin.tar.gz” para este tutorial. O seguinte comando é usado para verificar o download:

$ cd Downloads $ ls

Após o download bem-sucedido, você verá a seguinte resposta:

apache-hive-0.14.0-bin.tar.gz

Etapa 4: Instalando o Hive

As etapas a seguir são necessárias para instalar o Hive em seu sistema. Vamos supor que o arquivo do Hive seja baixado no diretório / Downloads.

Extraindo e verificando o arquivo Hive

O seguinte comando é usado para verificar o download e extrair o arquivo do hive:

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

Após o download bem-sucedido, você verá a seguinte resposta:

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

Copiando arquivos para o diretório / usr / local / hive

Precisamos copiar os arquivos do superusuário “su -”. Os comandos a seguir são usados ​​para copiar os arquivos do diretório extraído para o diretório / usr / local / hive ”.

$ su -
passwd:

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

Configurando o ambiente para Hive

Você pode configurar o ambiente Hive anexando as seguintes linhas a ~/.bashrc Arquivo:

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/*:.

O seguinte comando é usado para executar o arquivo ~ / .bashrc.

$ source ~/.bashrc

Etapa 5: Configurando o Hive

Para configurar o Hive com Hadoop, você precisa editar o hive-env.sh arquivo, que é colocado no $HIVE_HOME/confdiretório. Os seguintes comandos redirecionam para o Hiveconfig pasta e copie o arquivo de modelo:

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

Edite o hive-env.sh arquivo anexando a seguinte linha:

export HADOOP_HOME=/usr/local/hadoop

A instalação do Hive foi concluída com sucesso. Agora você precisa de um servidor de banco de dados externo para configurar o Metastore. Usamos o banco de dados Apache Derby.

Etapa 6: Baixar e instalar o Apache Derby

Siga as etapas abaixo para baixar e instalar o Apache Derby:

Baixando Apache Derby

O seguinte comando é usado para baixar o Apache Derby. Leva algum tempo para fazer o download.

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

O seguinte comando é usado para verificar o download:

$ ls

Após o download bem-sucedido, você verá a seguinte resposta:

db-derby-10.4.2.0-bin.tar.gz

Extração e verificação do arquivo Derby

Os seguintes comandos são usados ​​para extrair e verificar o arquivo Derby:

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

Após o download bem-sucedido, você verá a seguinte resposta:

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

Copiando arquivos para o diretório / usr / local / derby

Precisamos copiar do superusuário “su -”. Os seguintes comandos são usados ​​para copiar os arquivos do diretório extraído para o diretório / usr / local / derby:

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

Configurando o ambiente para Derby

Você pode configurar o ambiente Derby anexando as seguintes linhas ao ~/.bashrc Arquivo:

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

O seguinte comando é usado para executar ~/.bashrc Arquivo:

$ source ~/.bashrc

Crie um diretório para armazenar Metastore

Crie um diretório denominado data no diretório $ DERBY_HOME para armazenar dados do Metastore.

$ mkdir $DERBY_HOME/data

A instalação do Derby e a configuração do ambiente agora estão completas.

Etapa 7: Configurando Metastore do Hive

Configurar o Metastore significa especificar para o Hive onde o banco de dados está armazenado. Você pode fazer isso editando o arquivo hive-site.xml, que está no diretório $ HIVE_HOME / conf. Em primeiro lugar, copie o arquivo de modelo usando o seguinte comando:

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

Editar hive-site.xml e acrescente as seguintes linhas entre as tags <configuration> e </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>

Crie um arquivo denominado jpox.properties e adicione as seguintes linhas a ele:

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

Etapa 8: Verificando a instalação do Hive

Antes de executar o Hive, você precisa criar o /tmppasta e uma pasta separada do Hive no HDFS. Aqui, usamos o/user/hive/warehousepasta. Você precisa definir a permissão de gravação para essas pastas recém-criadas, conforme mostrado abaixo:

chmod g+w

Agora configure-os no HDFS antes de verificar o Hive. Use os seguintes comandos:

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

Os seguintes comandos são usados ​​para verificar a instalação do Hive:

$ cd $HIVE_HOME $ bin/hive

Na instalação bem-sucedida do Hive, você verá a seguinte resposta:

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>

O seguinte comando de amostra é executado para exibir todas as tabelas:

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

Este capítulo apresenta os diferentes tipos de dados no Hive, que estão envolvidos na criação da tabela. Todos os tipos de dados no Hive são classificados em quatro tipos, conforme segue:

• Tipos de coluna
• Literals
• Valores Nulos
• Tipos Complexos

Tipos de coluna

Os tipos de coluna são usados ​​como tipos de dados de coluna do Hive. Eles são os seguintes:

Tipos Integrais

Os dados do tipo inteiro podem ser especificados usando tipos de dados integrais, INT. Quando o intervalo de dados excede o intervalo de INT, você precisa usar BIGINT e se o intervalo de dados for menor do que o INT, você usa SMALLINT. TINYINT é menor que SMALLINT.

A tabela a seguir descreve vários tipos de dados INT:

Tipo	Postfix	Exemplo
TINYINT	Y	10 anos
SMALLINT	S	10S
INT	-	10
BIGINT	eu	10L

Tipos de String

Os tipos de dados do tipo string podem ser especificados usando aspas simples ('') ou aspas duplas (""). Ele contém dois tipos de dados: VARCHAR e CHAR. O Hive segue os caracteres de escape do tipo C.

A tabela a seguir descreve vários tipos de dados CHAR:

Tipo de dados	comprimento
VARCHAR	1 a 65355
CARACTERES	255

Timestamp

Suporta carimbo de data / hora UNIX tradicional com precisão opcional de nanossegundos. Ele suporta o formato java.sql.Timestamp “AAAA-MM-DD HH: MM: SS.fffffffff” e o formato “aaaa-mm-dd hh: mm: ss.ffffffffff”.

datas

Os valores de DATA são descritos no formato ano / mês / dia no formato {{AAAA-MM-DD}}.

Decimais

O tipo DECIMAL no Hive é igual ao formato Big Decimal do Java. É usado para representar precisão arbitrária imutável. A sintaxe e o exemplo são os seguintes:

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

Tipos de União

Union é uma coleção de tipos de dados heterogêneos. Você pode criar uma instância usandocreate union. A sintaxe e o exemplo são os seguintes:

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}

Literais

Os seguintes literais são usados ​​no Hive:

Tipos de ponto flutuante

Os tipos de ponto flutuante nada mais são do que números com casas decimais. Geralmente, este tipo de dados é composto do tipo de dados DOUBLE.

Tipo Decimal

^{-308 308}

Valor Nulo

Os valores ausentes são representados pelo valor especial NULL.

Tipos Complexos

Os tipos de dados complexos do Hive são os seguintes:

Arrays

Arrays no Hive são usados ​​da mesma maneira que são usados ​​em Java.

Sintaxe: ARRAY <data_type>

Mapas

Os mapas no Hive são semelhantes aos mapas Java.

Sintaxe: MAP <primitive_type, data_type>

Structs

Structs no Hive é semelhante ao uso de dados complexos com comentários.

Sintaxe: STRUCT <col_name: data_type [COMMENT col_comment], ...>

Hive é uma tecnologia de banco de dados que pode definir bancos de dados e tabelas para analisar dados estruturados. O tema da análise de dados estruturados é armazenar os dados de forma tabular e passar consultas para analisá-los. Este capítulo explica como criar um banco de dados Hive. O Hive contém um banco de dados padrão chamadodefault.

Criar declaração de banco de dados

Criar banco de dados é uma instrução usada para criar um banco de dados no Hive. Um banco de dados no Hive é umnamespaceou uma coleção de tabelas. osyntax para esta declaração é a seguinte:

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

Aqui, IF NOT EXISTS é uma cláusula opcional, que notifica o usuário que um banco de dados com o mesmo nome já existe. Podemos usar SCHEMA no lugar de DATABASE neste comando. A seguinte consulta é executada para criar um banco de dados chamadouserdb:

hive> CREATE DATABASE [IF NOT EXISTS] userdb;

or

hive> CREATE SCHEMA userdb;

A seguinte consulta é usada para verificar uma lista de bancos de dados:

hive> SHOW DATABASES;
default
userdb

Programa JDBC

O programa JDBC para criar um banco de dados é fornecido abaixo.

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

Salve o programa em um arquivo denominado HiveCreateDb.java. Os seguintes comandos são usados ​​para compilar e executar este programa.

$ javac HiveCreateDb.java $ java HiveCreateDb

Resultado:

Database userdb created successfully.

Este capítulo descreve como descartar um banco de dados no Hive. O uso de SCHEMA e DATABASE é o mesmo.

Declaração de banco de dados de descarte

Eliminar banco de dados é uma instrução que descarta todas as tabelas e exclui o banco de dados. Sua sintaxe é a seguinte:

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

As seguintes consultas são usadas para eliminar um banco de dados. Vamos supor que o nome do banco de dados sejauserdb.

hive> DROP DATABASE IF EXISTS userdb;

A consulta a seguir elimina o banco de dados usando CASCADE. Significa eliminar as respectivas tabelas antes de eliminar o banco de dados.

hive> DROP DATABASE IF EXISTS userdb CASCADE;

A consulta a seguir elimina o banco de dados usando SCHEMA.

hive> DROP SCHEMA userdb;

Esta cláusula foi adicionada no Hive 0.6.

Programa JDBC

O programa JDBC para eliminar um banco de dados é fornecido abaixo.

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

Salve o programa em um arquivo denominado HiveDropDb.java. A seguir estão os comandos para compilar e executar este programa.

$ javac HiveDropDb.java $ java HiveDropDb

Resultado:

Drop userdb database successful.

Este capítulo explica como criar uma tabela e inserir dados nela. As convenções de criação de uma tabela no HIVE são bastante semelhantes à criação de uma tabela usando SQL.

Criar declaração de tabela

Criar tabela é uma instrução usada para criar uma tabela no Hive. A sintaxe e o exemplo são os seguintes:

Sintaxe

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]

Exemplo

Vamos supor que você precise criar uma tabela chamada employee usando CREATE TABLEdeclaração. A tabela a seguir lista os campos e seus tipos de dados na tabela de funcionários:

Sr. Não	Nome do Campo	Tipo de dados
1	Eid	int
2	Nome	Corda
3	Salário	Flutuador
4	Designação	corda

Os dados a seguir são um comentário, campos formatados de linha, como terminador de campo, terminador de linhas e tipo de arquivo armazenado.

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

A consulta a seguir cria uma tabela chamada employee usando os dados acima.

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;

Se você adicionar a opção IF NOT EXISTS, o Hive ignorará a instrução caso a tabela já exista.

Após a criação bem-sucedida da tabela, você verá a seguinte resposta:

OK
Time taken: 5.905 seconds
hive>

Programa JDBC

O programa JDBC para criar uma tabela é um exemplo.

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

Salve o programa em um arquivo denominado HiveCreateDb.java. Os seguintes comandos são usados ​​para compilar e executar este programa.

$ javac HiveCreateDb.java $ java HiveCreateDb

Resultado

Table employee created.

Declaração de carga de dados

Geralmente, após criar uma tabela em SQL, podemos inserir dados usando a instrução Insert. Mas no Hive, podemos inserir dados usando a instrução LOAD DATA.

Ao inserir dados no Hive, é melhor usar LOAD DATA para armazenar registros em massa. Existem duas maneiras de carregar dados: uma é do sistema de arquivos local e a segunda é do sistema de arquivos Hadoop.

Syntex

A sintaxe para carregar dados é a seguinte:

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

• LOCAL é o identificador para especificar o caminho local. Isso é opcional.
• OVERWRITE é opcional para sobrescrever os dados na tabela.
• PARTITION é opcional.

Exemplo

Vamos inserir os seguintes dados na tabela. É um arquivo de texto chamadosample.txt dentro /home/user diretório.

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

A consulta a seguir carrega o texto fornecido na tabela.

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

Após o download bem-sucedido, você verá a seguinte resposta:

OK
Time taken: 15.905 seconds
hive>

Programa JDBC

A seguir está o programa JDBC para carregar dados fornecidos na tabela.

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

Salve o programa em um arquivo denominado HiveLoadData.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveLoadData.java $ java HiveLoadData

Resultado:

Load Data into employee successful

Este capítulo explica como alterar os atributos de uma tabela, como alterar o nome da tabela, alterar os nomes das colunas, adicionar colunas e excluir ou substituir colunas.

Alterar declaração da tabela

É usado para alterar uma tabela no Hive.

Sintaxe

A instrução assume qualquer uma das seguintes sintaxes com base nos atributos que desejamos modificar em uma tabela.

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 ...])

Renomear para… Declaração

A consulta a seguir renomeia a tabela de employee para emp.

hive> ALTER TABLE employee RENAME TO emp;

Programa JDBC

O programa JDBC para renomear uma tabela é o seguinte.

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

Salve o programa em um arquivo denominado HiveAlterRenameTo.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveAlterRenameTo.java $ java HiveAlterRenameTo

Resultado:

Table renamed successfully.

Declaração de mudança

A tabela a seguir contém os campos de employee tabela e mostra os campos a serem alterados (em negrito).

Nome do Campo	Converter do tipo de dados	Alterar o nome do campo	Converter para tipo de dados
eid	int	eid	int
name	Corda	ename	Corda
salário	Float	salário	Double
designação	Corda	designação	Corda

As consultas a seguir renomeiam o nome da coluna e o tipo de dados da coluna usando os dados acima:

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

Programa JDBC

A seguir está o programa JDBC para alterar uma coluna.

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

Salve o programa em um arquivo denominado HiveAlterChangeColumn.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveAlterChangeColumn.java $ java HiveAlterChangeColumn

Resultado:

Change column successful.

Adicionar declaração de colunas

A consulta a seguir adiciona uma coluna chamada dept à tabela de funcionários.

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

Programa JDBC

O programa JDBC para adicionar uma coluna a uma tabela é fornecido abaixo.

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

Salve o programa em um arquivo denominado HiveAlterAddColumn.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveAlterAddColumn.java $ java HiveAlterAddColumn

Resultado:

Add column successful.

Substituir Declaração

A consulta a seguir exclui todas as colunas do employee mesa e a substitui por emp e name colunas:

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

Programa JDBC

Abaixo é fornecido o programa JDBC para substituir eid coluna com empid e ename coluna com 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();
   }
}

Salve o programa em um arquivo denominado HiveAlterReplaceColumn.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveAlterReplaceColumn.java $ java HiveAlterReplaceColumn

Resultado:

Replace column successful.

Este capítulo descreve como eliminar uma tabela no Hive. Quando você remove uma tabela do Hive Metastore, ele remove os dados da tabela / coluna e seus metadados. Pode ser uma tabela normal (armazenada no Metastore) ou uma tabela externa (armazenada no sistema de arquivos local); O Hive trata os dois da mesma maneira, independentemente de seus tipos.

Declaração de abandono de mesa

A sintaxe é a seguinte:

DROP TABLE [IF EXISTS] table_name;

A consulta a seguir elimina uma tabela chamada employee:

hive> DROP TABLE IF EXISTS employee;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

OK
Time taken: 5.3 seconds
hive>

Programa JDBC

O programa JDBC a seguir elimina a tabela de funcionários.

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

Salve o programa em um arquivo denominado HiveDropTable.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveDropTable.java $ java HiveDropTable

Resultado:

Drop table successful

A seguinte consulta é usada para verificar a lista de tabelas:

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

O Hive organiza tabelas em partições. É uma maneira de dividir uma tabela em partes relacionadas com base nos valores de colunas particionadas, como data, cidade e departamento. Usando partição, é fácil consultar uma parte dos dados.

As tabelas ou partições são subdivididas em buckets,para fornecer estrutura extra aos dados que podem ser usados ​​para consultas mais eficientes. O agrupamento funciona com base no valor da função hash de alguma coluna de uma tabela.

Por exemplo, uma mesa chamada Tab1contém dados do funcionário, como id, nome, departamento e yoj (ou seja, ano de adesão). Suponha que você precise recuperar os detalhes de todos os funcionários que ingressaram em 2012. Uma consulta pesquisa em toda a tabela as informações necessárias. No entanto, se você particionar os dados do funcionário com o ano e armazená-los em um arquivo separado, isso reduzirá o tempo de processamento da consulta. O exemplo a seguir mostra como particionar um arquivo e seus dados:

O arquivo a seguir contém a tabela Employeedata.

/ tab1 / Employeedata / file1

id, nome, departamento, yoj

1, gopal, TP, 2012

2, kiran, HR, 2012

3, kaleel, SC, 2013

4, Prasanth, SC, 2013

 

Os dados acima são divididos em dois arquivos por ano.

/ tab1 / Employeedata / 2012 / file2

1, gopal, TP, 2012

2, kiran, HR, 2012

 

/ tab1 / Employeedata / 2013 / file3

3, kaleel, SC, 2013

4, Prasanth, SC, 2013

Adicionando uma Partição

Podemos adicionar partições a uma tabela alterando a tabela. Vamos supor que temos uma mesa chamadaemployee com campos como Id, Nome, Salário, Designação, Departamento e yoj.

Sintaxe:

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, ...)

A consulta a seguir é usada para adicionar uma partição à tabela de funcionários.

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

Renomeando uma Partição

A sintaxe desse comando é a seguinte.

ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;

A seguinte consulta é usada para renomear uma partição:

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

Soltando uma partição

A seguinte sintaxe é usada para descartar uma partição:

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

A seguinte consulta é usada para descartar uma partição:

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

Este capítulo explica os operadores integrados do Hive. Existem quatro tipos de operadores no Hive:

• Operadores Relacionais
• Operadores aritméticos
• Operadores lógicos
• Operadores Complexos

Operadores Relacionais

Esses operadores são usados ​​para comparar dois operandos. A tabela a seguir descreve os operadores relacionais disponíveis no Hive:

Operador	Operando	Descrição
A = B	todos os tipos primitivos	TRUE se a expressão A for equivalente à expressão B, caso contrário, FALSE.
A! = B	todos os tipos primitivos	TRUE se a expressão A não for equivalente à expressão B, caso contrário, FALSE.
A <B	todos os tipos primitivos	TRUE se a expressão A for menor que a expressão B, caso contrário, FALSE.
A <= B	todos os tipos primitivos	TRUE se a expressão A for menor ou igual à expressão B, caso contrário, FALSE.
A> B	todos os tipos primitivos	TRUE se a expressão A for maior que a expressão B, caso contrário, FALSE.
A> = B	todos os tipos primitivos	TRUE se a expressão A for maior ou igual à expressão B, caso contrário, FALSE.
A IS NULL	todos os tipos	TRUE se a expressão A for avaliada como NULL, caso contrário, FALSE.
A NÃO É NULO	todos os tipos	FALSE se a expressão A for avaliada como NULL, caso contrário, TRUE.
A LIKE B	Cordas	TRUE se o padrão de string A corresponder a B, caso contrário, FALSE.
A RLIKE B	Cordas	NULL se A ou B for NULL, TRUE se qualquer substring de A corresponder à expressão regular Java B, caso contrário, FALSE.
A REGEXP B	Cordas	O mesmo que RLIKE.

Exemplo

Vamos supor que employeeA tabela é composta de campos denominados Id, Nome, Salário, Designação e Departamento, conforme mostrado abaixo. Gere uma consulta para recuperar os detalhes do funcionário cujo ID é 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|
+-----+--------------+--------+---------------------------+------+

A seguinte consulta é executada para recuperar os detalhes do funcionário usando a tabela acima:

hive> SELECT * FROM employee WHERE Id=1205;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

A consulta a seguir é executada para recuperar os detalhes do funcionário cujo salário é maior ou igual a Rs 40.000.

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

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Operadores aritméticos

Esses operadores suportam várias operações aritméticas comuns nos operandos. Todos eles retornam tipos de números. A tabela a seguir descreve os operadores aritméticos disponíveis no Hive:

Operadores	Operando	Descrição
A + B	todos os tipos de número	Dá o resultado da adição de A e B.
A - B	todos os tipos de número	Fornece o resultado da subtração de B de A.
A * B	todos os tipos de número	Dá o resultado da multiplicação de A e B.
A / B	todos os tipos de número	Dá o resultado da divisão de B de A.
A% B	todos os tipos de número	Dá o lembrete resultante da divisão de A por B.
A e B	todos os tipos de número	Dá o resultado de AND bit a bit de A e B.
A | B	todos os tipos de número	Dá o resultado de OR bit a bit de A e B.
A ^ B	todos os tipos de número	Fornece o resultado do XOR bit a bit de A e B.
~ A	todos os tipos de número	Dá o resultado de NOT bit a bit de A.

Exemplo

A consulta a seguir adiciona dois números, 20 e 30.

hive> SELECT 20+30 ADD FROM temp;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Operadores lógicos

Os operadores são expressões lógicas. Todos eles retornam VERDADEIRO ou FALSO.

Operadores	Operandos	Descrição
A AND B	boleano	TRUE se A e B forem TRUE, caso contrário, FALSE.
A && B	boleano	Igual a A AND B.
A OU B	boleano	TRUE se A ou B ou ambos forem TRUE, caso contrário, FALSE.
A || B	boleano	Igual a A OR B.
NÃO A	boleano	TRUE se A for FALSE, caso contrário FALSE.
!UMA	boleano	O mesmo que NÃO A.

Exemplo

A consulta a seguir é usada para recuperar os detalhes do funcionário cujo Departamento é TP e o Salário é superior a Rs 40000.

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

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Operadores Complexos

Esses operadores fornecem uma expressão para acessar os elementos de Tipos complexos.

Operador	Operando	Descrição
A]	A é um Array en é um int	Ele retorna o enésimo elemento na matriz A. O primeiro elemento tem índice 0.
M [tecla]	M é um Mapa <K, V> e a chave tem tipo K	Ele retorna o valor correspondente à chave no mapa.
Sx	S é uma estrutura	Ele retorna o campo x de S.

O Hive Query Language (HiveQL) é uma linguagem de consulta para o Hive processar e analisar dados estruturados em um Metastore. Este capítulo explica como usar a instrução SELECT com a cláusula WHERE.

A instrução SELECT é usada para recuperar os dados de uma tabela. A cláusula WHERE funciona de maneira semelhante a uma condição. Ele filtra os dados usando a condição e fornece um resultado finito. Os operadores e funções integrados geram uma expressão que atende à condição.

Sintaxe

A seguir está a sintaxe da consulta 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];

Exemplo

Tomemos um exemplo para a cláusula SELECT… WHERE. Suponha que temos a tabela de funcionários conforme fornecida abaixo, com campos chamados Id, Nome, Salário, Designação e Departamento. Gere uma consulta para recuperar os detalhes dos funcionários que ganham um salário de mais de Rs 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  | 
+------+--------------+-------------+-------------------+--------+

A consulta a seguir recupera os detalhes do funcionário usando o cenário acima:

hive> SELECT * FROM employee WHERE salary>30000;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Programa JDBC

O programa JDBC para aplicar a cláusula where para o exemplo fornecido é o seguinte.

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

Salve o programa em um arquivo denominado HiveQLWhere.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveQLWhere.java $ java HiveQLWhere

Resultado:

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

Este capítulo explica como usar a cláusula ORDER BY em uma instrução SELECT. A cláusula ORDER BY é usada para recuperar os detalhes com base em uma coluna e classificar o conjunto de resultados em ordem crescente ou decrescente.

Sintaxe

A seguir está a sintaxe da cláusula 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];

Exemplo

Tomemos um exemplo para a cláusula SELECT ... ORDER BY. Assuma a tabela de funcionários conforme fornecida abaixo, com os campos chamados Id, Nome, Salário, Designação e Departamento. Gere uma consulta para recuperar os detalhes do funcionário em ordem usando o nome do Departamento.

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

A consulta a seguir recupera os detalhes do funcionário usando o cenário acima:

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

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Programa JDBC

Aqui está o programa JDBC para aplicar a cláusula Order By para o exemplo fornecido.

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

Salve o programa em um arquivo denominado HiveQLOrderBy.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveQLOrderBy.java $ java HiveQLOrderBy

Resultado:

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

Este capítulo explica os detalhes da cláusula GROUP BY em uma instrução SELECT. A cláusula GROUP BY é usada para agrupar todos os registros em um conjunto de resultados usando uma coluna de coleção específica. É usado para consultar um grupo de registros.

Sintaxe

A sintaxe da cláusula GROUP BY é a seguinte:

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

Exemplo

Vejamos um exemplo da cláusula SELECT… GROUP BY. Assuma a tabela de funcionários conforme fornecida abaixo, com os campos Id, Nome, Salário, Designação e Departamento. Gere uma consulta para recuperar o número de funcionários em cada departamento.

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

A consulta a seguir recupera os detalhes do funcionário usando o cenário acima.

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

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Programa JDBC

A seguir está o programa JDBC para aplicar a cláusula Group By para o exemplo fornecido.

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

Salve o programa em um arquivo denominado HiveQLGroupBy.java. Use os seguintes comandos para compilar e executar este programa.

$ javac HiveQLGroupBy.java $ java HiveQLGroupBy

Resultado:

Dept     Count(*)
 Admin       1
 PR          2
 TP          3

JOINS é uma cláusula usada para combinar campos específicos de duas tabelas usando valores comuns a cada uma. É usado para combinar registros de duas ou mais tabelas no banco de dados.

Sintaxe

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]

Exemplo

Usaremos as duas tabelas a seguir neste capítulo. Considere a seguinte tabela chamada CLIENTES.

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

Considere outra tabela ORDERS da seguinte forma:

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

Existem diferentes tipos de junções fornecidas a seguir:

• JOIN
• LEFT OUTER JOIN
• DIREITO OUTER JOIN
• FULL OUTER JOIN

JUNTE-SE

A cláusula JOIN é usada para combinar e recuperar os registros de várias tabelas. JOIN é igual a OUTER JOIN no SQL. Uma condição JOIN deve ser gerada usando as chaves primárias e as chaves estrangeiras das tabelas.

A consulta a seguir executa JOIN nas tabelas CUSTOMER e ORDER e recupera os registros:

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

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

LEFT OUTER JOIN

O HiveQL LEFT OUTER JOIN retorna todas as linhas da tabela da esquerda, mesmo se não houver correspondências na tabela da direita. Isso significa que, se a cláusula ON corresponder a 0 (zero) registros na tabela certa, o JOIN ainda retornará uma linha no resultado, mas com NULL em cada coluna da tabela certa.

Um LEFT JOIN retorna todos os valores da tabela à esquerda, mais os valores correspondentes da tabela à direita, ou NULL no caso de nenhum predicado JOIN correspondente.

A consulta a seguir demonstra LEFT OUTER JOIN entre as tabelas CUSTOMER e 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);

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

DIREITO OUTER JOIN

O HiveQL RIGHT OUTER JOIN retorna todas as linhas da tabela da direita, mesmo se não houver correspondências na tabela da esquerda. Se a cláusula ON corresponder a 0 (zero) registros na tabela à esquerda, o JOIN ainda retornará uma linha no resultado, mas com NULL em cada coluna da tabela à esquerda.

Um RIGHT JOIN retorna todos os valores da tabela da direita, mais os valores correspondentes da tabela da esquerda, ou NULL no caso de nenhum predicado de junção correspondente.

A consulta a seguir demonstra RIGHT OUTER JOIN entre as tabelas CUSTOMER e 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);

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

FULL OUTER JOIN

O HiveQL FULL OUTER JOIN combina os registros das tabelas externas esquerda e direita que atendem à condição JOIN. A tabela associada contém todos os registros de ambas as tabelas ou preenche valores NULL para correspondências ausentes em ambos os lados.

A consulta a seguir demonstra FULL OUTER JOIN entre as tabelas CUSTOMER e 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);

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

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

Este capítulo explica as funções integradas disponíveis no Hive. As funções parecem bastante semelhantes às funções SQL, exceto pelo seu uso.

Funções integradas

O Hive oferece suporte às seguintes funções integradas:

Tipo de Devolução	Assinatura	Descrição
BIGINT	rodada (duplo a)	Ele retorna o valor BIGINT arredondado do duplo.
BIGINT	andar (duplo a)	Ele retorna o valor máximo de BIGINT que é igual ou menor que o dobro.
BIGINT	teto (duplo a)	Ele retorna o valor mínimo de BIGINT que é igual ou maior que o dobro.
em dobro	rand (), rand (semente interna)	Ele retorna um número aleatório que muda de linha para linha.
corda	concat (string A, string B, ...)	Ele retorna a string resultante da concatenação de B após A.
corda	substr (string A, início interno)	Ele retorna a substring de A começando da posição inicial até o final da string A.
corda	substr (string A, início interno, comprimento interno)	Ele retorna a substring de A começando da posição inicial com o comprimento fornecido.
corda	superior (corda A)	Ele retorna a string resultante da conversão de todos os caracteres de A em maiúsculas.
corda	ucase (string A)	O mesmo que acima.
corda	inferior (string A)	Ele retorna a string resultante da conversão de todos os caracteres de B em minúsculas.
corda	lcase (string A)	O mesmo que acima.
corda	trim (string A)	Ele retorna a string resultante do corte de espaços de ambas as extremidades de A.
corda	ltrim (string A)	Ele retorna a string resultante do corte de espaços do início (lado esquerdo) de A.
corda	rtrim (string A)	rtrim (string A) Retorna a string resultante do corte de espaços do final (lado direito) de A.
corda	regexp_replace (string A, string B, string C)	Ele retorna a string resultante da substituição de todas as substrings em B que correspondem à sintaxe da expressão regular Java com C.
int	tamanho (Mapa <KV>)	Ele retorna o número de elementos no tipo de mapa.
int	tamanho (Array <T>)	Ele retorna o número de elementos no tipo de matriz.
valor de <tipo>	elenco (<expr> como <tipo>)	Ele converte os resultados da expressão expr em <tipo>, por exemplo, cast ('1' como BIGINT) converte a string '1' em sua representação integral. Um NULL é retornado se a conversão não for bem-sucedida.
corda	from_unixtime (int unixtime)	converter o número de segundos da época Unix (1970-01-01 00:00:00 UTC) em uma string que representa o carimbo de data / hora daquele momento no fuso horário do sistema atual no formato "1970-01-01 00:00: 00 "
corda	to_date (string timestamp)	Ele retorna a parte da data de uma string de carimbo de data / hora: to_date ("1970-01-01 00:00:00") = "1970-01-01"
int	ano (string data)	Ele retorna a parte do ano de uma data ou uma string de carimbo de data / hora: ano ("1970-01-01 00:00:00") = 1970, ano ("1970-01-01") = 1970
int	mês (string data)	Ele retorna a parte do mês de uma data ou uma string de carimbo de data / hora: mês ("1970-11-01 00:00:00") = 11, mês ("1970-11-01") = 11
int	dia (string data)	Ele retorna a parte do dia de uma data ou string de carimbo de data / hora: day ("1970-11-01 00:00:00") = 1, day ("1970-11-01") = 1
corda	get_json_object (string json_string, caminho da string)	Ele extrai o objeto json de uma string json com base no caminho json especificado e retorna a string json do objeto json extraído. Ele retorna NULL se a string json de entrada for inválida.

Exemplo

As seguintes consultas demonstram algumas funções integradas:

função round ()

hive> SELECT round(2.6) from temp;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

3.0

função floor ()

hive> SELECT floor(2.6) from temp;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

2.0

função ceil ()

hive> SELECT ceil(2.6) from temp;

Na execução bem-sucedida da consulta, você verá a seguinte resposta:

3.0

Funções de agregação

O Hive é compatível com o seguinte aggregate functions. O uso dessas funções é igual ao das funções de agregação SQL.

Tipo de Devolução	Assinatura	Descrição
BIGINT	contagem (*), contagem (expr),	count (*) - Retorna o número total de linhas recuperadas.
EM DOBRO	soma (col), soma (DISTINCT col)	Ele retorna a soma dos elementos do grupo ou a soma dos valores distintos da coluna do grupo.
EM DOBRO	média (col), média (DISTINCT col)	Ele retorna a média dos elementos no grupo ou a média dos valores distintos da coluna no grupo.
EM DOBRO	min (col)	Ele retorna o valor mínimo da coluna no grupo.
EM DOBRO	max (col)	Ele retorna o valor máximo da coluna no grupo.

Este capítulo descreve como criar e gerenciar visualizações. As visualizações são geradas com base nos requisitos do usuário. Você pode salvar quaisquer dados do conjunto de resultados como uma visualização. O uso da visualização no Hive é igual ao da visualização no SQL. É um conceito RDBMS padrão. Podemos executar todas as operações DML em uma visualização.

Criação de uma visão

Você pode criar uma visualização no momento de executar uma instrução SELECT. A sintaxe é a seguinte:

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

Exemplo

Vamos dar um exemplo para ver. Assuma a tabela de funcionários conforme fornecida abaixo, com os campos Id, Nome, Salário, Designação e Departamento. Gere uma consulta para recuperar os detalhes do funcionário que ganham um salário de mais de Rs 30000. Armazenamos o resultado em uma visualização chamadaemp_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  |
+------+--------------+-------------+-------------------+--------+

A consulta a seguir recupera os detalhes do funcionário usando o cenário acima:

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

Abandonando uma Visualização

Use a seguinte sintaxe para descartar uma visualização:

DROP VIEW view_name

A consulta a seguir elimina uma visualização chamada emp_30000:

hive> DROP VIEW emp_30000;

Criação de um índice

Um índice nada mais é do que um ponteiro para uma coluna específica de uma tabela. Criar um índice significa criar um ponteiro em uma coluna específica de uma tabela. Sua sintaxe é a seguinte:

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 (...)]

Exemplo

Tomemos um exemplo de índice. Use a mesma tabela de funcionários que usamos anteriormente com os campos Id, Nome, Salário, Designação e Departamento. Crie um índice denominado index_salary na coluna de salários da tabela de funcionários.

A consulta a seguir cria um índice:

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

É um indicador para a coluna de salários. Se a coluna for modificada, as alterações serão armazenadas usando um valor de índice.

Descartando um índice

A seguinte sintaxe é usada para descartar um índice:

DROP INDEX <index_name> ON <table_name>

A consulta a seguir elimina um índice denominado index_salary:

hive> DROP INDEX index_salary ON employee;