Apache Pig - Guia Rápido

O que é Apache Pig?

Apache Pig é uma abstração do MapReduce. É uma ferramenta / plataforma usada para analisar grandes conjuntos de dados, representando-os como fluxos de dados. O porco é geralmente usado comHadoop; podemos realizar todas as operações de manipulação de dados no Hadoop usando o Apache Pig.

Para escrever programas de análise de dados, o Pig fornece uma linguagem de alto nível conhecida como Pig Latin. Essa linguagem fornece vários operadores, usando os quais os programadores podem desenvolver suas próprias funções de leitura, gravação e processamento de dados.

Para analisar dados usando Apache Pig, os programadores precisam escrever scripts usando a linguagem Pig Latin. Todos esses scripts são convertidos internamente em tarefas Map e Reduce. Apache Pig tem um componente conhecido comoPig Engine que aceita os scripts Pig Latin como entrada e os converte em tarefas MapReduce.

Por que precisamos do Apache Pig?

Os programadores que não são tão bons em Java normalmente costumavam ter dificuldade em trabalhar com o Hadoop, especialmente durante a execução de qualquer tarefa MapReduce. O Apache Pig é uma benção para todos esses programadores.

• Usando Pig Latin, os programadores podem executar tarefas MapReduce facilmente, sem precisar digitar códigos complexos em Java.

• Apache Pig usa multi-query approach, reduzindo assim o comprimento dos códigos. Por exemplo, uma operação que exigiria que você digite 200 linhas de código (LoC) em Java pode ser facilmente feita digitando apenas 10 LoC no Apache Pig. Em última análise, o Apache Pig reduz o tempo de desenvolvimento em quase 16 vezes.

• Pig Latin é SQL-like language e é fácil aprender Apache Pig quando você está familiarizado com SQL.

• O Apache Pig fornece muitos operadores integrados para suportar operações de dados como junções, filtros, ordenação etc. Além disso, ele também fornece tipos de dados aninhados como tuplas, bolsas e mapas que estão faltando no MapReduce.

Características do porco

O Apache Pig vem com os seguintes recursos -

• Rich set of operators - Ele fornece muitos operadores para realizar operações como junção, classificação, arquivador, etc.

• Ease of programming - Pig Latin é semelhante ao SQL e é fácil escrever um script Pig se você for bom em SQL.

• Optimization opportunities - As tarefas no Apache Pig otimizam sua execução automaticamente, de modo que os programadores precisam se concentrar apenas na semântica da linguagem.

• Extensibility - Usando os operadores existentes, os usuários podem desenvolver suas próprias funções para ler, processar e gravar dados.

• UDF’s - Pig fornece a facilidade de criar User-defined Functions em outras linguagens de programação, como Java, e os invoque ou incorpore em Pig Scripts.

• Handles all kinds of data- O Apache Pig analisa todos os tipos de dados, tanto estruturados quanto não estruturados. Ele armazena os resultados em HDFS.

Apache Pig Vs MapReduce

Listadas abaixo estão as principais diferenças entre o Apache Pig e o MapReduce.

Porco apache	MapReduce
Apache Pig é uma linguagem de fluxo de dados.	MapReduce é um paradigma de processamento de dados.
É uma linguagem de alto nível.	MapReduce é de baixo nível e rígido.
Realizar uma operação Join no Apache Pig é muito simples.	É muito difícil no MapReduce realizar uma operação de junção entre conjuntos de dados.
Qualquer programador novato com um conhecimento básico de SQL pode trabalhar convenientemente com o Apache Pig.	A exposição ao Java é obrigatória para trabalhar com MapReduce.
O Apache Pig usa uma abordagem de várias consultas, reduzindo em grande parte o comprimento dos códigos.	O MapReduce exigirá quase 20 vezes mais o número de linhas para realizar a mesma tarefa.
Não há necessidade de compilação. Na execução, cada operador Apache Pig é convertido internamente em um trabalho MapReduce.	Os trabalhos de MapReduce têm um longo processo de compilação.

Apache Pig Vs SQL

Listadas abaixo estão as principais diferenças entre o Apache Pig e o SQL.

Porco	SQL
Pig Latin é um procedural língua.	SQL é um declarative língua.
Em Apache Pig, schemaé opcional. Podemos armazenar dados sem projetar um esquema (os valores são armazenados como$01, $02 etc.)	O esquema é obrigatório no SQL.
O modelo de dados no Apache Pig é nested relational.	O modelo de dados usado em SQL is flat relational.
Apache Pig oferece oportunidades limitadas para Query optimization.	Há mais oportunidades para otimização de consulta em SQL.

Além das diferenças acima, Apache Pig Latin -

• Permite divisões no pipeline.
• Permite que os desenvolvedores armazenem dados em qualquer lugar do pipeline.
• Declara planos de execução.
• Fornece operadores para realizar funções ETL (Extrair, Transformar e Carregar).

Apache Pig Vs Hive

Tanto o Apache Pig quanto o Hive são usados ​​para criar trabalhos de MapReduce. E, em alguns casos, o Hive opera no HDFS de maneira semelhante ao Apache Pig. Na tabela a seguir, listamos alguns pontos significativos que diferenciam o Apache Pig do Hive.

Porco apache	Colmeia
Apache Pig usa uma linguagem chamada Pig Latin. Foi originalmente criado emYahoo.	O Hive usa uma linguagem chamada HiveQL. Foi originalmente criado emFacebook.
Pig Latin é uma linguagem de fluxo de dados.	HiveQL é uma linguagem de processamento de consulta.
Pig Latin é uma linguagem procedural e se encaixa no paradigma pipeline.	HiveQL é uma linguagem declarativa.
Apache Pig pode lidar com dados estruturados, não estruturados e semiestruturados.	O Hive é principalmente para dados estruturados.

Aplicações do Apache Pig

O Apache Pig é geralmente usado por cientistas de dados para realizar tarefas que envolvem processamento ad-hoc e prototipagem rápida. Apache Pig é usado -

• Para processar grandes fontes de dados, como logs da web.
• Para realizar o processamento de dados para plataformas de pesquisa.
• Para processar cargas de dados sensíveis ao tempo.

Apache Pig - História

Dentro 2006, Apache Pig foi desenvolvido como um projeto de pesquisa no Yahoo, especialmente para criar e executar jobs MapReduce em cada conjunto de dados. Dentro2007, Apache Pig foi de código aberto via incubadora Apache. Dentro2008, o primeiro lançamento do Apache Pig foi lançado. Dentro2010, Apache Pig graduou-se como um projeto de nível superior do Apache.

A linguagem usada para analisar dados no Hadoop usando Pig é conhecida como Pig Latin. É uma linguagem de processamento de dados de alto nível que fornece um rico conjunto de tipos de dados e operadores para realizar várias operações nos dados.

Para executar uma tarefa específica, os programadores que usam Pig, precisam escrever um script Pig usando a linguagem Pig Latin e executá-los usando qualquer um dos mecanismos de execução (Grunt Shell, UDFs, Embedded). Após a execução, esses scripts passarão por uma série de transformações aplicadas pelo Pig Framework, para produzir a saída desejada.

Internamente, o Apache Pig converte esses scripts em uma série de tarefas MapReduce e, portanto, torna a tarefa do programador mais fácil. A arquitetura do Apache Pig é mostrada abaixo.

Componentes Apache Pig

Conforme mostrado na figura, existem vários componentes na estrutura do Apache Pig. Vamos dar uma olhada nos componentes principais.

Parser

Inicialmente, os scripts do Pig são tratados pelo analisador. Ele verifica a sintaxe do script, verifica o tipo e outras verificações diversas. A saída do analisador será um DAG (gráfico acíclico direcionado), que representa as instruções Pig Latin e os operadores lógicos.

No DAG, os operadores lógicos do script são representados como nós e os fluxos de dados são representados como bordas.

Otimizador

O plano lógico (DAG) é passado para o otimizador lógico, que realiza as otimizações lógicas, como projeção e pushdown.

Compilador

O compilador compila o plano lógico otimizado em uma série de tarefas MapReduce.

Motor de execução

Finalmente, as tarefas MapReduce são enviadas ao Hadoop em uma ordem classificada. Finalmente, essas tarefas MapReduce são executadas no Hadoop produzindo os resultados desejados.

Pig Latin Data Model

O modelo de dados do Pig Latin é totalmente aninhado e permite tipos de dados não atômicos complexos, como map e tuple. A seguir, está a representação diagramática do modelo de dados do Pig Latin.

Átomo

Qualquer valor único em Pig Latin, independentemente de seus dados, é conhecido como um tipo Atom. É armazenado como string e pode ser usado como string e número. int, long, float, double, chararray e bytearray são os valores atômicos de Pig. Um dado ou um valor atômico simples é conhecido como umfield.

Example - 'raja' ou '30'

Tupla

Um registro que é formado por um conjunto ordenado de campos é conhecido como tupla, os campos podem ser de qualquer tipo. Uma tupla é semelhante a uma linha em uma tabela de RDBMS.

Example - (Raja, 30)

Bolsa

Uma bolsa é um conjunto não ordenado de tuplas. Em outras palavras, uma coleção de tuplas (não exclusivas) é conhecida como bolsa. Cada tupla pode ter qualquer número de campos (esquema flexível). Uma bolsa é representada por '{}'. É semelhante a uma tabela em RDBMS, mas ao contrário de uma tabela em RDBMS, não é necessário que cada tupla contenha o mesmo número de campos ou que os campos na mesma posição (coluna) tenham o mesmo tipo.

Example - {(Raja, 30), (Mohammad, 45)}

Uma bolsa pode ser um campo em uma relação; nesse contexto, é conhecido comoinner bag.

Example- {Raja, 30, {9848022338, [email protected],} }

Mapa

Um mapa (ou mapa de dados) é um conjunto de pares de valores-chave. okeyprecisa ser do tipo chararray e deve ser exclusivo. ovaluepode ser de qualquer tipo. É representado por '[]'

Example - [nome # Raja, idade # 30]

Relação

Uma relação é um saco de tuplas. As relações no Pig Latin são desordenadas (não há garantia de que as tuplas sejam processadas em qualquer ordem particular).

Este capítulo explica como baixar, instalar e configurar Apache Pig em seu sistema.

Pré-requisitos

É essencial que você tenha Hadoop e Java instalados em seu sistema antes de ir para o Apache Pig. Portanto, antes de instalar o Apache Pig, instale o Hadoop e o Java seguindo as etapas fornecidas no link a seguir -

http://www.tutorialspoint.com/hadoop/hadoop_enviornment_setup.htm

Baixar Apache Pig

Em primeiro lugar, baixe a versão mais recente do Apache Pig do seguinte site - https://pig.apache.org/

Passo 1

Abra a página inicial do site do Apache Pig. Sob a seçãoNews, Clique no link release page conforme mostrado no instantâneo a seguir.

Passo 2

Ao clicar no link especificado, você será redirecionado para o Apache Pig Releasespágina. Nesta página, sob oDownload seção, você terá dois links, a saber, Pig 0.8 and later e Pig 0.7 and before. Clique no linkPig 0.8 and later, então você será redirecionado para a página com um conjunto de espelhos.

etapa 3

Escolha e clique em qualquer um desses espelhos, conforme mostrado abaixo.

Passo 4

Esses espelhos irão levá-lo ao Pig Releasespágina. Esta página contém várias versões do Apache Pig. Clique na versão mais recente entre eles.

Etapa 5

Dentro dessas pastas, você terá os arquivos de origem e binários do Apache Pig em várias distribuições. Baixe os arquivos tar dos arquivos fonte e binários do Apache Pig 0.15,pig0.15.0-src.tar.gz e pig-0.15.0.tar.gz.

Instale o Apache Pig

Depois de baixar o software Apache Pig, instale-o em seu ambiente Linux seguindo as etapas fornecidas a seguir.

Passo 1

Crie um diretório com o nome Pig no mesmo diretório onde os diretórios de instalação do Hadoop, Java,e outro software foi instalado. (Em nosso tutorial, criamos o diretório Pig no usuário denominado Hadoop).

$ mkdir Pig

Passo 2

Extraia os arquivos tar baixados conforme mostrado abaixo.

$ cd Downloads/ 
$ tar zxvf pig-0.15.0-src.tar.gz $ tar zxvf pig-0.15.0.tar.gz

etapa 3

Mova o conteúdo de pig-0.15.0-src.tar.gz arquivo para o Pig diretório criado anteriormente, conforme mostrado abaixo.

$ mv pig-0.15.0-src.tar.gz/* /home/Hadoop/Pig/

Configurar Apache Pig

Depois de instalar o Apache Pig, temos que configurá-lo. Para configurar, precisamos editar dois arquivos -bashrc and pig.properties.

arquivo .bashrc

No .bashrc arquivo, defina as seguintes variáveis ​​-

• PIG_HOME pasta para a pasta de instalação do Apache Pig,

• PATH variável de ambiente para a pasta bin, e

• PIG_CLASSPATH variável de ambiente para a pasta etc (configuração) de suas instalações do Hadoop (o diretório que contém os arquivos core-site.xml, hdfs-site.xml e mapred-site.xml).

export PIG_HOME = /home/Hadoop/Pig
export PATH  = $PATH:/home/Hadoop/pig/bin
export PIG_CLASSPATH = $HADOOP_HOME/conf

arquivo pig.properties

No conf pasta do Pig, temos um arquivo chamado pig.properties. No arquivo pig.properties, você pode definir vários parâmetros conforme fornecido a seguir.

pig -h properties

As seguintes propriedades são suportadas -

Logging: verbose = true|false; default is false. This property is the same as -v
       switch brief=true|false; default is false. This property is the same 
       as -b switch debug=OFF|ERROR|WARN|INFO|DEBUG; default is INFO.             
       This property is the same as -d switch aggregate.warning = true|false; default is true. 
       If true, prints count of warnings of each type rather than logging each warning.		 
		 
Performance tuning: pig.cachedbag.memusage=<mem fraction>; default is 0.2 (20% of all memory).
       Note that this memory is shared across all large bags used by the application.         
       pig.skewedjoin.reduce.memusagea=<mem fraction>; default is 0.3 (30% of all memory).
       Specifies the fraction of heap available for the reducer to perform the join.
       pig.exec.nocombiner = true|false; default is false.
           Only disable combiner as a temporary workaround for problems.         
       opt.multiquery = true|false; multiquery is on by default.
           Only disable multiquery as a temporary workaround for problems.
       opt.fetch=true|false; fetch is on by default.
           Scripts containing Filter, Foreach, Limit, Stream, and Union can be dumped without MR jobs.         
       pig.tmpfilecompression = true|false; compression is off by default.             
           Determines whether output of intermediate jobs is compressed.         
       pig.tmpfilecompression.codec = lzo|gzip; default is gzip.
           Used in conjunction with pig.tmpfilecompression. Defines compression type.         
       pig.noSplitCombination = true|false. Split combination is on by default.
           Determines if multiple small files are combined into a single map.         
			  
       pig.exec.mapPartAgg = true|false. Default is false.             
           Determines if partial aggregation is done within map phase, before records are sent to combiner.         
       pig.exec.mapPartAgg.minReduction=<min aggregation factor>. Default is 10.             
           If the in-map partial aggregation does not reduce the output num records by this factor, it gets disabled.
			  
Miscellaneous: exectype = mapreduce|tez|local; default is mapreduce. This property is the same as -x switch
       pig.additional.jars.uris=<comma seperated list of jars>. Used in place of register command.
       udf.import.list=<comma seperated list of imports>. Used to avoid package names in UDF.
       stop.on.failure = true|false; default is false. Set to true to terminate on the first error.         
       pig.datetime.default.tz=<UTC time offset>. e.g. +08:00. Default is the default timezone of the host.
           Determines the timezone used to handle datetime datatype and UDFs.
Additionally, any Hadoop property can be specified.

Verificando a instalação

Verifique a instalação do Apache Pig digitando o comando version. Se a instalação for bem-sucedida, você obterá a versão do Apache Pig conforme mostrado abaixo.

$ pig –version 
 
Apache Pig version 0.15.0 (r1682971)  
compiled Jun 01 2015, 11:44:35

No capítulo anterior, explicamos como instalar o Apache Pig. Neste capítulo, discutiremos como executar o Apache Pig.

Modos de execução do Apache Pig

Você pode executar o Apache Pig em dois modos, a saber, Local Mode e HDFS mode.

Modo local

Nesse modo, todos os arquivos são instalados e executados a partir do host local e do sistema de arquivos local. Não há necessidade de Hadoop ou HDFS. Este modo é geralmente usado para fins de teste.

Modo MapReduce

O modo MapReduce é onde carregamos ou processamos os dados que existem no Hadoop File System (HDFS) usando o Apache Pig. Nesse modo, sempre que executamos as instruções Pig Latin para processar os dados, uma tarefa MapReduce é chamada no back-end para realizar uma operação específica nos dados existentes no HDFS.

Mecanismos de execução do Apache Pig

Os scripts do Apache Pig podem ser executados de três maneiras, a saber, modo interativo, modo em lote e modo integrado.

• Interactive Mode(Shell Grunt) - Você pode executar o Apache Pig no modo interativo usando o shell Grunt. Neste shell, você pode inserir as instruções Pig Latin e obter a saída (usando o operador Dump).

• Batch Mode (Script) - Você pode executar o Apache Pig no modo em lote, escrevendo o script Pig Latin em um único arquivo com .pig extensão.

• Embedded Mode (UDF) - Apache Pig fornece a definição de nossas próprias funções (USer Dafinado Funções) em linguagens de programação como Java e como usá-las em nosso script.

Invocando o Grunt Shell

Você pode invocar o shell Grunt em um modo desejado (local / MapReduce) usando o −x opção como mostrado abaixo.

Modo local	Modo MapReduce
Command − $ ./pig –x local	Command − $ ./pig -x mapreduce
Output -	Output -

Qualquer um desses comandos fornece o prompt do shell Grunt conforme mostrado abaixo.

grunt>

Você pode sair do shell Grunt usando ‘ctrl + d’.

Depois de invocar o shell Grunt, você pode executar um script Pig inserindo diretamente as instruções Pig Latin nele.

grunt> customers = LOAD 'customers.txt' USING PigStorage(',');

Executando Apache Pig em modo de lote

Você pode escrever um script Pig Latin inteiro em um arquivo e executá-lo usando o –x command. Vamos supor que temos um script Pig em um arquivo chamadosample_script.pig como mostrado abaixo.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);
  
Dump student;

Agora, você pode executar o script no arquivo acima, conforme mostrado abaixo.

Modo local	Modo MapReduce
$ pig -x local Sample_script.pig	$ pig -x mapreduce Sample_script.pig

Note - Discutiremos em detalhes como executar um script Pig em Bach mode e em embedded mode nos capítulos subsequentes.

Depois de invocar o shell Grunt, você pode executar seus scripts Pig no shell. Além disso, existem certos shell úteis e comandos de utilitário fornecidos pelo shell Grunt. Este capítulo explica o shell e os comandos de utilitário fornecidos pelo shell Grunt.

Note - Em algumas partes deste capítulo, os comandos como Load e Storesão usados. Consulte os respectivos capítulos para obter informações detalhadas sobre eles.

Comandos Shell

O shell Grunt do Apache Pig é usado principalmente para escrever scripts do Pig Latin. Antes disso, podemos invocar qualquer comando shell usandosh e fs.

Comando sh

Usando shcomando, podemos invocar qualquer comando shell do shell Grunt. Usandosh comando do shell Grunt, não podemos executar os comandos que fazem parte do ambiente do shell (ex - cd).

Syntax

Dada a seguir é a sintaxe de sh comando.

grunt> sh shell command parameters

Example

Podemos invocar o ls comando do shell Linux a partir do shell Grunt usando o shopção como mostrado abaixo. Neste exemplo, ele lista os arquivos no/pig/bin/ diretório.

grunt> sh ls
   
pig 
pig_1444799121955.log 
pig.cmd 
pig.py

Comando fs

Usando o fs , podemos invocar qualquer comando FsShell do shell Grunt.

Syntax

Dada a seguir é a sintaxe de fs comando.

grunt> sh File System command parameters

Example

Podemos invocar o comando ls do HDFS a partir do shell Grunt usando o comando fs. No exemplo a seguir, ele lista os arquivos no diretório raiz HDFS.

grunt> fs –ls
  
Found 3 items
drwxrwxrwx   - Hadoop supergroup          0 2015-09-08 14:13 Hbase
drwxr-xr-x   - Hadoop supergroup          0 2015-09-09 14:52 seqgen_data
drwxr-xr-x   - Hadoop supergroup          0 2015-09-08 11:30 twitter_data

Da mesma forma, podemos invocar todos os outros comandos do shell do sistema de arquivos do shell Grunt usando o fs comando.

Comandos utilitários

O shell Grunt fornece um conjunto de comandos utilitários. Isso inclui comandos utilitários comoclear, help, history, quit, e set; e comandos comoexec, kill, e runpara controlar Pig a partir do shell Grunt. A seguir está a descrição dos comandos utilitários fornecidos pelo shell Grunt.

comando claro

o clear comando é usado para limpar a tela do shell Grunt.

Syntax

Você pode limpar a tela do escudo do grunhido usando o clear comando como mostrado abaixo.

grunt> clear

comando de ajuda

o help comando fornece uma lista de comandos do Pig ou propriedades do Pig.

Usage

Você pode obter uma lista de comandos Pig usando o help comando como mostrado abaixo.

grunt> help

Commands: <pig latin statement>; - See the PigLatin manual for details:
http://hadoop.apache.org/pig
  
File system commands:fs <fs arguments> - Equivalent to Hadoop dfs  command:
http://hadoop.apache.org/common/docs/current/hdfs_shell.html
	 
Diagnostic Commands:describe <alias>[::<alias] - Show the schema for the alias.
Inner aliases can be described as A::B.
    explain [-script <pigscript>] [-out <path>] [-brief] [-dot|-xml] 
       [-param <param_name>=<pCram_value>]
       [-param_file <file_name>] [<alias>] - 
       Show the execution plan to compute the alias or for entire script.
       -script - Explain the entire script.
       -out - Store the output into directory rather than print to stdout.
       -brief - Don't expand nested plans (presenting a smaller graph for overview).
       -dot - Generate the output in .dot format. Default is text format.
       -xml - Generate the output in .xml format. Default is text format.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       alias - Alias to explain.
       dump <alias> - Compute the alias and writes the results to stdout.

Utility Commands: exec [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment including aliases.
       -param <param_name - See parameter substitution for details.
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    run [-param <param_name>=param_value] [-param_file <file_name>] <script> -
       Execute the script with access to grunt environment.
		 -param <param_name - See parameter substitution for details.         
       -param_file <file_name> - See parameter substitution for details.
       script - Script to be executed.
    sh  <shell command> - Invoke a shell command.
    kill <job_id> - Kill the hadoop job specified by the hadoop job id.
    set <key> <value> - Provide execution parameters to Pig. Keys and values are case sensitive.
       The following keys are supported:
       default_parallel - Script-level reduce parallelism. Basic input size heuristics used 
       by default.
       debug - Set debug on or off. Default is off.
       job.name - Single-quoted name for jobs. Default is PigLatin:<script name>     
       job.priority - Priority for jobs. Values: very_low, low, normal, high, very_high.
       Default is normal stream.skippath - String that contains the path.
       This is used by streaming any hadoop property.
    help - Display this message.
    history [-n] - Display the list statements in cache.
       -n Hide line numbers.
    quit - Quit the grunt shell.

história Comando

Este comando exibe uma lista de instruções executadas / usadas até agora desde que a venda Grunt foi invocada.

Usage

Suponha que executamos três instruções desde a abertura do shell Grunt.

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',');
 
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
 
grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

Então, usando o history comando irá produzir a seguinte saída.

grunt> history

customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(','); 
  
orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',');
   
student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',');

set Command

o set comando é usado para mostrar / atribuir valores às chaves usadas no Pig.

Usage

Usando este comando, você pode definir valores para as seguintes chaves.

Chave	Descrição e valores
default_parallel	Você pode definir o número de redutores para um trabalho de mapa passando qualquer número inteiro como um valor para esta chave.
debug	Você pode desligar ou ligar a freature de depuração no Pig passando on / off para esta chave.
job.name	Você pode definir o nome do trabalho para o trabalho necessário, passando um valor de string para esta chave.
job.priority	Você pode definir a prioridade do trabalho para um trabalho, passando um dos seguintes valores para esta chave - very_low low normal high very_high
stream.skippath	Para streaming, você pode definir o caminho de onde os dados não devem ser transferidos, passando o caminho desejado na forma de uma string para essa chave.

sair do comando

Você pode sair do shell Grunt usando este comando.

Usage

Saia do shell Grunt conforme mostrado abaixo.

grunt> quit

Vamos agora dar uma olhada nos comandos usando os quais você pode controlar o Apache Pig a partir do shell do Grunt.

Comando exec

Usando o exec comando, podemos executar scripts Pig a partir do shell Grunt.

Syntax

A seguir está a sintaxe do comando do utilitário exec.

grunt> exec [–param param_name = param_value] [–param_file file_name] [script]

Example

Vamos supor que haja um arquivo chamado student.txt no /pig_data/ diretório do HDFS com o seguinte conteúdo.

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

E, suponha que temos um arquivo de script chamado sample_script.pig no /pig_data/ diretório do HDFS com o seguinte conteúdo.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING PigStorage(',') 
   as (id:int,name:chararray,city:chararray);
  
Dump student;

Agora, vamos executar o script acima do shell Grunt usando o exec comando como mostrado abaixo.

grunt> exec /sample_script.pig

Output

o exec comando executa o script no sample_script.pig. Conforme indicado no script, ele carrega ostudent.txt arquivo no Pig e fornece o resultado do operador Dump exibindo o seguinte conteúdo.

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

comando matar

Você pode eliminar um trabalho do shell Grunt usando este comando.

Syntax

Dada a seguir é a sintaxe do kill comando.

grunt> kill JobId

Example

Suponha que haja um trabalho do Pig em execução com id Id_0055, você pode matá-lo do shell Grunt usando o kill comando, conforme mostrado abaixo.

grunt> kill Id_0055

comando de execução

Você pode executar um script Pig a partir do shell Grunt usando o run comando

Syntax

Dada a seguir é a sintaxe do run comando.

grunt> run [–param param_name = param_value] [–param_file file_name] script

Example

Vamos supor que haja um arquivo chamado student.txt no /pig_data/ diretório do HDFS com o seguinte conteúdo.

Student.txt

001,Rajiv,Hyderabad
002,siddarth,Kolkata
003,Rajesh,Delhi

E, suponha que temos um arquivo de script chamado sample_script.pig no sistema de arquivos local com o seguinte conteúdo.

Sample_script.pig

student = LOAD 'hdfs://localhost:9000/pig_data/student.txt' USING
   PigStorage(',') as (id:int,name:chararray,city:chararray);

Agora, vamos executar o script acima do shell Grunt usando o comando run, conforme mostrado abaixo.

grunt> run /sample_script.pig

Você pode ver a saída do script usando o Dump operator como mostrado abaixo.

grunt> Dump;

(1,Rajiv,Hyderabad)
(2,siddarth,Kolkata)
(3,Rajesh,Delhi)

Note - A diferença entre exec e a run comando é que se usarmos run, as instruções do script estão disponíveis no histórico de comandos.

Pig Latin é a linguagem usada para analisar dados no Hadoop usando o Apache Pig. Neste capítulo, vamos discutir os fundamentos do Pig Latin, como declarações do Pig Latin, tipos de dados, operadores gerais e relacionais e UDFs do Pig Latin.

Pig Latin - Modelo de Dados

Conforme discutido nos capítulos anteriores, o modelo de dados do Pig está totalmente aninhado. UMARelationé a estrutura mais externa do modelo de dados Pig Latin. E é umbag onde -

• Uma bolsa é uma coleção de tuplas.
• Uma tupla é um conjunto ordenado de campos.
• Um campo é um dado.

Pig Latin - Statemets

Durante o processamento de dados usando Pig Latin, statements são as construções básicas.

• Essas declarações funcionam com relations. Eles incluemexpressions e schemas.

• Cada instrução termina com um ponto e vírgula (;).

• Realizaremos diversas operações utilizando operadores disponibilizados pela Pig Latin, por meio de extratos.

• Exceto LOAD e STORE, ao executar todas as outras operações, as instruções do Pig Latin tomam uma relação como entrada e produzem outra relação como saída.

• Assim que você inserir um Loadno shell Grunt, sua verificação semântica será realizada. Para ver o conteúdo do esquema, você precisa usar oDumpoperador. Só depois de realizar odump operação, o trabalho MapReduce para carregar os dados no sistema de arquivos será executado.

Exemplo

A seguir, está uma instrução Pig Latin, que carrega dados no Apache Pig.

grunt> Student_data = LOAD 'student_data.txt' USING PigStorage(',')as 
   ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Pig Latin - Tipos de dados

A tabela abaixo descreve os tipos de dados do Pig Latin.

SN	Tipo de dados	Descrição e exemplo
1	int	Representa um número inteiro assinado de 32 bits. Example : 8
2	grandes	Representa um número inteiro assinado de 64 bits. Example : 5L
3	flutuador	Representa um ponto flutuante de 32 bits assinado. Example : 5.5F
4	em dobro	Representa um ponto flutuante de 64 bits. Example : 10,5
5	Chararray	Representa uma matriz de caracteres (string) no formato Unicode UTF-8. Example : 'tutorials point'
6	Bytearray	Representa uma matriz de bytes (blob).
7	boleano	Representa um valor booleano. Example : verdadeiro falso.
8	Data hora	Representa uma data e hora. Example : 1970-01-01T00: 00: 00.000 + 00: 00
9	Biginteger	Representa um Java BigInteger. Example : 60708090709
10	Bigdecimal	Representa um Java BigDecimal Example : 185.98376256272893883
Tipos Complexos
11	Tupla	Uma tupla é um conjunto ordenado de campos. Example : (rajá, 30)
12	Bolsa	Uma bolsa é uma coleção de tuplas. Example : {(raju, 30), (Mohhammad, 45)}
13	Mapa	Um mapa é um conjunto de pares de valores-chave. Example : ['nome' # 'Raju', 'idade' # 30]

Valores Nulos

Os valores para todos os tipos de dados acima podem ser NULL. O Apache Pig trata os valores nulos de maneira semelhante ao SQL.

Um nulo pode ser um valor desconhecido ou um valor inexistente. Ele é usado como um espaço reservado para valores opcionais. Esses nulos podem ocorrer naturalmente ou podem ser o resultado de uma operação.

Pig Latin - Operadores Aritméticos

A tabela a seguir descreve os operadores aritméticos do Pig Latin. Suponha que a = 10 e b = 20.

Operador	Descrição	Exemplo
+	Addition - Adiciona valores em ambos os lados do operador	a + b dará 30
-	Subtraction - Subtrai operando direito do operando esquerdo	a - b dará −10
*	Multiplication - Multiplica valores em ambos os lados do operador	a * b dará 200
/	Division - Divide operando esquerdo pelo operando direito	b / a dará 2
%	Modulus - Divide o operando do lado esquerdo pelo operando do lado direito e retorna o resto	b% a dará 0
? :	Bincond- Avalia os operadores booleanos. Possui três operandos, conforme mostrado a seguir. variável x = (expressão)? value1 se verdadeiro :value2 se falso .	b = (a == 1)? 20h30; se a = 1, o valor de b é 20. if a!=1 the value of b is 30.
CASE WHEN THEN ELSE END	Case − The case operator is equivalent to nested bincond operator.	CASE f2 % 2 WHEN 0 THEN 'even' WHEN 1 THEN 'odd' END

Pig Latin – Comparison Operators

The following table describes the comparison operators of Pig Latin.

Operator	Description	Example
==	Equal − Checks if the values of two operands are equal or not; if yes, then the condition becomes true.	(a = b) is not true
!=	Not Equal − Checks if the values of two operands are equal or not. If the values are not equal, then condition becomes true.	(a != b) is true.
>	Greater than − Checks if the value of the left operand is greater than the value of the right operand. If yes, then the condition becomes true.	(a > b) is not true.
<	Less than − Checks if the value of the left operand is less than the value of the right operand. If yes, then the condition becomes true.	(a < b) is true.
>=	Greater than or equal to − Checks if the value of the left operand is greater than or equal to the value of the right operand. If yes, then the condition becomes true.	(a >= b) is not true.
<=	Less than or equal to − Checks if the value of the left operand is less than or equal to the value of the right operand. If yes, then the condition becomes true.	(a <= b) is true.
matches	Pattern matching − Checks whether the string in the left-hand side matches with the constant in the right-hand side.	f1 matches '.*tutorial.*'

Pig Latin – Type Construction Operators

The following table describes the Type construction operators of Pig Latin.

Operator	Description	Example
()	Tuple constructor operator − This operator is used to construct a tuple.	(Raju, 30)
{}	Bag constructor operator − This operator is used to construct a bag.	{(Raju, 30), (Mohammad, 45)}
[]	Map constructor operator − This operator is used to construct a tuple.	[name#Raja, age#30]

Pig Latin – Relational Operations

The following table describes the relational operators of Pig Latin.

Operator	Description
Loading and Storing
LOAD	To Load the data from the file system (local/HDFS) into a relation.
STORE	To save a relation to the file system (local/HDFS).
Filtering
FILTER	To remove unwanted rows from a relation.
DISTINCT	To remove duplicate rows from a relation.
FOREACH, GENERATE	To generate data transformations based on columns of data.
STREAM	To transform a relation using an external program.
Grouping and Joining
JOIN	To join two or more relations.
COGROUP	To group the data in two or more relations.
GROUP	To group the data in a single relation.
CROSS	To create the cross product of two or more relations.
Sorting
ORDER	To arrange a relation in a sorted order based on one or more fields (ascending or descending).
LIMIT	To get a limited number of tuples from a relation.
Combining and Splitting
UNION	To combine two or more relations into a single relation.
SPLIT	To split a single relation into two or more relations.
Diagnostic Operators
DUMP	To print the contents of a relation on the console.
DESCRIBE	To describe the schema of a relation.
EXPLAIN	To view the logical, physical, or MapReduce execution plans to compute a relation.
ILLUSTRATE	To view the step-by-step execution of a series of statements.

In general, Apache Pig works on top of Hadoop. It is an analytical tool that analyzes large datasets that exist in the Hadoop File System. To analyze data using Apache Pig, we have to initially load the data into Apache Pig. This chapter explains how to load data to Apache Pig from HDFS.

Preparing HDFS

In MapReduce mode, Pig reads (loads) data from HDFS and stores the results back in HDFS. Therefore, let us start HDFS and create the following sample data in HDFS.

Student ID	First Name	Last Name	Phone	City
001	Rajiv	Reddy	9848022337	Hyderabad
002	siddarth	Battacharya	9848022338	Kolkata
003	Rajesh	Khanna	9848022339	Delhi
004	Preethi	Agarwal	9848022330	Pune
005	Trupthi	Mohanthy	9848022336	Bhuwaneshwar
006	Archana	Mishra	9848022335	Chennai

The above dataset contains personal details like id, first name, last name, phone number and city, of six students.

Step 1: Verifying Hadoop

First of all, verify the installation using Hadoop version command, as shown below.

$ hadoop version

If your system contains Hadoop, and if you have set the PATH variable, then you will get the following output −

Hadoop 2.6.0 
Subversion https://git-wip-us.apache.org/repos/asf/hadoop.git -r 
e3496499ecb8d220fba99dc5ed4c99c8f9e33bb1 
Compiled by jenkins on 2014-11-13T21:10Z 
Compiled with protoc 2.5.0 
From source with checksum 18e43357c8f927c0695f1e9522859d6a 
This command was run using /home/Hadoop/hadoop/share/hadoop/common/hadoop
common-2.6.0.jar

Step 2: Starting HDFS

Browse through the sbin directory of Hadoop and start yarn and Hadoop dfs (distributed file system) as shown below.

cd /$Hadoop_Home/sbin/ 
$ start-dfs.sh 
localhost: starting namenode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-namenode-localhost.localdomain.out 
localhost: starting datanode, logging to /home/Hadoop/hadoop/logs/hadoopHadoop-datanode-localhost.localdomain.out 
Starting secondary namenodes [0.0.0.0] 
starting secondarynamenode, logging to /home/Hadoop/hadoop/logs/hadoop-Hadoopsecondarynamenode-localhost.localdomain.out
 
$ start-yarn.sh 
starting yarn daemons 
starting resourcemanager, logging to /home/Hadoop/hadoop/logs/yarn-Hadoopresourcemanager-localhost.localdomain.out 
localhost: starting nodemanager, logging to /home/Hadoop/hadoop/logs/yarnHadoop-nodemanager-localhost.localdomain.out

Step 3: Create a Directory in HDFS

In Hadoop DFS, you can create directories using the command mkdir. Create a new directory in HDFS with the name Pig_Data in the required path as shown below.

$cd /$Hadoop_Home/bin/ 
$ hdfs dfs -mkdir hdfs://localhost:9000/Pig_Data

Step 4: Placing the data in HDFS

The input file of Pig contains each tuple/record in individual lines. And the entities of the record are separated by a delimiter (In our example we used “,”).

In the local file system, create an input file student_data.txt containing data as shown below.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

Now, move the file from the local file system to HDFS using put command as shown below. (You can use copyFromLocal command as well.)

$ cd $HADOOP_HOME/bin $ hdfs dfs -put /home/Hadoop/Pig/Pig_Data/student_data.txt dfs://localhost:9000/pig_data/

Verifying the file

You can use the cat command to verify whether the file has been moved into the HDFS, as shown below.

$ cd $HADOOP_HOME/bin
$ hdfs dfs -cat hdfs://localhost:9000/pig_data/student_data.txt

Output

You can see the content of the file as shown below.

15/10/01 12:16:55 WARN util.NativeCodeLoader: Unable to load native-hadoop
library for your platform... using builtin-java classes where applicable
  
001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai

The Load Operator

You can load data into Apache Pig from the file system (HDFS/ Local) using LOAD operator of Pig Latin.

Syntax

The load statement consists of two parts divided by the “=” operator. On the left-hand side, we need to mention the name of the relation where we want to store the data, and on the right-hand side, we have to define how we store the data. Given below is the syntax of the Load operator.

Relation_name = LOAD 'Input file path' USING function as schema;

Where,

• relation_name − We have to mention the relation in which we want to store the data.

• Input file path − We have to mention the HDFS directory where the file is stored. (In MapReduce mode)

• function − We have to choose a function from the set of load functions provided by Apache Pig (BinStorage, JsonLoader, PigStorage, TextLoader).

• Schema − We have to define the schema of the data. We can define the required schema as follows −

(column1 : data type, column2 : data type, column3 : data type);

Note − We load the data without specifying the schema. In that case, the columns will be addressed as $01, $02, etc… (check).

Example

As an example, let us load the data in student_data.txt in Pig under the schema named Student using the LOAD command.

Start the Pig Grunt Shell

First of all, open the Linux terminal. Start the Pig Grunt shell in MapReduce mode as shown below.

$ Pig –x mapreduce

It will start the Pig Grunt shell as shown below.

15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : LOCAL
15/10/01 12:33:37 INFO pig.ExecTypeProvider: Trying ExecType : MAPREDUCE
15/10/01 12:33:37 INFO pig.ExecTypeProvider: Picked MAPREDUCE as the ExecType

2015-10-01 12:33:38,080 [main] INFO  org.apache.pig.Main - Apache Pig version 0.15.0 (r1682971) compiled Jun 01 2015, 11:44:35
2015-10-01 12:33:38,080 [main] INFO  org.apache.pig.Main - Logging error messages to: /home/Hadoop/pig_1443683018078.log
2015-10-01 12:33:38,242 [main] INFO  org.apache.pig.impl.util.Utils - Default bootup file /home/Hadoop/.pigbootup not found
  
2015-10-01 12:33:39,630 [main]
INFO org.apache.pig.backend.hadoop.executionengine.HExecutionEngine - Connecting to hadoop file system at: hdfs://localhost:9000
 
grunt>

Execute a declaração de carga

Agora carregue os dados do arquivo student_data.txt no Pig executando a seguinte instrução Pig Latin no shell Grunt.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

A seguir está a descrição da declaração acima.

Nome da relação	Nós armazenamos os dados no esquema student.
Caminho do arquivo de entrada	Estamos lendo dados do arquivo student_data.txt, que está no diretório / pig_data / do HDFS.
Função de armazenamento	Nós usamos o PigStorage()função. Ele carrega e armazena dados como arquivos de texto estruturados. Leva um delimitador usando o qual cada entidade de uma tupla é separada, como um parâmetro. Por padrão, leva '\ t' como parâmetro.
esquema	Armazenamos os dados usando o seguinte esquema. coluna Eu iria primeiro nome último nome telefone cidade tipo de dados int matriz char matriz char matriz char matriz char

Note - o loaddeclaração simplesmente carregará os dados na relação especificada no Pig. Para verificar a execução doLoad declaração, você tem que usar o Diagnostic Operators que são discutidos nos próximos capítulos.

No capítulo anterior, aprendemos como carregar dados no Apache Pig. Você pode armazenar os dados carregados no sistema de arquivos usando ostoreoperador. Este capítulo explica como armazenar dados no Apache Pig usando oStore operador.

Sintaxe

A seguir está a sintaxe da instrução Store.

STORE Relation_name INTO ' required_directory_path ' [USING function];

Exemplo

Suponha que temos um arquivo student_data.txt em HDFS com o seguinte conteúdo.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

E nós lemos isso em uma relação student usando o operador LOAD conforme mostrado abaixo.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

Agora, vamos armazenar a relação no diretório HDFS “/pig_Output/” como mostrado abaixo.

grunt> STORE student INTO ' hdfs://localhost:9000/pig_Output/ ' USING PigStorage (',');

Resultado

Depois de executar o storedeclaração, você obterá a seguinte saída. Um diretório é criado com o nome especificado e os dados serão armazenados nele.

2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MapReduceLau ncher - 100% complete
2015-10-05 13:05:05,429 [main] INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - 
Script Statistics:
   
HadoopVersion    PigVersion    UserId    StartedAt             FinishedAt             Features 
2.6.0            0.15.0        Hadoop    2015-10-0 13:03:03    2015-10-05 13:05:05    UNKNOWN  
Success!  
Job Stats (time in seconds): 
JobId          Maps    Reduces    MaxMapTime    MinMapTime    AvgMapTime    MedianMapTime    
job_14459_06    1        0           n/a           n/a           n/a           n/a
MaxReduceTime    MinReduceTime    AvgReduceTime    MedianReducetime    Alias    Feature   
     0                 0                0                0             student  MAP_ONLY 
OutPut folder
hdfs://localhost:9000/pig_Output/ 
 
Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/student_data.txt"  
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/pig_Output"  
Counters:
Total records written : 0
Total bytes written : 0
Spillable Memory Manager spill count : 0 
Total bags proactively spilled: 0
Total records proactively spilled: 0
  
Job DAG: job_1443519499159_0006
  
2015-10-05 13:06:06,192 [main] INFO  org.apache.pig.backend.hadoop.executionengine
.mapReduceLayer.MapReduceLau ncher - Success!

Verificação

Você pode verificar os dados armazenados conforme mostrado abaixo.

Passo 1

Primeiro de tudo, liste os arquivos no diretório chamado pig_output usando o ls comando como mostrado abaixo.

hdfs dfs -ls 'hdfs://localhost:9000/pig_Output/'
Found 2 items
rw-r--r-   1 Hadoop supergroup          0 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/_SUCCESS
rw-r--r-   1 Hadoop supergroup        224 2015-10-05 13:03 hdfs://localhost:9000/pig_Output/part-m-00000

Você pode observar que dois arquivos foram criados após a execução do store declaração.

Passo 2

Usando cat comando, liste o conteúdo do arquivo chamado part-m-00000 como mostrado abaixo.

$ hdfs dfs -cat 'hdfs://localhost:9000/pig_Output/part-m-00000' 
1,Rajiv,Reddy,9848022337,Hyderabad
2,siddarth,Battacharya,9848022338,Kolkata
3,Rajesh,Khanna,9848022339,Delhi
4,Preethi,Agarwal,9848022330,Pune
5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
6,Archana,Mishra,9848022335,Chennai

o loaddeclaração simplesmente carregará os dados na relação especificada no Apache Pig. Para verificar a execução doLoad declaração, você tem que usar o Diagnostic Operators. Pig Latin oferece quatro tipos diferentes de operadores de diagnóstico -

• Operador de despejo
• Descrever operador
• Operador de explicação
• Operador de ilustração

Neste capítulo, discutiremos os operadores Dump do Pig Latin.

Operador de despejo

o Dumpoperador é usado para executar as instruções do Pig Latin e exibir os resultados na tela. Geralmente é usado para fins de depuração.

Sintaxe

Dada a seguir é a sintaxe do Dump operador.

grunt> Dump Relation_Name

Exemplo

Suponha que temos um arquivo student_data.txt em HDFS com o seguinte conteúdo.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

E nós lemos isso em uma relação student usando o operador LOAD conforme mostrado abaixo.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' 
   USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, 
   city:chararray );

Agora, vamos imprimir o conteúdo da relação usando o Dump operator como mostrado abaixo.

grunt> Dump student

Depois de executar o acima Pig Latin, ele iniciará um trabalho MapReduce para ler dados do HDFS. Ele produzirá a seguinte saída.

2015-10-01 15:05:27,642 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLauncher - 
100% complete
2015-10-01 15:05:27,652 [main]
INFO  org.apache.pig.tools.pigstats.mapreduce.SimplePigStats - Script Statistics:   
HadoopVersion  PigVersion  UserId    StartedAt             FinishedAt       Features             
2.6.0          0.15.0      Hadoop  2015-10-01 15:03:11  2015-10-01 05:27     UNKNOWN
                                                
Success!  
Job Stats (time in seconds):
  
JobId           job_14459_0004
Maps                 1  
Reduces              0  
MaxMapTime          n/a    
MinMapTime          n/a
AvgMapTime          n/a 
MedianMapTime       n/a
MaxReduceTime        0
MinReduceTime        0  
AvgReduceTime        0
MedianReducetime     0
Alias             student 
Feature           MAP_ONLY        
Outputs           hdfs://localhost:9000/tmp/temp580182027/tmp757878456,

Input(s): Successfully read 0 records from: "hdfs://localhost:9000/pig_data/
student_data.txt"
  
Output(s): Successfully stored 0 records in: "hdfs://localhost:9000/tmp/temp580182027/
tmp757878456"  

Counters: Total records written : 0 Total bytes written : 0 Spillable Memory Manager 
spill count : 0Total bags proactively spilled: 0 Total records proactively spilled: 0  

Job DAG: job_1443519499159_0004
  
2015-10-01 15:06:28,403 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MapReduceLau ncher - Success!
2015-10-01 15:06:28,441 [main] INFO  org.apache.pig.data.SchemaTupleBackend - 
Key [pig.schematuple] was not set... will not generate code.
2015-10-01 15:06:28,485 [main]
INFO  org.apache.hadoop.mapreduce.lib.input.FileInputFormat - Total input paths 
to process : 1
2015-10-01 15:06:28,485 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.util.MapRedUtil - Total input paths
to process : 1

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata) (3,Rajesh,Khanna,9848022339,Delhi) (4,Preethi,Agarwal,9848022330,Pune) (5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar) (6,Archana,Mishra,9848022335,Chennai)

o describe operador é usado para visualizar o esquema de uma relação.

Sintaxe

A sintaxe do describe operador é o seguinte -

grunt> Describe Relation_name

Exemplo

Suponha que temos um arquivo student_data.txt em HDFS com o seguinte conteúdo.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

E nós lemos isso em uma relação student usando o operador LOAD conforme mostrado abaixo.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Agora, vamos descrever a relação chamada student e verifique o esquema conforme mostrado abaixo.

grunt> describe student;

Resultado

Depois de executar o acima Pig Latin declaração, ele produzirá a seguinte saída.

grunt> student: { id: int,firstname: chararray,lastname: chararray,phone: chararray,city: chararray }

o explain operador é usado para exibir os planos de execução lógico, físico e MapReduce de uma relação.

Sintaxe

Dada a seguir é a sintaxe do explain operador.

grunt> explain Relation_name;

Exemplo

Suponha que temos um arquivo student_data.txt em HDFS com o seguinte conteúdo.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

E nós lemos isso em uma relação student usando o operador LOAD conforme mostrado abaixo.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Agora, vamos explicar a relação chamada aluno usando o explain operador como mostrado abaixo.

grunt> explain student;

Resultado

Ele produzirá a seguinte saída.

$ explain student;

2015-10-05 11:32:43,660 [main]
2015-10-05 11:32:43,660 [main] INFO  org.apache.pig.newplan.logical.optimizer
.LogicalPlanOptimizer -
{RULES_ENABLED=[AddForEach, ColumnMapKeyPrune, ConstantCalculator,
GroupByConstParallelSetter, LimitOptimizer, LoadTypeCastInserter, MergeFilter, 
MergeForEach, PartitionFilterOptimizer, PredicatePushdownOptimizer,
PushDownForEachFlatten, PushUpFilter, SplitFilter, StreamTypeCastInserter]}  
#-----------------------------------------------
# New Logical Plan: 
#-----------------------------------------------
student: (Name: LOStore Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
| 
|---student: (Name: LOForEach Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)
    |   |
    |   (Name: LOGenerate[false,false,false,false,false] Schema:
id#31:int,firstname#32:chararray,lastname#33:chararray,phone#34:chararray,city#
35:chararray)ColumnPrune:InputUids=[34, 35, 32, 33,
31]ColumnPrune:OutputUids=[34, 35, 32, 33, 31]
    |   |   | 
    |   |   (Name: Cast Type: int Uid: 31) 
    |   |   |     |   |   |---id:(Name: Project Type: bytearray Uid: 31 Input: 0 Column: (*))
    |   |   |     
    |   |   (Name: Cast Type: chararray Uid: 32)
    |   |   | 
    |   |   |---firstname:(Name: Project Type: bytearray Uid: 32 Input: 1
Column: (*))
    |   |   |
    |   |   (Name: Cast Type: chararray Uid: 33)
    |   |   |
    |   |   |---lastname:(Name: Project Type: bytearray Uid: 33 Input: 2
	 Column: (*))
    |   |   | 
    |   |   (Name: Cast Type: chararray Uid: 34)
    |   |   |  
    |   |   |---phone:(Name: Project Type: bytearray Uid: 34 Input: 3 Column:
(*))
    |   |   | 
    |   |   (Name: Cast Type: chararray Uid: 35)
    |   |   |  
    |   |   |---city:(Name: Project Type: bytearray Uid: 35 Input: 4 Column:
(*))
    |   | 
    |   |---(Name: LOInnerLoad[0] Schema: id#31:bytearray)
    |   |  
    |   |---(Name: LOInnerLoad[1] Schema: firstname#32:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[2] Schema: lastname#33:bytearray)
    |   |
    |   |---(Name: LOInnerLoad[3] Schema: phone#34:bytearray)
    |   | 
    |   |---(Name: LOInnerLoad[4] Schema: city#35:bytearray)
    |
    |---student: (Name: LOLoad Schema: 
id#31:bytearray,firstname#32:bytearray,lastname#33:bytearray,phone#34:bytearray
,city#35:bytearray)RequiredFields:null 
#-----------------------------------------------
# Physical Plan: #-----------------------------------------------
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
| 
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |  
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   | 
    |   Cast[chararray] - scope-27
    |   |  
    |   |---Project[bytearray][2] - scope-26 
    |   |  
    |   Cast[chararray] - scope-30 
    |   |  
    |   |---Project[bytearray][3] - scope-29
    |   |
    |   Cast[chararray] - scope-33
    |   | 
    |   |---Project[bytearray][4] - scope-32
    | 
    |---student: Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope19
2015-10-05 11:32:43,682 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MRCompiler - 
File concatenation threshold: 100 optimistic? false
2015-10-05 11:32:43,684 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.MultiQueryOp timizer - 
MR plan size before optimization: 1 2015-10-05 11:32:43,685 [main]
INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.
MultiQueryOp timizer - MR plan size after optimization: 1 
#--------------------------------------------------
# Map Reduce Plan                                   
#--------------------------------------------------
MapReduce node scope-37
Map Plan
student: Store(fakefile:org.apache.pig.builtin.PigStorage) - scope-36
|
|---student: New For Each(false,false,false,false,false)[bag] - scope-35
    |   |
    |   Cast[int] - scope-21 
    |   |
    |   |---Project[bytearray][0] - scope-20
    |   |
    |   Cast[chararray] - scope-24
    |   |
    |   |---Project[bytearray][1] - scope-23
    |   |
    |   Cast[chararray] - scope-27
    |   | 
    |   |---Project[bytearray][2] - scope-26 
    |   | 
    |   Cast[chararray] - scope-30 
    |   |  
    |   |---Project[bytearray][3] - scope-29 
    |   | 
    |   Cast[chararray] - scope-33
    |   | 
    |   |---Project[bytearray][4] - scope-32 
    |  
    |---student:
Load(hdfs://localhost:9000/pig_data/student_data.txt:PigStorage(',')) - scope
19-------- Global sort: false
 ----------------

o illustrate operador fornece a execução passo a passo de uma sequência de instruções.

Sintaxe

Dada a seguir é a sintaxe do illustrate operador.

grunt> illustrate Relation_name;

Exemplo

Suponha que temos um arquivo student_data.txt em HDFS com o seguinte conteúdo.

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata 
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune 
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

E nós lemos isso em uma relação student usando o operador LOAD conforme mostrado abaixo.

grunt> student = LOAD 'hdfs://localhost:9000/pig_data/student_data.txt' USING PigStorage(',')
   as ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );

Agora, vamos ilustrar a relação denominada aluno conforme mostrado abaixo.

grunt> illustrate student;

Resultado

Ao executar a instrução acima, você obterá a seguinte saída.

grunt> illustrate student;

INFO  org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigMapOnly$M ap - Aliases
being processed per job phase (AliasName[line,offset]): M: student[1,10] C:  R:
---------------------------------------------------------------------------------------------
|student | id:int | firstname:chararray | lastname:chararray | phone:chararray | city:chararray |
--------------------------------------------------------------------------------------------- 
|        | 002    | siddarth            | Battacharya        | 9848022338      | Kolkata        |
---------------------------------------------------------------------------------------------

o GROUPoperador é usado para agrupar os dados em uma ou mais relações. Ele coleta os dados com a mesma chave.

Sintaxe

Dada a seguir é a sintaxe do group operador.

grunt> Group_data = GROUP Relation_name BY age;

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Apache Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

Agora, vamos agrupar os registros / tuplas na relação por idade, conforme mostrado abaixo.

grunt> group_data = GROUP student_details by age;

Verificação

Verifique a relação group_data usando o DUMP operador como mostrado abaixo.

grunt> Dump group_data;

Resultado

Então você obterá uma saída exibindo o conteúdo da relação nomeada group_datacomo mostrado abaixo. Aqui você pode observar que o esquema resultante tem duas colunas -

• Um é age, pelo qual agrupamos a relação.

• O outro é um bag, que contém o grupo de tuplas, registros do aluno com a respectiva idade.

(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})
(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233 8,Kolkata)})
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)})

Você pode ver o esquema da tabela depois de agrupar os dados usando o describe comando como mostrado abaixo.

grunt> Describe group_data;
  
group_data: {group: int,student_details: {(id: int,firstname: chararray,
               lastname: chararray,age: int,phone: chararray,city: chararray)}}

Da mesma forma, você pode obter a ilustração de amostra do esquema usando o illustrate comando como mostrado abaixo.

$ Illustrate group_data;

Ele produzirá a seguinte saída -

------------------------------------------------------------------------------------------------- 
|group_data|  group:int | student_details:bag{:tuple(id:int,firstname:chararray,lastname:chararray,age:int,phone:chararray,city:chararray)}|
------------------------------------------------------------------------------------------------- 
|          |     21     | { 4, Preethi, Agarwal, 21, 9848022330, Pune), (1, Rajiv, Reddy, 21, 9848022337, Hyderabad)}| 
|          |     2      | {(2,siddarth,Battacharya,22,9848022338,Kolkata),(003,Rajesh,Khanna,22,9848022339,Delhi)}| 
-------------------------------------------------------------------------------------------------

Agrupamento por múltiplas colunas

Vamos agrupar a relação por idade e cidade como mostrado abaixo.

grunt> group_multiple = GROUP student_details by (age, city);

Você pode verificar o conteúdo da relação nomeada group_multiple usando o operador Dump conforme mostrado abaixo.

grunt> Dump group_multiple; 
  
((21,Pune),{(4,Preethi,Agarwal,21,9848022330,Pune)})
((21,Hyderabad),{(1,Rajiv,Reddy,21,9848022337,Hyderabad)})
((22,Delhi),{(3,Rajesh,Khanna,22,9848022339,Delhi)})
((22,Kolkata),{(2,siddarth,Battacharya,22,9848022338,Kolkata)})
((23,Chennai),{(6,Archana,Mishra,23,9848022335,Chennai)})
((23,Bhuwaneshwar),{(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)})
((24,Chennai),{(8,Bharathi,Nambiayar,24,9848022333,Chennai)})
(24,trivendram),{(7,Komal,Nayak,24,9848022334,trivendram)})

Grupo Tudo

Você pode agrupar uma relação por todas as colunas como mostrado abaixo.

grunt> group_all = GROUP student_details All;

Agora, verifique o conteúdo da relação group_all como mostrado abaixo.

grunt> Dump group_all;  
  
(all,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334 ,trivendram), 
(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336,Bhuw aneshwar), 
(4,Preethi,Agarwal,21,9848022330,Pune),(3,Rajesh,Khanna,22,9848022339,Delhi), 
(2,siddarth,Battacharya,22,9848022338,Kolkata),(1,Rajiv,Reddy,21,9848022337,Hyd erabad)})

o COGROUPoperador funciona mais ou menos da mesma maneira que o operador GRUPO . A única diferença entre os dois operadores é que ogroup operador é normalmente usado com uma relação, enquanto o cogroup operador é usado em declarações envolvendo duas ou mais relações.

Agrupando Duas Relações Usando Cogrupo

Suponha que temos dois arquivos, a saber student_details.txt e employee_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai

employee_details.txt

001,Robin,22,newyork 
002,BOB,23,Kolkata 
003,Maya,23,Tokyo 
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai

E carregamos esses arquivos no Pig com os nomes das relações student_details e employee_details respectivamente, conforme mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray); 
  
grunt> employee_details = LOAD 'hdfs://localhost:9000/pig_data/employee_details.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

Agora, vamos agrupar os registros / tuplas das relações student_details e employee_details com a idade da chave, conforme mostrado abaixo.

grunt> cogroup_data = COGROUP student_details by age, employee_details by age;

Verificação

Verifique a relação cogroup_data usando o DUMP operador como mostrado abaixo.

grunt> Dump cogroup_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação nomeada cogroup_data como mostrado abaixo.

(21,{(4,Preethi,Agarwal,21,9848022330,Pune), (1,Rajiv,Reddy,21,9848022337,Hyderabad)}, 
   {    })  
(22,{ (3,Rajesh,Khanna,22,9848022339,Delhi), (2,siddarth,Battacharya,22,9848022338,Kolkata) },  
   { (6,Maggy,22,Chennai),(1,Robin,22,newyork) })  
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336 ,Bhuwaneshwar)}, 
   {(5,David,23,Bhuwaneshwar),(3,Maya,23,Tokyo),(2,BOB,23,Kolkata)}) 
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334, trivendram)}, 
   { })  
(25,{   }, 
   {(4,Sara,25,London)})

o cogroup operador agrupa as tuplas de cada relação de acordo com a idade, onde cada grupo representa um valor de idade particular.

Por exemplo, se considerarmos a 1ª tupla do resultado, ela é agrupada pela idade de 21 anos. E contém duas bolsas -

• o primeiro saco contém todas as tuplas da primeira relação (student_details neste caso) ter 21 anos e

• o segundo saco contém todas as tuplas da segunda relação (employee_details neste caso) ter 21 anos.

Caso uma relação não possua tuplas com o valor de idade 21, ela retorna um saco vazio.

o JOINoperador é usado para combinar registros de duas ou mais relações. Ao realizar uma operação de junção, declaramos uma (ou um grupo de) tuplas de cada relação como chaves. Quando essas chaves correspondem, as duas tuplas específicas são correspondidas, caso contrário, os registros são eliminados. As junções podem ser dos seguintes tipos -

• Self-join
• Inner-join
• Junção externa - junção à esquerda, junção à direita e junção completa

Este capítulo explica com exemplos como usar o operador join no Pig Latin. Suponha que temos dois arquivos, a sabercustomers.txt e orders.txt no /pig_data/ diretório do HDFS conforme mostrado abaixo.

customers.txt

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

orders.txt

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

E carregamos esses dois arquivos no Pig com as relações customers e orders como mostrado abaixo.

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

Vamos agora realizar várias operações de junção nessas duas relações.

Auto-adesão

Self-join é usado para unir uma tabela consigo mesma como se a tabela fosse duas relações, renomeando temporariamente pelo menos uma relação.

Geralmente, no Apache Pig, para realizar a autojunção, carregaremos os mesmos dados várias vezes, sob diferentes aliases (nomes). Portanto, vamos carregar o conteúdo do arquivocustomers.txt como duas tabelas, conforme mostrado abaixo.

grunt> customers1 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> customers2 = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);

Sintaxe

Dada a seguir está a sintaxe de desempenho self-join operação usando o JOIN operador.

grunt> Relation3_name = JOIN Relation1_name BY key, Relation2_name BY key ;

Exemplo

Vamos realizar self-join operação na relação customers, juntando as duas relações customers1 e customers2 como mostrado abaixo.

grunt> customers3 = JOIN customers1 BY id, customers2 BY id;

Verificação

Verifique a relação customers3 usando o DUMP operador como mostrado abaixo.

grunt> Dump customers3;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação customers.

(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000)
(2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500)
(3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000)
(4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500)
(5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500)
(6,Komal,22,MP,4500,6,Komal,22,MP,4500)
(7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)

Junção interna

Inner Joiné usado com bastante frequência; também é conhecido comoequijoin. Uma junção interna retorna linhas quando há uma correspondência em ambas as tabelas.

Ele cria uma nova relação combinando valores de coluna de duas relações (digamos A e B) com base no predicado de junção. A consulta compara cada linha de A com cada linha de B para encontrar todos os pares de linhas que satisfazem o predicado de junção. Quando o predicado de junção é satisfeito, os valores da coluna para cada par de linhas correspondentes de A e B são combinados em uma linha de resultado.

Sintaxe

Aqui está a sintaxe de execução inner join operação usando o JOIN operador.

grunt> result = JOIN relation1 BY columnname, relation2 BY columnname;

Exemplo

Vamos realizar inner join operação nas duas relações customers e orders como mostrado abaixo.

grunt> coustomer_orders = JOIN customers BY id, orders BY customer_id;

Verificação

Verifique a relação coustomer_orders usando o DUMP operador como mostrado abaixo.

grunt> Dump coustomer_orders;

Resultado

Você obterá a seguinte saída que será o conteúdo da relação chamada coustomer_orders.

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

Note -

União externa : ao contrário da união interna,outer joinretorna todas as linhas de pelo menos uma das relações. Uma operação de junção externa é realizada de três maneiras -

• Junção externa esquerda
• Junção externa direita
• Junção externa completa

União Externa Esquerda

o left outer Join operação retorna todas as linhas da tabela esquerda, mesmo se não houver correspondências na relação direita.

Sintaxe

Dada a seguir está a sintaxe de desempenho left outer join operação usando o JOIN operador.

grunt> Relation3_name = JOIN Relation1_name BY id LEFT OUTER, Relation2_name BY customer_id;

Exemplo

Vamos realizar a operação left outer join nos dois clientes de relacionamento e pedidos, conforme mostrado abaixo.

grunt> outer_left = JOIN customers BY id LEFT OUTER, orders BY customer_id;

Verificação

Verifique a relação outer_left usando o DUMP operador como mostrado abaixo.

grunt> Dump outer_left;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação outer_left.

(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)

Junção Externa Direita

o right outer join operação retorna todas as linhas da tabela direita, mesmo se não houver correspondências na tabela esquerda.

Sintaxe

Dada a seguir está a sintaxe de desempenho right outer join operação usando o JOIN operador.

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

Exemplo

Vamos realizar right outer join operação nas duas relações customers e orders como mostrado abaixo.

grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;

Verificação

Verifique a relação outer_right usando o DUMP operador como mostrado abaixo.

grunt> Dump outer_right

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação outer_right.

(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)

Full Outer Join

o full outer join operação retorna linhas quando há uma correspondência em uma das relações.

Sintaxe

Dada a seguir está a sintaxe de desempenho full outer join usando o JOIN operador.

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

Exemplo

Vamos realizar full outer join operação nas duas relações customers e orders como mostrado abaixo.

grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;

Verificação

Verifique a relação outer_full usando o DUMP operador como mostrado abaixo.

grun> Dump outer_full;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação outer_full.

(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)

Usando Chaves Múltiplas

Podemos realizar a operação JOIN usando várias teclas.

Sintaxe

Aqui está como você pode executar uma operação JOIN em duas tabelas usando várias teclas.

grunt> Relation3_name = JOIN Relation2_name BY (key1, key2), Relation3_name BY (key1, key2);

Suponha que temos dois arquivos, a saber employee.txt e employee_contact.txt no /pig_data/ diretório do HDFS conforme mostrado abaixo.

employee.txt

001,Rajiv,Reddy,21,programmer,003
002,siddarth,Battacharya,22,programmer,003
003,Rajesh,Khanna,22,programmer,003
004,Preethi,Agarwal,21,programmer,003
005,Trupthi,Mohanthy,23,programmer,003
006,Archana,Mishra,23,programmer,003
007,Komal,Nayak,24,teamlead,002
008,Bharathi,Nambiayar,24,manager,001

employee_contact.txt

001,9848022337,[email protected],Hyderabad,003
002,9848022338,[email protected],Kolkata,003
003,9848022339,[email protected],Delhi,003
004,9848022330,[email protected],Pune,003
005,9848022336,[email protected],Bhuwaneshwar,003
006,9848022335,[email protected],Chennai,003
007,9848022334,[email protected],trivendram,002
008,9848022333,[email protected],Chennai,001

E carregamos esses dois arquivos no Pig com relações employee e employee_contact como mostrado abaixo.

grunt> employee = LOAD 'hdfs://localhost:9000/pig_data/employee.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, designation:chararray, jobid:int);
  
grunt> employee_contact = LOAD 'hdfs://localhost:9000/pig_data/employee_contact.txt' USING PigStorage(',') 
   as (id:int, phone:chararray, email:chararray, city:chararray, jobid:int);

Agora, vamos juntar o conteúdo dessas duas relações usando o JOIN operador como mostrado abaixo.

grunt> emp = JOIN employee BY (id,jobid), employee_contact BY (id,jobid);

Verificação

Verifique a relação emp usando o DUMP operador como mostrado abaixo.

grunt> Dump emp;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação nomeada emp como mostrado abaixo.

(1,Rajiv,Reddy,21,programmer,113,1,9848022337,[email protected],Hyderabad,113)
(2,siddarth,Battacharya,22,programmer,113,2,9848022338,[email protected],Kolka ta,113)  
(3,Rajesh,Khanna,22,programmer,113,3,9848022339,[email protected],Delhi,113)  
(4,Preethi,Agarwal,21,programmer,113,4,9848022330,[email protected],Pune,113)  
(5,Trupthi,Mohanthy,23,programmer,113,5,9848022336,[email protected],Bhuwaneshw ar,113)  
(6,Archana,Mishra,23,programmer,113,6,9848022335,[email protected],Chennai,113)  
(7,Komal,Nayak,24,teamlead,112,7,9848022334,[email protected],trivendram,112)  
(8,Bharathi,Nambiayar,24,manager,111,8,9848022333,[email protected],Chennai,111)

o CROSSoperador calcula o produto cruzado de duas ou mais relações. Este capítulo explica com um exemplo de como usar o operador cruzado no Pig Latin.

Sintaxe

Dada a seguir é a sintaxe do CROSS operador.

grunt> Relation3_name = CROSS Relation1_name, Relation2_name;

Exemplo

Suponha que temos dois arquivos, a saber customers.txt e orders.txt no /pig_data/ diretório do HDFS conforme mostrado abaixo.

customers.txt

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

orders.txt

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

E carregamos esses dois arquivos no Pig com as relações customers e orders como mostrado abaixo.

grunt> customers = LOAD 'hdfs://localhost:9000/pig_data/customers.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, address:chararray, salary:int);
  
grunt> orders = LOAD 'hdfs://localhost:9000/pig_data/orders.txt' USING PigStorage(',')
   as (oid:int, date:chararray, customer_id:int, amount:int);

Vamos agora obter o produto cruzado dessas duas relações usando o cross operador nessas duas relações, conforme mostrado abaixo.

grunt> cross_data = CROSS customers, orders;

Verificação

Verifique a relação cross_data usando o DUMP operador como mostrado abaixo.

grunt> Dump cross_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação cross_data.

(7,Muffy,24,Indore,10000,103,2008-05-20 00:00:00,4,2060) 
(7,Muffy,24,Indore,10000,101,2009-11-20 00:00:00,2,1560) 
(7,Muffy,24,Indore,10000,100,2009-10-08 00:00:00,3,1500) 
(7,Muffy,24,Indore,10000,102,2009-10-08 00:00:00,3,3000) 
(6,Komal,22,MP,4500,103,2008-05-20 00:00:00,4,2060) 
(6,Komal,22,MP,4500,101,2009-11-20 00:00:00,2,1560) 
(6,Komal,22,MP,4500,100,2009-10-08 00:00:00,3,1500) 
(6,Komal,22,MP,4500,102,2009-10-08 00:00:00,3,3000) 
(5,Hardik,27,Bhopal,8500,103,2008-05-20 00:00:00,4,2060) 
(5,Hardik,27,Bhopal,8500,101,2009-11-20 00:00:00,2,1560) 
(5,Hardik,27,Bhopal,8500,100,2009-10-08 00:00:00,3,1500) 
(5,Hardik,27,Bhopal,8500,102,2009-10-08 00:00:00,3,3000) 
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060) 
(4,Chaitali,25,Mumbai,6500,101,2009-20 00:00:00,4,2060) 
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) 
(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500) 
(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) 
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) 
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) 
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) 
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)-11-20 00:00:00,2,1560) 
(4,Chaitali,25,Mumbai,6500,100,2009-10-08 00:00:00,3,1500) 
(4,Chaitali,25,Mumbai,6500,102,2009-10-08 00:00:00,3,3000) 
(3,kaushik,23,Kota,2000,103,2008-05-20 00:00:00,4,2060) 
(3,kaushik,23,Kota,2000,101,2009-11-20 00:00:00,2,1560) 
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500) 
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000) 
(2,Khilan,25,Delhi,1500,103,2008-05-20 00:00:00,4,2060) 
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560) 
(2,Khilan,25,Delhi,1500,100,2009-10-08 00:00:00,3,1500)
(2,Khilan,25,Delhi,1500,102,2009-10-08 00:00:00,3,3000) 
(1,Ramesh,32,Ahmedabad,2000,103,2008-05-20 00:00:00,4,2060) 
(1,Ramesh,32,Ahmedabad,2000,101,2009-11-20 00:00:00,2,1560) 
(1,Ramesh,32,Ahmedabad,2000,100,2009-10-08 00:00:00,3,1500) 
(1,Ramesh,32,Ahmedabad,2000,102,2009-10-08 00:00:00,3,3000)

o UNIONoperador de Pig Latin é usado para mesclar o conteúdo de duas relações. Para realizar a operação UNION em duas relações, suas colunas e domínios devem ser idênticos.

Sintaxe

Dada a seguir é a sintaxe do UNION operador.

grunt> Relation_name3 = UNION Relation_name1, Relation_name2;

Exemplo

Suponha que temos dois arquivos, a saber student_data1.txt e student_data2.txt no /pig_data/ diretório do HDFS conforme mostrado abaixo.

Student_data1.txt

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai.

Student_data2.txt

7,Komal,Nayak,9848022334,trivendram.
8,Bharathi,Nambiayar,9848022333,Chennai.

E carregamos esses dois arquivos no Pig com as relações student1 e student2 como mostrado abaixo.

grunt> student1 = LOAD 'hdfs://localhost:9000/pig_data/student_data1.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray); 
 
grunt> student2 = LOAD 'hdfs://localhost:9000/pig_data/student_data2.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

Vamos agora fundir o conteúdo dessas duas relações usando o UNION operador como mostrado abaixo.

grunt> student = UNION student1, student2;

Verificação

Verifique a relação student usando o DUMP operador como mostrado abaixo.

grunt> Dump student;

Resultado

Ele exibirá a seguinte saída, exibindo o conteúdo da relação student.

(1,Rajiv,Reddy,9848022337,Hyderabad) (2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune) 
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai) 
(7,Komal,Nayak,9848022334,trivendram) 
(8,Bharathi,Nambiayar,9848022333,Chennai)

o SPLIT operador é usado para dividir uma relação em duas ou mais relações.

Sintaxe

Dada a seguir é a sintaxe do SPLIT operador.

grunt> SPLIT Relation1_name INTO Relation2_name IF (condition1), Relation2_name (condition2),

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

Vamos agora dividir a relação em duas, uma listando os funcionários com menos de 23 anos e a outra listando os funcionários com idades entre 22 e 25 anos.

SPLIT student_details into student_details1 if age<23, student_details2 if (22<age and age>25);

Verificação

Verifique as relações student_details1 e student_details2 usando o DUMP operador como mostrado abaixo.

grunt> Dump student_details1;  

grunt> Dump student_details2;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo das relações student_details1 e student_details2 respectivamente.

grunt> Dump student_details1; 
(1,Rajiv,Reddy,21,9848022337,Hyderabad) 
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(4,Preethi,Agarwal,21,9848022330,Pune)
  
grunt> Dump student_details2; 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) 
(6,Archana,Mishra,23,9848022335,Chennai) 
(7,Komal,Nayak,24,9848022334,trivendram) 
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

o FILTER operador é usado para selecionar as tuplas necessárias de uma relação com base em uma condição.

Sintaxe

Dada a seguir é a sintaxe do FILTER operador.

grunt> Relation2_name = FILTER Relation1_name BY (condition);

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, age:int, phone:chararray, city:chararray);

Vamos agora usar o operador Filtro para obter os detalhes dos alunos que pertencem à cidade de Chennai.

filter_data = FILTER student_details BY city == 'Chennai';

Verificação

Verifique a relação filter_data usando o DUMP operador como mostrado abaixo.

grunt> Dump filter_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação filter_data do seguinte modo.

(6,Archana,Mishra,23,9848022335,Chennai)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)

o DISTINCT operador é usado para remover tuplas redundantes (duplicadas) de uma relação.

Sintaxe

Dada a seguir é a sintaxe do DISTINCT operador.

grunt> Relation_name2 = DISTINCT Relatin_name1;

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata 
002,siddarth,Battacharya,9848022338,Kolkata 
003,Rajesh,Khanna,9848022339,Delhi 
003,Rajesh,Khanna,9848022339,Delhi 
004,Preethi,Agarwal,9848022330,Pune 
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai 
006,Archana,Mishra,9848022335,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',') 
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);

Vamos agora remover as tuplas redundantes (duplicadas) da relação chamada student_details usando o DISTINCT operador e armazená-lo como outra relação chamada distinct_data como mostrado abaixo.

grunt> distinct_data = DISTINCT student_details;

Verificação

Verifique a relação distinct_data usando o DUMP operador como mostrado abaixo.

grunt> Dump distinct_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação distinct_data do seguinte modo.

(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata) 
(3,Rajesh,Khanna,9848022339,Delhi) 
(4,Preethi,Agarwal,9848022330,Pune) 
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)

o FOREACH operador é usado para gerar transformações de dados especificadas com base nos dados da coluna.

Sintaxe

Dada a seguir é a sintaxe de FOREACH operador.

grunt> Relation_name2 = FOREACH Relatin_name1 GENERATE (required data);

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

Vamos agora obter os valores de id, idade e cidade de cada aluno da relação student_details e armazene-o em outra relação chamada foreach_data usando o foreach operador como mostrado abaixo.

grunt> foreach_data = FOREACH student_details GENERATE id,age,city;

Verificação

Verifique a relação foreach_data usando o DUMP operador como mostrado abaixo.

grunt> Dump foreach_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação foreach_data.

(1,21,Hyderabad)
(2,22,Kolkata)
(3,22,Delhi)
(4,21,Pune) 
(5,23,Bhuwaneshwar)
(6,23,Chennai) 
(7,24,trivendram)
(8,24,Chennai)

o ORDER BY operador é usado para exibir o conteúdo de uma relação em uma ordem de classificação com base em um ou mais campos.

Sintaxe

Dada a seguir é a sintaxe do ORDER BY operador.

grunt> Relation_name2 = ORDER Relatin_name1 BY (ASC|DESC);

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

Vamos agora classificar a relação em ordem decrescente com base na idade do aluno e armazená-la em outra relação chamada order_by_data usando o ORDER BY operador como mostrado abaixo.

grunt> order_by_data = ORDER student_details BY age DESC;

Verificação

Verifique a relação order_by_data usando o DUMP operador como mostrado abaixo.

grunt> Dump order_by_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação order_by_data.

(8,Bharathi,Nambiayar,24,9848022333,Chennai)
(7,Komal,Nayak,24,9848022334,trivendram)
(6,Archana,Mishra,23,9848022335,Chennai) 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(4,Preethi,Agarwal,21,9848022330,Pune) 
(1,Rajiv,Reddy,21,9848022337,Hyderabad)

o LIMIT operador é usado para obter um número limitado de tuplas de uma relação.

Sintaxe

Dada a seguir é a sintaxe do LIMIT operador.

grunt> Result = LIMIT Relation_name required number of tuples;

Exemplo

Suponha que temos um arquivo chamado student_details.txt no diretório HDFS /pig_data/ como mostrado abaixo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

E carregamos este arquivo no Pig com o nome da relação student_details como mostrado abaixo.

grunt> student_details = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray,age:int, phone:chararray, city:chararray);

Agora, vamos classificar a relação em ordem decrescente com base na idade do aluno e armazená-la em outra relação chamada limit_data usando o ORDER BY operador como mostrado abaixo.

grunt> limit_data = LIMIT student_details 4;

Verificação

Verifique a relação limit_data usando o DUMP operador como mostrado abaixo.

grunt> Dump limit_data;

Resultado

Ele irá produzir a seguinte saída, exibindo o conteúdo da relação limit_data do seguinte modo.

(1,Rajiv,Reddy,21,9848022337,Hyderabad) 
(2,siddarth,Battacharya,22,9848022338,Kolkata) 
(3,Rajesh,Khanna,22,9848022339,Delhi) 
(4,Preethi,Agarwal,21,9848022330,Pune)

Apache Pig fornece várias funções integradas, nomeadamente eval, load, store, math, string, bag e tuple funções.

Funções de avaliação

Dada abaixo está a lista de eval funções fornecidas pelo Apache Pig.

SN	Descrição da função
1	AVG () Para calcular a média dos valores numéricos dentro de uma bolsa.
2	BagToString () Para concatenar os elementos de uma bolsa em uma string. Enquanto concatenamos, podemos colocar um delimitador entre esses valores (opcional).
3	CONCAT () Para concatenar duas ou mais expressões do mesmo tipo.
4	CONTAGEM() Para obter o número de elementos em uma bolsa, enquanto conta o número de tuplas em uma bolsa.
5	COUNT_STAR () É semelhante ao COUNT()função. É usado para obter o número de elementos em uma bolsa.
6	DIFF () Para comparar dois sacos (campos) em uma tupla.
7	Está vazia() Para verificar se uma bolsa ou mapa está vazio.
8	MAX () Para calcular o valor mais alto para uma coluna (valores numéricos ou chararrays) em um pacote de coluna única.
9	MIN () Para obter o valor mínimo (mais baixo) (numérico ou chararray) para uma determinada coluna em um pacote de coluna única.
10	PluckTuple () Usando o Pig Latin PluckTuple() função, podemos definir um prefixo de string e filtrar as colunas em uma relação que começa com o prefixo dado.
11	TAMANHO() Para calcular o número de elementos com base em qualquer tipo de dados Pig.
12	SUBTRAIR() Para subtrair dois sacos. Ele pega duas bolsas como entradas e retorna uma bolsa que contém as tuplas da primeira bolsa que não estão na segunda bolsa.
13	SOMA() Para obter o total dos valores numéricos de uma coluna em um saco de coluna única.
14	TOKENIZE () Para dividir uma string (que contém um grupo de palavras) em uma única tupla e retornar uma bolsa que contém a saída da operação de divisão.

o Load e StoreAs funções do Apache Pig são usadas para determinar como os dados vão e vêm do Pig. Essas funções são usadas com os operadores de carregamento e armazenamento. A seguir, está a lista de funções de carregamento e armazenamento disponíveis no Pig.

SN	Descrição da função
1	PigStorage () Para carregar e armazenar arquivos estruturados.
2	TextLoader () Para carregar dados não estruturados no Pig.
3	BinStorage () Para carregar e armazenar dados no Pig usando formato legível por máquina.
4	Manipulação de Compressão No Pig Latin, podemos carregar e armazenar dados compactados.

A seguir está a lista de funções Bag e Tupla.

SN	Descrição da função
1	TOBAG () Para converter duas ou mais expressões em uma bolsa.
2	TOPO() Para chegar ao topo N tuplas de uma relação.
3	TOTUPLE () Para converter uma ou mais expressões em uma tupla.
4	MAPEAR() Para converter os pares de valores-chave em um mapa.

Temos as seguintes funções de String no Apache Pig.

SN	Funções e descrição
1	ENDSWITH (string, testAgainst) Para verificar se uma determinada string termina com uma substring específica.
2	STARTSWITH (string, substring) Aceita dois parâmetros de string e verifica se a primeira string começa com a segunda.
3	SUBSTRING (string, startIndex, stopIndex) Retorna uma substring de uma determinada string.
4	EqualsIgnoreCase (string1, string2) Para comparar duas picadas ignorando o caso.
5	INDEXOF (string, 'character', startIndex) Retorna a primeira ocorrência de um caractere em uma string, procurando a partir de um índice inicial.
6	LAST_INDEX_OF (expressão) Retorna o índice da última ocorrência de um caractere em uma string, pesquisando para trás a partir de um índice inicial.
7	LCFIRST (expressão) Converte o primeiro caractere em uma string em minúsculas.
8	UCFIRST (expressão) Retorna uma string com o primeiro caractere convertido em maiúsculas.
9	UPPER (expressão) UPPER (expressão) Retorna uma string convertida em maiúsculas.
10	LOWER (expressão) Converte todos os caracteres em uma string em minúsculas.
11	REPLACE (string, 'oldChar', 'newChar'); Para substituir os caracteres existentes em uma string por novos caracteres.
12	STRSPLIT (string, regex, limite) Para dividir uma string em torno de correspondências de uma determinada expressão regular.
13	STRSPLITTOBAG (string, regex, limite) Semelhante ao STRSPLIT() função, ele divide a string por determinado delimitador e retorna o resultado em um saco.
14	TRIM (expressão) Retorna uma cópia de uma string com os espaços em branco à esquerda e à direita removidos.
15	LTRIM (expressão) Retorna uma cópia de uma string com os espaços em branco à esquerda removidos.
16	RTRIM (expressão) Retorna uma cópia de uma string com os espaços em branco à direita removidos.

O Apache Pig fornece as seguintes funções de data e hora -

SN	Funções e descrição
1	ToDate (milissegundos) Esta função retorna um objeto de data e hora de acordo com os parâmetros fornecidos. A outra alternativa para esta função são ToDate (iosstring), ToDate (userstring, formato), ToDate (userstring, formato, fuso horário)
2	Hora atual() retorna o objeto de data e hora da hora atual.
3	GetDay (datetime) Retorna o dia de um mês do objeto data e hora.
4	GetHour (datetime) Retorna a hora de um dia do objeto data-hora.
5	GetMilliSecond (datetime) Retorna o milissegundo de segundo do objeto de data e hora.
6	GetMinute (datetime) Retorna o minuto de uma hora do objeto de data e hora.
7	GetMonth (datetime) Retorna o mês de um ano do objeto data e hora.
8	GetSecond (datetime) Retorna o segundo de um minuto do objeto de data e hora.
9	GetWeek (datetime) Retorna a semana de um ano do objeto data e hora.
10	GetWeekYear (datetime) Retorna o ano da semana do objeto data-hora.
11	GetYear (datetime) Retorna o ano do objeto data-hora.
12	AddDuration (datetime, duration) Retorna o resultado de um objeto de data e hora junto com o objeto de duração.
13	SubtractDuration (datetime, duration) Subtrai o objeto Duration do objeto Date-Time e retorna o resultado.
14	DaysBetween (datetime1, datetime2) Retorna o número de dias entre os dois objetos de data e hora.
15	Horasentre (datetime1, datetime2) Retorna o número de horas entre dois objetos de data e hora.
16	MilliSecondsBetween (datetime1, datetime2) Retorna o número de milissegundos entre dois objetos de data e hora.
17	MinutesBetween (datetime1, datetime2) Retorna o número de minutos entre dois objetos de data e hora.
18	Meses Entre (datetime1, datetime2) Retorna o número de meses entre dois objetos de data e hora.
19	SecondsBetween (datetime1, datetime2) Retorna o número de segundos entre dois objetos de data e hora.
20	WeeksBetween (datetime1, datetime2) Retorna o número de semanas entre dois objetos de data e hora.
21	Anos Entre (datetime1, datetime2) Retorna o número de anos entre dois objetos de data e hora.

Temos as seguintes funções matemáticas no Apache Pig -

SN	Funções e descrição
1	ABS (expressão) Para obter o valor absoluto de uma expressão.
2	ACOS (expressão) Para obter o arco cosseno de uma expressão.
3	ASIN (expressão) Para obter o arco seno de uma expressão.
4	ATAN (expressão) Esta função é usada para obter o arco tangente de uma expressão.
5	CBRT (expressão) Esta função é usada para obter a raiz cúbica de uma expressão.
6	CEIL (expressão) Esta função é usada para obter o valor de uma expressão arredondado para o inteiro mais próximo.
7	COS (expressão) Esta função é usada para obter o cosseno trigonométrico de uma expressão.
8	COSH (expressão) Esta função é usada para obter o cosseno hiperbólico de uma expressão.
9	EXP (expressão) Esta função é usada para elevar o número de Euler e à potência de x.
10	FLOOR (expressão) Para obter o valor de uma expressão arredondado para o inteiro mais próximo.
11	LOG (expressão) Para obter o logaritmo natural (base e) de uma expressão.
12	LOG10 (expressão) Para obter o logaritmo de base 10 de uma expressão.
13	ALEATÓRIA( ) Para obter um número pseudoaleatório (digite duplo) maior ou igual a 0,0 e menor que 1,0.
14	ROUND (expressão) Para obter o valor de uma expressão arredondado para um inteiro (se o tipo de resultado for flutuante) ou arredondado para um longo (se o tipo de resultado for duplo).
15	SIN (expressão) Para obter o seno de uma expressão.
16	SINH (expressão) Para obter o seno hiperbólico de uma expressão.
17	SQRT (expressão) Para obter a raiz quadrada positiva de uma expressão.
18	TAN (expressão) Para obter a tangente trigonométrica de um ângulo.
19	TANH (expressão) Para obter a tangente hiperbólica de uma expressão.

Além das funções integradas, o Apache Pig oferece amplo suporte para USer Dafinado Funções (UDF's). Usando essas UDFs, podemos definir nossas próprias funções e usá-las. O suporte UDF é fornecido em seis linguagens de programação, a saber, Java, Jython, Python, JavaScript, Ruby e Groovy.

Para escrever UDFs, é fornecido suporte completo em Java e suporte limitado em todas as linguagens restantes. Usando Java, você pode escrever UDFs envolvendo todas as partes do processamento, como carregamento / armazenamento de dados, transformação de coluna e agregação. Como o Apache Pig foi escrito em Java, as UDFs escritas usando a linguagem Java funcionam de forma eficiente em comparação com outras linguagens.

No Apache Pig, também temos um repositório Java para UDF's denominado Piggybank. Usando Piggybank, podemos acessar UDFs de Java escritos por outros usuários e contribuir com nossas próprias UDFs.

Tipos de UDFs em Java

Ao escrever UDFs usando Java, podemos criar e usar os três tipos de funções a seguir -

• Filter Functions- As funções de filtro são usadas como condições em declarações de filtro. Essas funções aceitam um valor Pig como entrada e retornam um valor booleano.

• Eval Functions- As funções Eval são usadas em instruções FOREACH-GENERATE. Essas funções aceitam um valor Pig como entrada e retornam um resultado Pig.

• Algebraic Functions- As funções algébricas atuam em bolsas internas em uma instrução FOREACHGENERATE. Essas funções são usadas para realizar operações MapReduce completas em uma bolsa interna.

Escrevendo UDFs usando Java

Para escrever uma UDF usando Java, temos que integrar o arquivo jar Pig-0.15.0.jar. Nesta seção, discutimos como escrever uma amostra de UDF usando Eclipse. Antes de prosseguir, certifique-se de ter instalado o Eclipse e o Maven em seu sistema.

Siga as etapas abaixo para escrever uma função UDF -

• Abra o Eclipse e crie um novo projeto (digamos myproject)

• Converta o projeto recém-criado em um projeto Maven.

• Copie o seguinte conteúdo no pom.xml. Este arquivo contém as dependências do Maven para arquivos jar Apache Pig e Hadoop-core.

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0http://maven.apache .org/xsd/maven-4.0.0.xsd"> 
	
   <modelVersion>4.0.0</modelVersion> 
   <groupId>Pig_Udf</groupId> 
   <artifactId>Pig_Udf</artifactId> 
   <version>0.0.1-SNAPSHOT</version>
	
   <build>    
      <sourceDirectory>src</sourceDirectory>    
      <plugins>      
         <plugin>        
            <artifactId>maven-compiler-plugin</artifactId>        
            <version>3.3</version>        
            <configuration>          
               <source>1.7</source>          
               <target>1.7</target>        
            </configuration>      
         </plugin>    
      </plugins>  
   </build>
	
   <dependencies> 
	
      <dependency>            
         <groupId>org.apache.pig</groupId>            
         <artifactId>pig</artifactId>            
         <version>0.15.0</version>     
      </dependency> 
		
      <dependency>        
         <groupId>org.apache.hadoop</groupId>            
         <artifactId>hadoop-core</artifactId>            
         <version>0.20.2</version>     
      </dependency> 
      
   </dependencies>  
	
</project>

• Salve o arquivo e atualize-o. NoMaven Dependencies seção, você pode encontrar os arquivos jar baixados.

• Crie um novo arquivo de classe com o nome Sample_Eval e copie o seguinte conteúdo nele.

import java.io.IOException; 
import org.apache.pig.EvalFunc; 
import org.apache.pig.data.Tuple; 
 
import java.io.IOException; 
import org.apache.pig.EvalFunc; 
import org.apache.pig.data.Tuple;

public class Sample_Eval extends EvalFunc<String>{ 

   public String exec(Tuple input) throws IOException {   
      if (input == null || input.size() == 0)      
      return null;      
      String str = (String)input.get(0);      
      return str.toUpperCase();  
   } 
}

Ao escrever UDFs, é obrigatório herdar a classe EvalFunc e fornecer implementação para exec()função. Dentro desta função, o código necessário para o UDF é escrito. No exemplo acima, retornamos o código para converter o conteúdo da coluna fornecida em maiúsculas.

• Depois de compilar a classe sem erros, clique com o botão direito no arquivo Sample_Eval.java. Dá a você um menu. Selecioneexport como mostrado na imagem a seguir.

• Ao clicar export, você obterá a seguinte janela. Clique emJAR file.

• Continue clicando Next>botão. Você verá outra janela onde você precisa inserir o caminho no sistema de arquivos local, onde você precisa armazenar o arquivo jar.

• Por fim, clique no Finishbotão. Na pasta especificada, um arquivo Jarsample_udf.jaré criado. Este arquivo jar contém o UDF escrito em Java.

Usando o UDF

Depois de escrever o UDF e gerar o arquivo Jar, siga as etapas abaixo -

Etapa 1: Registrando o arquivo Jar

Depois de escrever UDF (em Java), temos que registrar o arquivo Jar que contém a UDF usando o operador Register. Ao registrar o arquivo Jar, os usuários podem indicar a localização do UDF ao Apache Pig.

Syntax

A seguir está a sintaxe do operador Register.

REGISTER path;

Example

Como exemplo, vamos registrar o sample_udf.jar criado anteriormente neste capítulo.

Inicie o Apache Pig no modo local e registre o arquivo jar sample_udf.jar conforme mostrado abaixo.

$cd PIG_HOME/bin $./pig –x local 

REGISTER '/$PIG_HOME/sample_udf.jar'

Note - assume o arquivo Jar no caminho - /$PIG_HOME/sample_udf.jar

Etapa 2: Definindo o Alias

Depois de registrar o UDF, podemos definir um alias para ele usando o Define operador.

Syntax

A seguir está a sintaxe do operador Define.

DEFINE alias {function | [`command` [input] [output] [ship] [cache] [stderr] ] };

Example

Defina o alias para sample_eval conforme mostrado abaixo.

DEFINE sample_eval sample_eval();

Etapa 3: usando o UDF

Depois de definir o alias, você pode usar o UDF da mesma forma que as funções integradas. Suponha que haja um arquivo chamado emp_data no HDFS/Pig_Data/ diretório com o seguinte conteúdo.

001,Robin,22,newyork
002,BOB,23,Kolkata
003,Maya,23,Tokyo
004,Sara,25,London 
005,David,23,Bhuwaneshwar 
006,Maggy,22,Chennai
007,Robert,22,newyork
008,Syam,23,Kolkata
009,Mary,25,Tokyo
010,Saran,25,London 
011,Stacy,25,Bhuwaneshwar 
012,Kelly,22,Chennai

E suponha que carregamos esse arquivo no Pig, conforme mostrado abaixo.

grunt> emp_data = LOAD 'hdfs://localhost:9000/pig_data/emp1.txt' USING PigStorage(',')
   as (id:int, name:chararray, age:int, city:chararray);

Vamos agora converter os nomes dos funcionários em maiúsculas usando o UDF sample_eval.

grunt> Upper_case = FOREACH emp_data GENERATE sample_eval(name);

Verifique o conteúdo da relação Upper_case como mostrado abaixo.

grunt> Dump Upper_case;
  
(ROBIN)
(BOB)
(MAYA)
(SARA)
(DAVID)
(MAGGY)
(ROBERT)
(SYAM)
(MARY)
(SARAN)
(STACY)
(KELLY)

Aqui neste capítulo, veremos como executar scripts do Apache Pig no modo em lote.

Comentários no Pig Script

Ao escrever um script em um arquivo, podemos incluir comentários como mostrado abaixo.

Comentários multilinhas

Começaremos os comentários de várias linhas com '/ *' e terminá-los com '* /'.

/* These are the multi-line comments 
  In the pig script */

Comentários de linha única

Começaremos os comentários de linha única com '-'.

--we can write single line comments like this.

Executando Pig Script no modo Batch

Ao executar as instruções do Apache Pig no modo em lote, siga as etapas fornecidas abaixo.

Passo 1

Grave todas as instruções do Pig Latin necessárias em um único arquivo. Podemos escrever todas as instruções e comandos do Pig Latin em um único arquivo e salvá-lo como.pig Arquivo.

Passo 2

Execute o script do Apache Pig. Você pode executar o script Pig a partir do shell (Linux), conforme mostrado abaixo.

Modo local	Modo MapReduce
$ pig -x local Sample_script.pig	$ pig -x mapreduce Sample_script.pig

Você também pode executá-lo a partir do shell Grunt, usando o comando exec conforme mostrado abaixo.

grunt> exec /sample_script.pig

Executando um Pig Script do HDFS

Também podemos executar um script Pig que reside no HDFS. Suponha que haja um script Pig com o nomeSample_script.pig no diretório HDFS chamado /pig_data/. Podemos executá-lo conforme mostrado abaixo.

$ pig -x mapreduce hdfs://localhost:9000/pig_data/Sample_script.pig

Exemplo

Suponha que temos um arquivo student_details.txt em HDFS com o seguinte conteúdo.

student_details.txt

001,Rajiv,Reddy,21,9848022337,Hyderabad 
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi 
004,Preethi,Agarwal,21,9848022330,Pune 
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 
006,Archana,Mishra,23,9848022335,Chennai 
007,Komal,Nayak,24,9848022334,trivendram 
008,Bharathi,Nambiayar,24,9848022333,Chennai

Também temos um script de exemplo com o nome sample_script.pig, no mesmo diretório HDFS. Este arquivo contém instruções que executam operações e transformações nostudent relação, conforme mostrado abaixo.

student = LOAD 'hdfs://localhost:9000/pig_data/student_details.txt' USING PigStorage(',')
   as (id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray);
	
student_order = ORDER student BY age DESC;
  
student_limit = LIMIT student_order 4;
  
Dump student_limit;

• A primeira instrução do script carregará os dados no arquivo denominado student_details.txt como uma relação chamada student.

• A segunda declaração do script irá organizar as tuplas da relação em ordem decrescente, com base na idade, e armazená-la como student_order.

• A terceira instrução do script irá armazenar as primeiras 4 tuplas de student_order Como student_limit.

• Finalmente, a quarta declaração irá despejar o conteúdo da relação student_limit.

Vamos agora executar o sample_script.pig como mostrado abaixo.

$./pig -x mapreduce hdfs://localhost:9000/pig_data/sample_script.pig

O Apache Pig é executado e fornece a saída com o seguinte conteúdo.

(7,Komal,Nayak,24,9848022334,trivendram)
(8,Bharathi,Nambiayar,24,9848022333,Chennai) 
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar) 
(6,Archana,Mishra,23,9848022335,Chennai)
2015-10-19 10:31:27,446 [main] INFO  org.apache.pig.Main - Pig script completed in 12
minutes, 32 seconds and 751 milliseconds (752751 ms)