HCatalog - Guida rapida
Cos'è HCatalog?
HCatalog è uno strumento di gestione dell'archiviazione delle tabelle per Hadoop. Espone i dati tabulari del metastore Hive ad altre applicazioni Hadoop. Consente agli utenti con diversi strumenti di elaborazione dati (Pig, MapReduce) di scrivere facilmente i dati su una griglia. Assicura che gli utenti non debbano preoccuparsi di dove o in quale formato sono archiviati i loro dati.
HCatalog funziona come un componente chiave di Hive e consente agli utenti di memorizzare i propri dati in qualsiasi formato e struttura.
Perché HCatalog?
Abilitazione dello strumento giusto per il lavoro giusto
L'ecosistema Hadoop contiene diversi strumenti per l'elaborazione dei dati come Hive, Pig e MapReduce. Sebbene questi strumenti non richiedano metadati, possono comunque trarne vantaggio quando sono presenti. La condivisione di un archivio di metadati consente inoltre agli utenti di tutti gli strumenti di condividere i dati più facilmente. Un flusso di lavoro in cui i dati vengono caricati e normalizzati utilizzando MapReduce o Pig e quindi analizzati tramite Hive è molto comune. Se tutti questi strumenti condividono un metastore, gli utenti di ogni strumento hanno accesso immediato ai dati creati con un altro strumento. Non sono richieste fasi di caricamento o trasferimento.
Acquisisci gli stati di elaborazione per abilitare la condivisione
HCatalog può pubblicare i risultati delle tue analisi. Quindi l'altro programmatore può accedere alla tua piattaforma di analisi tramite "REST". Gli schemi da te pubblicati sono utili anche ad altri data scientist. Gli altri data scientist utilizzano le tue scoperte come input per una scoperta successiva.
Integra Hadoop con tutto
Hadoop come ambiente di elaborazione e archiviazione offre molte opportunità all'azienda; tuttavia, per favorire l'adozione, deve lavorare con e potenziare gli strumenti esistenti. Hadoop dovrebbe servire come input nella tua piattaforma di analisi o integrarsi con i tuoi archivi di dati operativi e le applicazioni web. L'organizzazione dovrebbe godere del valore di Hadoop senza dover apprendere un set di strumenti completamente nuovo. I servizi REST aprono la piattaforma all'azienda con un'API familiare e un linguaggio simile a SQL. I sistemi di gestione dei dati aziendali utilizzano HCatalog per integrarsi più profondamente con la piattaforma Hadoop.
Architettura HCatalog
La figura seguente mostra l'architettura complessiva di HCatalog.
HCatalog supporta la lettura e la scrittura di file in qualsiasi formato per il quale a SerDe(serializer-deserializer) può essere scritto. Per impostazione predefinita, HCatalog supporta i formati di file RCFile, CSV, JSON, SequenceFile e ORC. Per utilizzare un formato personalizzato, è necessario fornire InputFormat, OutputFormat e SerDe.
HCatalog si basa sul metastore Hive e incorpora DDL di Hive. HCatalog fornisce interfacce di lettura e scrittura per Pig e MapReduce e utilizza l'interfaccia della riga di comando di Hive per inviare la definizione dei dati e i comandi di esplorazione dei metadati.
Tutti i sottoprogetti Hadoop come Hive, Pig e HBase supportano il sistema operativo Linux. Pertanto, è necessario installare una versione Linux sul proprio sistema. HCatalog è stato unito all'installazione di Hive il 26 marzo 2013. Dalla versione Hive-0.11.0 in poi, HCatalog viene fornito con l'installazione di Hive. Pertanto, segui i passaggi indicati di seguito per installare Hive che a sua volta installerà automaticamente HCatalog sul tuo sistema.
Passaggio 1: verifica dell'installazione di JAVA
Java deve essere installato sul sistema prima di installare Hive. È possibile utilizzare il seguente comando per verificare se Java è già installato sul sistema:
$ java –versionSe Java è già installato sul tuo sistema, puoi vedere la seguente risposta:
java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b13)
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)Se non hai Java installato sul tuo sistema, devi seguire i passaggi indicati di seguito.
Passaggio 2: installazione di Java
Scarica Java (JDK <ultima versione> - X64.tar.gz) visitando il seguente collegamento http://www.oracle.com/
Poi jdk-7u71-linux-x64.tar.gz verrà scaricato sul tuo sistema.
Generalmente troverai il file Java scaricato nella cartella Download. Verificalo ed estrai il filejdk-7u71-linux-x64.gz file utilizzando i seguenti comandi.
$ cd Downloads/
$ ls jdk-7u71-linux-x64.gz $ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gzPer rendere Java disponibile a tutti gli utenti, è necessario spostarlo nella posizione "/ usr / local /". Apri root e digita i seguenti comandi.
$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exitPer l'allestimento PATH e JAVA_HOME variabili, aggiungi i seguenti comandi a ~/.bashrc file.
export JAVA_HOME=/usr/local/jdk1.7.0_71
export PATH=PATH:$JAVA_HOME/binOra verifica l'installazione utilizzando il comando java -version dal terminale come spiegato sopra.
Passaggio 3: verifica dell'installazione di Hadoop
Hadoop deve essere installato sul tuo sistema prima di installare Hive. Cerchiamo di verificare l'installazione di Hadoop utilizzando il seguente comando:
$ hadoop versionSe Hadoop è già installato sul tuo sistema, riceverai la seguente risposta:
Hadoop 2.4.1
Subversion https://svn.apache.org/repos/asf/hadoop/common -r 1529768
Compiled by hortonmu on 2013-10-07T06:28Z
Compiled with protoc 2.5.0
From source with checksum 79e53ce7994d1628b240f09af91e1af4Se Hadoop non è installato sul tuo sistema, procedi con i seguenti passaggi:
Passaggio 4: download di Hadoop
Scarica ed estrai Hadoop 2.4.1 da Apache Software Foundation utilizzando i seguenti comandi.
$ su
password:
# cd /usr/local
# wget http://apache.claz.org/hadoop/common/hadoop-2.4.1/
hadoop-2.4.1.tar.gz
# tar xzf hadoop-2.4.1.tar.gz
# mv hadoop-2.4.1/* to hadoop/
# exitPassaggio 5: installazione di Hadoop in modalità pseudo distribuita
I seguenti passaggi vengono utilizzati per l'installazione Hadoop 2.4.1 in modalità pseudo distribuita.
Configurazione di Hadoop
Puoi impostare le variabili d'ambiente Hadoop aggiungendo i seguenti comandi a ~/.bashrc file.
export HADOOP_HOME=/usr/local/hadoop
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME export HADOOP_HDFS_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/binOra applica tutte le modifiche al sistema in esecuzione corrente.
$ source ~/.bashrcConfigurazione Hadoop
Puoi trovare tutti i file di configurazione di Hadoop nella posizione "$ HADOOP_HOME / etc / hadoop". È necessario apportare modifiche adeguate a quei file di configurazione in base alla propria infrastruttura Hadoop.
$ cd $HADOOP_HOME/etc/hadoopPer sviluppare programmi Hadoop utilizzando Java, è necessario reimpostare le variabili d'ambiente Java in hadoop-env.sh file sostituendo JAVA_HOME valore con la posizione di Java nel sistema.
export JAVA_HOME=/usr/local/jdk1.7.0_71Di seguito è riportato l'elenco dei file che devi modificare per configurare Hadoop.
core-site.xml
Il core-site.xml file contiene informazioni come il numero di porta utilizzato per l'istanza Hadoop, la memoria allocata per il file system, il limite di memoria per la memorizzazione dei dati e la dimensione dei buffer di lettura / scrittura.
Apri core-site.xml e aggiungi le seguenti proprietà tra i tag <configuration> e </configuration>.
<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://localhost:9000</value>
</property>
</configuration>hdfs-site.xml
Il hdfs-site.xmlfile contiene informazioni come il valore dei dati di replica, il percorso namenode e il percorso datanode dei file system locali. Significa il luogo in cui si desidera archiviare l'infrastruttura Hadoop.
Assumiamo i seguenti dati.
dfs.replication (data replication value) = 1
(In the following path /hadoop/ is the user name.
hadoopinfra/hdfs/namenode is the directory created by hdfs file system.)
namenode path = //home/hadoop/hadoopinfra/hdfs/namenode
(hadoopinfra/hdfs/datanode is the directory created by hdfs file system.)
datanode path = //home/hadoop/hadoopinfra/hdfs/datanodeApri questo file e aggiungi le seguenti proprietà tra i tag <configuration>, </configuration> in questo file.
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
<property>
<name>dfs.name.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/namenode</value>
</property>
<property>
<name>dfs.data.dir</name>
<value>file:///home/hadoop/hadoopinfra/hdfs/datanode</value>
</property>
</configuration>Note - Nel file sopra, tutti i valori delle proprietà sono definiti dall'utente ed è possibile apportare modifiche in base alla propria infrastruttura Hadoop.
filato-site.xml
Questo file viene utilizzato per configurare il filato in Hadoop. Apri il file filato-site.xml e aggiungi le seguenti proprietà tra i tag <configuration>, </configuration> in questo file.
<configuration>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>mapred-site.xml
Questo file viene utilizzato per specificare quale framework MapReduce stiamo utilizzando. Per impostazione predefinita, Hadoop contiene un modello di filato-site.xml. Prima di tutto, devi copiare il file damapred-site,xml.template per mapred-site.xml file utilizzando il seguente comando.
$ cp mapred-site.xml.template mapred-site.xmlApri il file mapred-site.xml e aggiungi le seguenti proprietà tra i tag <configuration>, </configuration> in questo file.
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>Passaggio 6: verifica dell'installazione di Hadoop
I seguenti passaggi vengono utilizzati per verificare l'installazione di Hadoop.
Configurazione Namenode
Impostare il namenode utilizzando il comando "hdfs namenode -format" come segue:
$ cd ~ $ hdfs namenode -formatIl risultato atteso è il seguente:
10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG: host = localhost/192.168.1.11
STARTUP_MSG: args = [-format]
STARTUP_MSG: version = 2.4.1
...
...
10/24/14 21:30:56 INFO common.Storage: Storage directory
/home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted.
10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to retain 1
images with txid >= 0 10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0
10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11
************************************************************/Verifica di Hadoop DFS
Il seguente comando viene utilizzato per avviare il DFS. L'esecuzione di questo comando avvierà il tuo file system Hadoop.
$ start-dfs.shL'output previsto è il seguente:
10/24/14 21:37:56 Starting namenodes on [localhost]
localhost: starting namenode, logging to
/home/hadoop/hadoop-2.4.1/logs/hadoop-hadoop-namenode-localhost.out localhost:
starting datanode, logging to
/home/hadoop/hadoop-2.4.1/logs/hadoop-hadoop-datanode-localhost.out
Starting secondary namenodes [0.0.0.0]Verifica dello script del filato
Il seguente comando viene utilizzato per avviare lo script Yarn. L'esecuzione di questo comando avvierà i tuoi demoni di Yarn.
$ start-yarn.shL'output previsto è il seguente:
starting yarn daemons
starting resourcemanager, logging to /home/hadoop/hadoop-2.4.1/logs/
yarn-hadoop-resourcemanager-localhost.out
localhost: starting nodemanager, logging to
/home/hadoop/hadoop-2.4.1/logs/yarn-hadoop-nodemanager-localhost.outAccesso ad Hadoop sul browser
Il numero di porta predefinito per accedere a Hadoop è 50070. Utilizza il seguente URL per ottenere i servizi Hadoop sul tuo browser.
http://localhost:50070/
Verifica tutte le applicazioni per il cluster
Il numero di porta predefinito per accedere a tutte le applicazioni del cluster è 8088. Utilizzare il seguente URL per visitare questo servizio.
http://localhost:8088/
Una volta terminata l'installazione di Hadoop, procedi al passaggio successivo e installa Hive sul tuo sistema.
Passaggio 7: download di Hive
Usiamo hive-0.14.0 in questo tutorial. Puoi scaricarlo visitando il seguente linkhttp://apache.petsads.us/hive/hive-0.14.0/. Supponiamo che venga scaricato nel file/Downloadsdirectory. Qui, scarichiamo l'archivio Hive denominato "apache-hive-0.14.0-bin.tar.gz"Per questo tutorial. Il seguente comando viene utilizzato per verificare il download:
$ cd Downloads $ lsIn caso di download riuscito, viene visualizzata la seguente risposta:
apache-hive-0.14.0-bin.tar.gzPassaggio 8: installazione di Hive
I seguenti passaggi sono necessari per l'installazione di Hive sul tuo sistema. Supponiamo che l'archivio Hive venga scaricato nel file/Downloads directory.
Estrazione e verifica dell'archivio Hive
Il seguente comando viene utilizzato per verificare il download ed estrarre l'archivio Hive:
$ tar zxvf apache-hive-0.14.0-bin.tar.gz $ lsIn caso di download riuscito, viene visualizzata la seguente risposta:
apache-hive-0.14.0-bin apache-hive-0.14.0-bin.tar.gzCopia dei file nella directory / usr / local / hive
Dobbiamo copiare i file dal superutente "su -". I seguenti comandi vengono utilizzati per copiare i file dalla directory estratta al file/usr/local/hive"Directory.
$ su -
passwd:
# cd /home/user/Download
# mv apache-hive-0.14.0-bin /usr/local/hive
# exitConfigurazione dell'ambiente per Hive
Puoi configurare l'ambiente Hive aggiungendo le seguenti righe a ~/.bashrc file -
export HIVE_HOME=/usr/local/hive
export PATH=$PATH:$HIVE_HOME/bin export CLASSPATH=$CLASSPATH:/usr/local/Hadoop/lib/*:.
export CLASSPATH=$CLASSPATH:/usr/local/hive/lib/*:.Il seguente comando viene utilizzato per eseguire il file ~ / .bashrc.
$ source ~/.bashrcPassaggio 9: configurazione di Hive
Per configurare Hive con Hadoop, devi modificare il file hive-env.sh file, che viene inserito nel file $HIVE_HOME/confdirectory. I seguenti comandi reindirizzano a Hiveconfig cartella e copia il file modello -
$ cd $HIVE_HOME/conf $ cp hive-env.sh.template hive-env.shModifica il file hive-env.sh file aggiungendo la seguente riga -
export HADOOP_HOME=/usr/local/hadoopCon questo, l'installazione di Hive è completa. Ora è necessario un server di database esterno per configurare Metastore. Usiamo il database Apache Derby.
Passaggio 10: download e installazione di Apache Derby
Seguire i passaggi indicati di seguito per scaricare e installare Apache Derby -
Download di Apache Derby
Il seguente comando viene utilizzato per scaricare Apache Derby. Ci vuole del tempo per il download.
$ cd ~ $ wget http://archive.apache.org/dist/db/derby/db-derby-10.4.2.0/db-derby-10.4.2.0-bin.tar.gzIl seguente comando viene utilizzato per verificare il download:
$ lsIn caso di download riuscito, viene visualizzata la seguente risposta:
db-derby-10.4.2.0-bin.tar.gzEstrazione e verifica dell'archivio Derby
I seguenti comandi sono usati per estrarre e verificare l'archivio Derby:
$ tar zxvf db-derby-10.4.2.0-bin.tar.gz
$ lsIn caso di download riuscito, viene visualizzata la seguente risposta:
db-derby-10.4.2.0-bin db-derby-10.4.2.0-bin.tar.gzCopia dei file nella directory / usr / local / derby
Dobbiamo copiare dal superutente "su -". I seguenti comandi vengono utilizzati per copiare i file dalla directory estratta al file/usr/local/derby directory -
$ su -
passwd:
# cd /home/user
# mv db-derby-10.4.2.0-bin /usr/local/derby
# exitImpostazione dell'ambiente per Derby
È possibile configurare l'ambiente Derby aggiungendo le seguenti righe a ~/.bashrc file -
export DERBY_HOME=/usr/local/derby
export PATH=$PATH:$DERBY_HOME/bin
export CLASSPATH=$CLASSPATH:$DERBY_HOME/lib/derby.jar:$DERBY_HOME/lib/derbytools.jarIl seguente comando viene utilizzato per eseguire ~/.bashrc file -
$ source ~/.bashrcCrea una directory per Metastore
Crea una directory denominata data nella directory $ DERBY_HOME per memorizzare i dati del Metastore.
$ mkdir $DERBY_HOME/dataL'installazione di Derby e la configurazione ambientale sono ora complete.
Passaggio 11: configurazione del metastore Hive
Configurare Metastore significa specificare in Hive dove è archiviato il database. Puoi farlo modificando il filehive-site.xml file, che si trova nel file $HIVE_HOME/confdirectory. Prima di tutto, copia il file modello utilizzando il seguente comando:
$ cd $HIVE_HOME/conf
$ cp hive-default.xml.template hive-site.xmlmodificare hive-site.xml e aggiungi le seguenti righe tra i tag <configuration> e </configuration> -
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:derby://localhost:1527/metastore_db;create = true</value>
<description>JDBC connect string for a JDBC metastore</description>
</property>Crea un file denominato jpox.properties e aggiungi le seguenti righe:
javax.jdo.PersistenceManagerFactoryClass = org.jpox.PersistenceManagerFactoryImpl
org.jpox.autoCreateSchema = false
org.jpox.validateTables = false
org.jpox.validateColumns = false
org.jpox.validateConstraints = false
org.jpox.storeManagerType = rdbms
org.jpox.autoCreateSchema = true
org.jpox.autoStartMechanismMode = checked
org.jpox.transactionIsolation = read_committed
javax.jdo.option.DetachAllOnCommit = true
javax.jdo.option.NontransactionalRead = true
javax.jdo.option.ConnectionDriverName = org.apache.derby.jdbc.ClientDriver
javax.jdo.option.ConnectionURL = jdbc:derby://hadoop1:1527/metastore_db;create = true
javax.jdo.option.ConnectionUserName = APP
javax.jdo.option.ConnectionPassword = minePassaggio 12: verifica dell'installazione di Hive
Prima di eseguire Hive, è necessario creare il file /tmpcartella e una cartella Hive separata in HDFS. Qui usiamo il file/user/hive/warehousecartella. È necessario impostare l'autorizzazione di scrittura per queste cartelle appena create come mostrato di seguito -
chmod g+wOra impostali in HDFS prima di verificare Hive. Usa i seguenti comandi:
$ $HADOOP_HOME/bin/hadoop fs -mkdir /tmp $ $HADOOP_HOME/bin/hadoop fs -mkdir /user/hive/warehouse $ $HADOOP_HOME/bin/hadoop fs -chmod g+w /tmp $ $HADOOP_HOME/bin/hadoop fs -chmod g+w /user/hive/warehouseI seguenti comandi vengono utilizzati per verificare l'installazione di Hive:
$ cd $HIVE_HOME $ bin/hiveDopo aver installato con successo Hive, vedrai la seguente risposta:
Logging initialized using configuration in
jar:file:/home/hadoop/hive-0.9.0/lib/hive-common-0.9.0.jar!/
hive-log4j.properties Hive history
=/tmp/hadoop/hive_job_log_hadoop_201312121621_1494929084.txt
………………….
hive>È possibile eseguire il seguente comando di esempio per visualizzare tutte le tabelle:
hive> show tables;
OK Time taken: 2.798 seconds
hive>Passaggio 13: verificare l'installazione di HCatalog
Utilizzare il seguente comando per impostare una variabile di sistema HCAT_HOME per HCatalog Home.
export HCAT_HOME = $HiVE_HOME/HCatalogUtilizzare il seguente comando per verificare l'installazione di HCatalog.
cd $HCAT_HOME/bin
./hcatSe l'installazione ha esito positivo, vedrai il seguente output:
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
usage: hcat { -e "<query>" | -f "<filepath>" }
[ -g "<group>" ] [ -p "<perms>" ]
[ -D"<name> = <value>" ]
-D <property = value> use hadoop value for given property
-e <exec> hcat command given from command line
-f <file> hcat commands in file
-g <group> group for the db/table specified in CREATE statement
-h,--help Print help information
-p <perms> permissions for the db/table specified in CREATE statementHCatalog Command Line Interface (CLI) può essere richiamata dal comando $HIVE_HOME/HCatalog/bin/hcat dove $ HIVE_HOME è la home directory di Hive. hcat è un comando utilizzato per inizializzare il server HCatalog.
Utilizzare il comando seguente per inizializzare la riga di comando di HCatalog.
cd $HCAT_HOME/bin
./hcatSe l'installazione è stata eseguita correttamente, otterrai il seguente output:
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
usage: hcat { -e "<query>" | -f "<filepath>" }
[ -g "<group>" ] [ -p "<perms>" ]
[ -D"<name> = <value>" ]
-D <property = value> use hadoop value for given property
-e <exec> hcat command given from command line
-f <file> hcat commands in file
-g <group> group for the db/table specified in CREATE statement
-h,--help Print help information
-p <perms> permissions for the db/table specified in CREATE statementLa CLI di HCatalog supporta queste opzioni della riga di comando:
| Suor n | Opzione | Esempio e descrizione |
|---|---|---|
| 1 | -g | hcat -g mygroup ... La tabella da creare deve avere il gruppo "miogruppo". |
| 2 | -p | hcat -p rwxr-xr-x ... La tabella da creare deve disporre delle autorizzazioni di lettura, scrittura ed esecuzione. |
| 3 | -f | hcat -f myscript.HCatalog ... myscript.HCatalog è un file di script contenente i comandi DDL da eseguire. |
| 4 | -e | hcat -e 'create table mytable(a int);' ... Tratta la seguente stringa come un comando DDL ed eseguilo. |
| 5 | -D | hcat -Dkey = value ... Passa la coppia chiave-valore a HCatalog come proprietà di sistema Java. |
| 6 | - | hcat Stampa un messaggio di utilizzo. |
Nota -
Il -g e -p le opzioni non sono obbligatorie.
Una volta, neanche -e o -f può essere fornita l'opzione, non entrambe.
L'ordine delle opzioni è irrilevante; puoi specificare le opzioni in qualsiasi ordine.
| Suor n | Comando e descrizione DDL |
|---|---|
| 1 | CREATE TABLE Crea una tabella utilizzando HCatalog. Se crei una tabella con una clausola CLUSTER BY, non sarai in grado di scrivere su di essa con Pig o MapReduce. |
| 2 | ALTER TABLE Supportato ad eccezione delle opzioni REBUILD e CONCATENATE. Il suo comportamento rimane lo stesso di Hive. |
| 3 | DROP TABLE Supportato. Comportamento uguale a Hive (rilascia la tabella e la struttura complete). |
| 4 | CREATE/ALTER/DROP VIEW Supportato. Comportamento uguale a Hive. Note - Pig e MapReduce non possono leggere o scrivere nelle viste. |
| 5 | SHOW TABLES Visualizza un elenco di tabelle. |
| 6 | SHOW PARTITIONS Visualizza un elenco di partizioni. |
| 7 | Create/Drop Index Le operazioni CREATE e DROP FUNCTION sono supportate, ma le funzioni create devono ancora essere registrate in Pig e collocate in CLASSPATH per MapReduce. |
| 8 | DESCRIBE Supportato. Comportamento uguale a Hive. Descrivi la struttura. |
Alcuni dei comandi della tabella sopra sono spiegati nei capitoli successivi.
Questo capitolo spiega come creare una tabella e come inserire dati in essa. Le convenzioni per la creazione di una tabella in HCatalog sono abbastanza simili alla creazione di una tabella tramite Hive.
Crea istruzione tabella
Crea tabella è un'istruzione utilizzata per creare una tabella nel metastore di Hive utilizzando HCatalog. La sua sintassi e l'esempio sono i seguenti:
Sintassi
CREATE [TEMPORARY] [EXTERNAL] TABLE [IF NOT EXISTS] [db_name.] table_name
[(col_name data_type [COMMENT col_comment], ...)]
[COMMENT table_comment]
[ROW FORMAT row_format]
[STORED AS file_format]Esempio
Supponiamo che sia necessario creare una tabella denominata employee utilizzando CREATE TABLEdichiarazione. La tabella seguente elenca i campi e i relativi tipi di dati nel fileemployee tavolo -
| Suor n | Nome campo | Tipo di dati |
|---|---|---|
| 1 | Eid | int |
| 2 | Nome | Corda |
| 3 | Stipendio | Galleggiante |
| 4 | Designazione | corda |
I seguenti dati definiscono i campi supportati come Comment, Campi formattati riga come Field terminator, Lines terminator, e Stored File type.
COMMENT ‘Employee details’
FIELDS TERMINATED BY ‘\t’
LINES TERMINATED BY ‘\n’
STORED IN TEXT FILELa query seguente crea una tabella denominata employee utilizzando i dati di cui sopra.
./hcat –e "CREATE TABLE IF NOT EXISTS employee ( eid int, name String,
salary String, destination String) \
COMMENT 'Employee details' \
ROW FORMAT DELIMITED \
FIELDS TERMINATED BY ‘\t’ \
LINES TERMINATED BY ‘\n’ \
STORED AS TEXTFILE;"Se aggiungi l'opzione IF NOT EXISTS, HCatalog ignora l'istruzione nel caso in cui la tabella esista già.
Dopo aver creato con successo la tabella, puoi vedere la seguente risposta:
OK
Time taken: 5.905 secondsIstruzione Load Data
Generalmente, dopo aver creato una tabella in SQL, possiamo inserire i dati utilizzando l'istruzione Insert. Ma in HCatalog, inseriamo i dati utilizzando l'istruzione LOAD DATA.
Durante l'inserimento dei dati in HCatalog, è preferibile utilizzare LOAD DATA per memorizzare i record di massa. Esistono due modi per caricare i dati: uno è dalocal file system e il secondo è da Hadoop file system.
Sintassi
La sintassi per LOAD DATA è la seguente:
LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename
[PARTITION (partcol1=val1, partcol2=val2 ...)]- LOCAL è l'identificatore per specificare il percorso locale. È opzionale.
- OVERWRITE è facoltativo per sovrascrivere i dati nella tabella.
- PARTITION è opzionale.
Esempio
Inseriremo i seguenti dati nella tabella. È un file di testo denominatosample.txt in /home/user directory.
1201 Gopal 45000 Technical manager
1202 Manisha 45000 Proof reader
1203 Masthanvali 40000 Technical writer
1204 Kiran 40000 Hr Admin
1205 Kranthi 30000 Op AdminLa seguente query carica il testo specificato nella tabella.
./hcat –e "LOAD DATA LOCAL INPATH '/home/user/sample.txt'
OVERWRITE INTO TABLE employee;"In caso di download riuscito, viene visualizzata la seguente risposta:
OK
Time taken: 15.905 secondsQuesto capitolo spiega come modificare gli attributi di una tabella, come cambiare il nome della tabella, cambiare i nomi delle colonne, aggiungere colonne e cancellare o sostituire le colonne.
Istruzione Alter Table
È possibile utilizzare l'istruzione ALTER TABLE per modificare una tabella in Hive.
Sintassi
L'istruzione accetta una delle seguenti sintassi in base agli attributi che desideriamo modificare in una tabella.
ALTER TABLE name RENAME TO new_name
ALTER TABLE name ADD COLUMNS (col_spec[, col_spec ...])
ALTER TABLE name DROP [COLUMN] column_name
ALTER TABLE name CHANGE column_name new_name new_type
ALTER TABLE name REPLACE COLUMNS (col_spec[, col_spec ...])Alcuni degli scenari sono spiegati di seguito.
Rename To ... Statement
La query seguente rinomina una tabella da employee per emp.
./hcat –e "ALTER TABLE employee RENAME TO emp;"Dichiarazione di modifica
La tabella seguente contiene i campi di employee tabella e mostra i campi da modificare (in grassetto).
| Nome campo | Converti da tipo di dati | Cambia nome campo | Converti in tipo di dati |
|---|---|---|---|
| eid | int | eid | int |
| nome | Corda | ename | Corda |
| stipendio | Galleggiante | stipendio | Doppio |
| designazione | Corda | designazione | Corda |
Le seguenti query rinominano il nome della colonna e il tipo di dati della colonna utilizzando i dati precedenti:
./hcat –e "ALTER TABLE employee CHANGE name ename String;"
./hcat –e "ALTER TABLE employee CHANGE salary salary Double;"Istruzione Aggiungi colonne
La query seguente aggiunge una colonna denominata dept al employee tavolo.
./hcat –e "ALTER TABLE employee ADD COLUMNS (dept STRING COMMENT 'Department name');"Sostituisci istruzione
La seguente query elimina tutte le colonne dal file employee table e lo sostituisce con emp e name colonne -
./hcat – e "ALTER TABLE employee REPLACE COLUMNS ( eid INT empid Int, ename STRING name String);"Istruzione Drop Table
Questo capitolo descrive come eliminare una tabella in HCatalog. Quando si rilascia una tabella dal metastore, vengono rimossi i dati della tabella / colonna e i relativi metadati. Può essere una tabella normale (memorizzata nel metastore) o una tabella esterna (memorizzata nel file system locale); HCatalog tratta entrambi allo stesso modo, indipendentemente dal tipo.
La sintassi è la seguente:
DROP TABLE [IF EXISTS] table_name;La query seguente elimina una tabella denominata employee -
./hcat –e "DROP TABLE IF EXISTS employee;"In caso di corretta esecuzione della query, viene visualizzata la seguente risposta:
OK
Time taken: 5.3 secondsQuesto capitolo descrive come creare e gestire un file viewin HCatalog. Le visualizzazioni del database vengono create utilizzando ilCREATE VIEWdichiarazione. Le visualizzazioni possono essere create da una singola tabella, più tabelle o un'altra visualizzazione.
Per creare una visualizzazione, un utente deve disporre dei privilegi di sistema appropriati in base all'implementazione specifica.
Crea istruzione vista
CREATE VIEWcrea una vista con il nome specificato. Viene generato un errore se esiste già una tabella o una vista con lo stesso nome. Puoi usareIF NOT EXISTS per saltare l'errore.
Se non vengono forniti nomi di colonna, i nomi delle colonne della vista verranno derivati automaticamente dal file defining SELECT expression.
Note - Se SELECT contiene espressioni scalari prive di alias come x + y, i nomi delle colonne della vista risultante verranno generati nella forma _C0, _C1, ecc.
Quando si rinominano le colonne, possono essere forniti anche commenti di colonna. I commenti non vengono ereditati automaticamente dalle colonne sottostanti.
Un'istruzione CREATE VIEW fallirà se la visualizzazione è defining SELECT expression è invalido.
Sintassi
CREATE VIEW [IF NOT EXISTS] [db_name.]view_name [(column_name [COMMENT column_comment], ...) ]
[COMMENT view_comment]
[TBLPROPERTIES (property_name = property_value, ...)]
AS SELECT ...;Esempio
Di seguito sono riportati i dati della tabella dei dipendenti. Vediamo ora come creare una vista denominataEmp_Deg_View contenente i campi id, nome, designazione e stipendio di un dipendente con uno stipendio superiore a 35.000.
+------+-------------+--------+-------------------+-------+
| ID | Name | Salary | Designation | Dept |
+------+-------------+--------+-------------------+-------+
| 1201 | Gopal | 45000 | Technical manager | TP |
| 1202 | Manisha | 45000 | Proofreader | PR |
| 1203 | Masthanvali | 30000 | Technical writer | TP |
| 1204 | Kiran | 40000 | Hr Admin | HR |
| 1205 | Kranthi | 30000 | Op Admin | Admin |
+------+-------------+--------+-------------------+-------+Quello che segue è il comando per creare una vista basata sui dati sopra indicati.
./hcat –e "CREATE VIEW Emp_Deg_View (salary COMMENT ' salary more than 35,000')
AS SELECT id, name, salary, designation FROM employee WHERE salary ≥ 35000;"Produzione
OK
Time taken: 5.3 secondsIstruzione Drop View
DROP VIEW rimuove i metadati per la vista specificata. Quando si rilascia una vista a cui fanno riferimento altre viste, non viene fornito alcun avviso (le viste dipendenti rimangono sospese come non valide e devono essere eliminate o ricreate dall'utente).
Sintassi
DROP VIEW [IF EXISTS] view_name;Esempio
Il comando seguente viene utilizzato per eliminare una vista denominata Emp_Deg_View.
DROP VIEW Emp_Deg_View;Spesso si desidera elencare tutte le tabelle in un database o elencare tutte le colonne in una tabella. Ovviamente, ogni database ha la propria sintassi per elencare le tabelle e le colonne.
Show Tablesistruzione mostra i nomi di tutte le tabelle. Per impostazione predefinita, elenca le tabelle dal database corrente o con l'estensioneIN clausola, in un database specificato.
Questo capitolo descrive come elencare tutte le tabelle dal database corrente in HCatalog.
Istruzione Mostra tabelle
La sintassi di SHOW TABLES è la seguente:
SHOW TABLES [IN database_name] ['identifier_with_wildcards'];La query seguente mostra un elenco di tabelle:
./hcat –e "Show tables;"In caso di corretta esecuzione della query, viene visualizzata la seguente risposta:
OK
emp
employee
Time taken: 5.3 secondsUna partizione è una condizione per i dati tabulari che viene utilizzata per creare una tabella o una vista separata. SHOW PARTITIONS elenca tutte le partizioni esistenti per una data tabella di base. Le partizioni sono elencate in ordine alfabetico. Dopo Hive 0.6, è anche possibile specificare parti di una specifica di partizione per filtrare l'elenco risultante.
È possibile utilizzare il comando MOSTRA PARTIZIONI per vedere le partizioni esistenti in una particolare tabella. Questo capitolo descrive come elencare le partizioni di una particolare tabella in HCatalog.
Show Partitions Statement
La sintassi è la seguente:
SHOW PARTITIONS table_name;La query seguente elimina una tabella denominata employee -
./hcat –e "Show partitions employee;"In caso di corretta esecuzione della query, viene visualizzata la seguente risposta:
OK
Designation = IT
Time taken: 5.3 secondsPartizione dinamica
HCatalog organizza le tabelle in partizioni. È un modo per dividere una tabella in parti correlate in base ai valori delle colonne partizionate come data, città e dipartimento. Utilizzando le partizioni, è facile interrogare una parte dei dati.
Ad esempio, una tabella denominata Tab1contiene i dati dei dipendenti come ID, nome, reparto e yoj (ad esempio, anno di adesione). Si supponga di dover recuperare i dettagli di tutti i dipendenti che hanno aderito nel 2012. Una query cerca le informazioni richieste nell'intera tabella. Tuttavia, se si partizionano i dati dei dipendenti con l'anno e li si memorizza in un file separato, si riduce il tempo di elaborazione delle query. L'esempio seguente mostra come partizionare un file e i suoi dati:
Il seguente file contiene employeedata tavolo.
/ tab1 / Employeedata / file1
id, name, dept, yoj
1, gopal, TP, 2012
2, kiran, HR, 2012
3, kaleel, SC, 2013
4, Prasanth, SC, 2013I dati di cui sopra vengono partizionati in due file utilizzando l'anno.
/ tab1 / Employeedata / 2012 / file2
1, gopal, TP, 2012
2, kiran, HR, 2012/ tab1 / Employeedata / 2013 / file3
3, kaleel, SC, 2013
4, Prasanth, SC, 2013Aggiunta di una partizione
Possiamo aggiungere partizioni a una tabella alterando la tabella. Supponiamo di avere una tabella chiamataemployee con campi come ID, Nome, Stipendio, Designazione, Reparto e yoj.
Sintassi
ALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION partition_spec
[LOCATION 'location1'] partition_spec [LOCATION 'location2'] ...;
partition_spec:
: (p_column = p_col_value, p_column = p_col_value, ...)La seguente query viene utilizzata per aggiungere una partizione al file employee tavolo.
./hcat –e "ALTER TABLE employee ADD PARTITION (year = '2013') location '/2012/part2012';"Ridenominazione di una partizione
È possibile utilizzare il comando RENAME-TO per rinominare una partizione. La sua sintassi è la seguente:
./hact –e "ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;"La seguente query viene utilizzata per rinominare una partizione:
./hcat –e "ALTER TABLE employee PARTITION (year=’1203’) RENAME TO PARTITION (Yoj='1203');"Eliminazione di una partizione
La sintassi del comando utilizzato per eliminare una partizione è la seguente:
./hcat –e "ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec,.
PARTITION partition_spec,...;"La seguente query viene utilizzata per eliminare una partizione:
./hcat –e "ALTER TABLE employee DROP [IF EXISTS] PARTITION (year=’1203’);"Creazione di un indice
Un indice non è altro che un puntatore su una particolare colonna di una tabella. Creare un indice significa creare un puntatore su una particolare colonna di una tabella. La sua sintassi è la seguente:
CREATE INDEX index_name
ON TABLE base_table_name (col_name, ...)
AS 'index.handler.class.name'
[WITH DEFERRED REBUILD]
[IDXPROPERTIES (property_name = property_value, ...)]
[IN TABLE index_table_name]
[PARTITIONED BY (col_name, ...)][
[ ROW FORMAT ...] STORED AS ...
| STORED BY ...
]
[LOCATION hdfs_path]
[TBLPROPERTIES (...)]Esempio
Facciamo un esempio per comprendere il concetto di indice. Usa lo stessoemployee tabella che abbiamo utilizzato in precedenza con i campi Id, Name, Stipendio, Designation e Dept. Crea un indice denominato index_salary sul salary colonna del employee tavolo.
La seguente query crea un indice:
./hcat –e "CREATE INDEX inedx_salary ON TABLE employee(salary)
AS 'org.apache.hadoop.hive.ql.index.compact.CompactIndexHandler';"È un puntatore a salarycolonna. Se la colonna viene modificata, le modifiche vengono memorizzate utilizzando un valore di indice.
Eliminazione di un indice
La seguente sintassi viene utilizzata per eliminare un indice:
DROP INDEX <index_name> ON <table_name>La query seguente elimina l'indice index_salary -
./hcat –e "DROP INDEX index_salary ON employee;"HCatalog contiene un'API di trasferimento dati per input e output paralleli senza utilizzare MapReduce. Questa API utilizza un'astrazione di archiviazione di base di tabelle e righe per leggere i dati dal cluster Hadoop e scrivere i dati in esso.
L'API di trasferimento dati contiene principalmente tre classi; quelli sono -
HCatReader - Legge i dati da un cluster Hadoop.
HCatWriter - Scrive i dati in un cluster Hadoop.
DataTransferFactory - Genera istanze di lettore e scrittore.
Questa API è adatta per la configurazione del nodo master-slave. Parliamo di più suHCatReader e HCatWriter.
HCatReader
HCatReader è una classe astratta interna a HCatalog e astrae le complessità del sistema sottostante da cui devono essere recuperati i record.
| S. No. | Nome e descrizione del metodo |
|---|---|
| 1 | Public abstract ReaderContext prepareRead() throws HCatException Questo dovrebbe essere chiamato al nodo master per ottenere ReaderContext che poi dovrebbe essere serializzato e inviato ai nodi slave. |
| 2 | Public abstract Iterator <HCatRecorder> read() throws HCaException Questo dovrebbe essere chiamato ai nodi slave per leggere HCatRecords. |
| 3 | Public Configuration getConf() Restituirà l'oggetto della classe di configurazione. |
La classe HCatReader viene utilizzata per leggere i dati da HDFS. La lettura è un processo in due fasi in cui il primo passaggio avviene sul nodo master di un sistema esterno. La seconda fase viene eseguita in parallelo su più nodi slave.
Le letture vengono eseguite su un file ReadEntity. Prima di iniziare a leggere, è necessario definire una ReadEntity da cui leggere. Questo può essere fatto tramiteReadEntity.Builder. È possibile specificare un nome di database, un nome di tabella, una partizione e una stringa di filtro. Ad esempio:
ReadEntity.Builder builder = new ReadEntity.Builder();
ReadEntity entity = builder.withDatabase("mydb").withTable("mytbl").build(); 10.Lo snippet di codice precedente definisce un oggetto ReadEntity ("entità"), che comprende una tabella denominata mytbl in un database denominato mydb, che può essere utilizzato per leggere tutte le righe di questa tabella. Notare che questa tabella deve esistere in HCatalog prima dell'inizio di questa operazione.
Dopo aver definito un ReadEntity, ottieni un'istanza di HCatReader utilizzando ReadEntity e la configurazione del cluster -
HCatReader reader = DataTransferFactory.getHCatReader(entity, config);Il passaggio successivo consiste nell'ottenere un ReaderContext dal lettore come segue:
ReaderContext cntxt = reader.prepareRead();HCatWriter
Questa astrazione è interna a HCatalog. Questo per facilitare la scrittura su HCatalog da sistemi esterni. Non provare a creare un'istanza direttamente. Utilizza invece DataTransferFactory.
| Sr.No. | Nome e descrizione del metodo |
|---|---|
| 1 | Public abstract WriterContext prepareRead() throws HCatException Il sistema esterno dovrebbe richiamare questo metodo esattamente una volta da un nodo master. Restituisce un fileWriterContext. Questo dovrebbe essere serializzato e inviato ai nodi slave per la costruzioneHCatWriter Là. |
| 2 | Public abstract void write(Iterator<HCatRecord> recordItr) throws HCaException Questo metodo dovrebbe essere utilizzato sui nodi slave per eseguire le scritture. RecordItr è un oggetto iteratore che contiene la raccolta di record da scrivere in HCatalog. |
| 3 | Public abstract void abort(WriterContext cntxt) throws HCatException Questo metodo dovrebbe essere chiamato nel nodo master. Lo scopo principale di questo metodo è eseguire le pulizie in caso di errori. |
| 4 | public abstract void commit(WriterContext cntxt) throws HCatException Questo metodo dovrebbe essere chiamato nel nodo master. Lo scopo di questo metodo è eseguire il commit dei metadati. |
Simile alla lettura, anche la scrittura è un processo in due fasi in cui il primo passaggio avviene sul nodo master. Successivamente, la seconda fase avviene in parallelo sui nodi slave.
Le scritture vengono eseguite su un file WriteEntity che può essere costruito in un modo simile alle letture -
WriteEntity.Builder builder = new WriteEntity.Builder();
WriteEntity entity = builder.withDatabase("mydb").withTable("mytbl").build();Il codice precedente crea un oggetto WriteEntity entityche può essere utilizzato per scrivere in una tabella denominatamytbl nel database mydb.
Dopo aver creato un WriteEntity, il passaggio successivo è ottenere un WriterContext -
HCatWriter writer = DataTransferFactory.getHCatWriter(entity, config);
WriterContext info = writer.prepareWrite();Tutti i passaggi precedenti si verificano sul nodo master. Il nodo master serializza quindi l'oggetto WriterContext e lo rende disponibile a tutti gli slave.
Sui nodi slave, è necessario ottenere un HCatWriter utilizzando WriterContext come segue:
HCatWriter writer = DataTransferFactory.getHCatWriter(context);Poi il writeraccetta un iteratore come argomento per il writemetodo -
writer.write(hCatRecordItr);Il writer poi chiama getNext() su questo iteratore in un ciclo e scrive tutti i record allegati all'iteratore.
Il TestReaderWriter.javaviene utilizzato per testare le classi HCatreader e HCatWriter. Il seguente programma dimostra come utilizzare HCatReader e HCatWriter API per leggere i dati da un file di origine e successivamente scriverli su un file di destinazione.
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hive.metastore.api.MetaException;
import org.apache.hadoop.hive.ql.CommandNeedRetryException;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hive.HCatalog.common.HCatException;
import org.apache.hive.HCatalog.data.transfer.DataTransferFactory;
import org.apache.hive.HCatalog.data.transfer.HCatReader;
import org.apache.hive.HCatalog.data.transfer.HCatWriter;
import org.apache.hive.HCatalog.data.transfer.ReadEntity;
import org.apache.hive.HCatalog.data.transfer.ReaderContext;
import org.apache.hive.HCatalog.data.transfer.WriteEntity;
import org.apache.hive.HCatalog.data.transfer.WriterContext;
import org.apache.hive.HCatalog.mapreduce.HCatBaseTest;
import org.junit.Assert;
import org.junit.Test;
public class TestReaderWriter extends HCatBaseTest {
@Test
public void test() throws MetaException, CommandNeedRetryException,
IOException, ClassNotFoundException {
driver.run("drop table mytbl");
driver.run("create table mytbl (a string, b int)");
Iterator<Entry<String, String>> itr = hiveConf.iterator();
Map<String, String> map = new HashMap<String, String>();
while (itr.hasNext()) {
Entry<String, String> kv = itr.next();
map.put(kv.getKey(), kv.getValue());
}
WriterContext cntxt = runsInMaster(map);
File writeCntxtFile = File.createTempFile("hcat-write", "temp");
writeCntxtFile.deleteOnExit();
// Serialize context.
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(writeCntxtFile));
oos.writeObject(cntxt);
oos.flush();
oos.close();
// Now, deserialize it.
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(writeCntxtFile));
cntxt = (WriterContext) ois.readObject();
ois.close();
runsInSlave(cntxt);
commit(map, true, cntxt);
ReaderContext readCntxt = runsInMaster(map, false);
File readCntxtFile = File.createTempFile("hcat-read", "temp");
readCntxtFile.deleteOnExit();
oos = new ObjectOutputStream(new FileOutputStream(readCntxtFile));
oos.writeObject(readCntxt);
oos.flush();
oos.close();
ois = new ObjectInputStream(new FileInputStream(readCntxtFile));
readCntxt = (ReaderContext) ois.readObject();
ois.close();
for (int i = 0; i < readCntxt.numSplits(); i++) {
runsInSlave(readCntxt, i);
}
}
private WriterContext runsInMaster(Map<String, String> config) throws HCatException {
WriteEntity.Builder builder = new WriteEntity.Builder();
WriteEntity entity = builder.withTable("mytbl").build();
HCatWriter writer = DataTransferFactory.getHCatWriter(entity, config);
WriterContext info = writer.prepareWrite();
return info;
}
private ReaderContext runsInMaster(Map<String, String> config,
boolean bogus) throws HCatException {
ReadEntity entity = new ReadEntity.Builder().withTable("mytbl").build();
HCatReader reader = DataTransferFactory.getHCatReader(entity, config);
ReaderContext cntxt = reader.prepareRead();
return cntxt;
}
private void runsInSlave(ReaderContext cntxt, int slaveNum) throws HCatException {
HCatReader reader = DataTransferFactory.getHCatReader(cntxt, slaveNum);
Iterator<HCatRecord> itr = reader.read();
int i = 1;
while (itr.hasNext()) {
HCatRecord read = itr.next();
HCatRecord written = getRecord(i++);
// Argh, HCatRecord doesnt implement equals()
Assert.assertTrue("Read: " + read.get(0) + "Written: " + written.get(0),
written.get(0).equals(read.get(0)));
Assert.assertTrue("Read: " + read.get(1) + "Written: " + written.get(1),
written.get(1).equals(read.get(1)));
Assert.assertEquals(2, read.size());
}
//Assert.assertFalse(itr.hasNext());
}
private void runsInSlave(WriterContext context) throws HCatException {
HCatWriter writer = DataTransferFactory.getHCatWriter(context);
writer.write(new HCatRecordItr());
}
private void commit(Map<String, String> config, boolean status,
WriterContext context) throws IOException {
WriteEntity.Builder builder = new WriteEntity.Builder();
WriteEntity entity = builder.withTable("mytbl").build();
HCatWriter writer = DataTransferFactory.getHCatWriter(entity, config);
if (status) {
writer.commit(context);
} else {
writer.abort(context);
}
}
private static HCatRecord getRecord(int i) {
List<Object> list = new ArrayList<Object>(2);
list.add("Row #: " + i);
list.add(i);
return new DefaultHCatRecord(list);
}
private static class HCatRecordItr implements Iterator<HCatRecord> {
int i = 0;
@Override
public boolean hasNext() {
return i++ < 100 ? true : false;
}
@Override
public HCatRecord next() {
return getRecord(i);
}
@Override
public void remove() {
throw new RuntimeException();
}
}
}Il programma precedente legge i dati dall'HDFS sotto forma di record e scrive i dati del record in mytable
Il HCatInputFormat e HCatOutputFormatle interfacce vengono utilizzate per leggere i dati da HDFS e, dopo l'elaborazione, scrivere i dati risultanti in HDFS utilizzando il lavoro MapReduce. Elaboriamo le interfacce dei formati di input e output.
HCatInputFormat
Il HCatInputFormatviene utilizzato con i lavori MapReduce per leggere i dati dalle tabelle gestite da HCatalog. HCatInputFormat espone un'API MapReduce di Hadoop 0.20 per la lettura dei dati come se fossero stati pubblicati in una tabella.
| Sr.No. | Nome e descrizione del metodo |
|---|---|
| 1 | public static HCatInputFormat setInput(Job job, String dbName, String tableName)throws IOException Imposta gli input da utilizzare per il lavoro. Interroga il metastore con la specifica di input fornita e serializza le partizioni corrispondenti nella configurazione del lavoro per le attività MapReduce. |
| 2 | public static HCatInputFormat setInput(Configuration conf, String dbName, String tableName) throws IOException Imposta gli input da utilizzare per il lavoro. Interroga il metastore con la specifica di input fornita e serializza le partizioni corrispondenti nella configurazione del lavoro per le attività MapReduce. |
| 3 | public HCatInputFormat setFilter(String filter)throws IOException Imposta un filtro nella tabella di input. |
| 4 | public HCatInputFormat setProperties(Properties properties) throws IOException Imposta le proprietà per il formato di input. |
L'API HCatInputFormat include i seguenti metodi:
- setInput
- setOutputSchema
- getTableSchema
Usare HCatInputFormat per leggere i dati, creare prima un'istanza di un file InputJobInfo con le informazioni necessarie dalla tabella in fase di lettura e quindi chiamare setInput con il InputJobInfo.
Puoi usare il file setOutputSchema metodo per includere un file projection schema, per specificare i campi di output. Se non viene specificato uno schema, verranno restituite tutte le colonne nella tabella. È possibile utilizzare il metodo getTableSchema per determinare lo schema della tabella per una tabella di input specificata.
HCatOutputFormat
HCatOutputFormat viene utilizzato con i lavori MapReduce per scrivere dati nelle tabelle gestite da HCatalog. HCatOutputFormat espone un'API MapReduce di Hadoop 0.20 per la scrittura di dati in una tabella. Quando un lavoro MapReduce utilizza HCatOutputFormat per scrivere l'output, viene utilizzato il formato OutputFormat predefinito configurato per la tabella e la nuova partizione viene pubblicata nella tabella al termine del lavoro.
| Sr.No. | Nome e descrizione del metodo |
|---|---|
| 1 | public static void setOutput (Configuration conf, Credentials credentials, OutputJobInfo outputJobInfo) throws IOException Impostare le informazioni sull'output da scrivere per il lavoro. Interroga il server dei metadati per trovare lo StorageHandler da utilizzare per la tabella. Genera un errore se la partizione è già pubblicata. |
| 2 | public static void setSchema (Configuration conf, HCatSchema schema) throws IOException Imposta lo schema per i dati da scrivere nella partizione. Lo schema della tabella viene utilizzato per impostazione predefinita per la partizione se non viene chiamato. |
| 3 | public RecordWriter <WritableComparable<?>, HCatRecord > getRecordWriter (TaskAttemptContext context)throws IOException, InterruptedException Ottieni lo scrittore di dischi per il lavoro. Utilizza OutputFormat predefinito di StorageHandler per ottenere il writer di record. |
| 4 | public OutputCommitter getOutputCommitter (TaskAttemptContext context) throws IOException, InterruptedException Ottieni il committer di output per questo formato di output. Assicura che l'output venga eseguito correttamente. |
Il HCatOutputFormat L'API include i seguenti metodi:
- setOutput
- setSchema
- getTableSchema
La prima chiamata su HCatOutputFormat deve essere setOutput; qualsiasi altra chiamata genererà un'eccezione dicendo che il formato di output non è inizializzato.
Lo schema per i dati da scrivere è specificato da setSchemametodo. È necessario chiamare questo metodo, fornendo lo schema dei dati che si sta scrivendo. Se i tuoi dati hanno lo stesso schema dello schema della tabella, puoi usareHCatOutputFormat.getTableSchema() per ottenere lo schema della tabella e quindi passarlo a setSchema().
Esempio
Il seguente programma MapReduce legge i dati da una tabella che presume abbia un numero intero nella seconda colonna ("colonna 1") e conta quante istanze di ciascun valore distinto trova. Cioè, fa l'equivalente di "select col1, count(*) from $table group by col1;".
Ad esempio, se i valori nella seconda colonna sono {1, 1, 1, 3, 3, 5}, il programma produrrà il seguente output di valori e conteggi:
1, 3
3, 2
5, 1Diamo ora un'occhiata al codice del programma:
import java.io.IOException;
import java.util.Iterator;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import org.apache.HCatalog.common.HCatConstants;
import org.apache.HCatalog.data.DefaultHCatRecord;
import org.apache.HCatalog.data.HCatRecord;
import org.apache.HCatalog.data.schema.HCatSchema;
import org.apache.HCatalog.mapreduce.HCatInputFormat;
import org.apache.HCatalog.mapreduce.HCatOutputFormat;
import org.apache.HCatalog.mapreduce.InputJobInfo;
import org.apache.HCatalog.mapreduce.OutputJobInfo;
public class GroupByAge extends Configured implements Tool {
public static class Map extends Mapper<WritableComparable,
HCatRecord, IntWritable, IntWritable> {
int age;
@Override
protected void map(
WritableComparable key, HCatRecord value,
org.apache.hadoop.mapreduce.Mapper<WritableComparable,
HCatRecord, IntWritable, IntWritable>.Context context
)throws IOException, InterruptedException {
age = (Integer) value.get(1);
context.write(new IntWritable(age), new IntWritable(1));
}
}
public static class Reduce extends Reducer<IntWritable, IntWritable,
WritableComparable, HCatRecord> {
@Override
protected void reduce(
IntWritable key, java.lang.Iterable<IntWritable> values,
org.apache.hadoop.mapreduce.Reducer<IntWritable, IntWritable,
WritableComparable, HCatRecord>.Context context
)throws IOException ,InterruptedException {
int sum = 0;
Iterator<IntWritable> iter = values.iterator();
while (iter.hasNext()) {
sum++;
iter.next();
}
HCatRecord record = new DefaultHCatRecord(2);
record.set(0, key.get());
record.set(1, sum);
context.write(null, record);
}
}
public int run(String[] args) throws Exception {
Configuration conf = getConf();
args = new GenericOptionsParser(conf, args).getRemainingArgs();
String serverUri = args[0];
String inputTableName = args[1];
String outputTableName = args[2];
String dbName = null;
String principalID = System
.getProperty(HCatConstants.HCAT_METASTORE_PRINCIPAL);
if (principalID != null)
conf.set(HCatConstants.HCAT_METASTORE_PRINCIPAL, principalID);
Job job = new Job(conf, "GroupByAge");
HCatInputFormat.setInput(job, InputJobInfo.create(dbName, inputTableName, null));
// initialize HCatOutputFormat
job.setInputFormatClass(HCatInputFormat.class);
job.setJarByClass(GroupByAge.class);
job.setMapperClass(Map.class);
job.setReducerClass(Reduce.class);
job.setMapOutputKeyClass(IntWritable.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(WritableComparable.class);
job.setOutputValueClass(DefaultHCatRecord.class);
HCatOutputFormat.setOutput(job, OutputJobInfo.create(dbName, outputTableName, null));
HCatSchema s = HCatOutputFormat.getTableSchema(job);
System.err.println("INFO: output schema explicitly set for writing:" + s);
HCatOutputFormat.setSchema(job, s);
job.setOutputFormatClass(HCatOutputFormat.class);
return (job.waitForCompletion(true) ? 0 : 1);
}
public static void main(String[] args) throws Exception {
int exitCode = ToolRunner.run(new GroupByAge(), args);
System.exit(exitCode);
}
}Prima di compilare il programma sopra, devi scaricarne alcuni jars e aggiungili al file classpathper questa applicazione. Devi scaricare tutti i jar Hive e HCatalog (HCatalog-core-0.5.0.jar, hive-metastore-0.10.0.jar, libthrift-0.7.0.jar, hive-exec-0.10.0.jar, libfb303-0.7.0.jar, jdo2-api-2.3-ec.jar, slf4j-api-1.6.1.jar).
Usa i seguenti comandi per copiarli jar file da local per HDFS e aggiungili al file classpath.
bin/hadoop fs -copyFromLocal $HCAT_HOME/share/HCatalog/HCatalog-core-0.5.0.jar /tmp bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/hive-metastore-0.10.0.jar /tmp
bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/libthrift-0.7.0.jar /tmp bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/hive-exec-0.10.0.jar /tmp
bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/libfb303-0.7.0.jar /tmp bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/jdo2-api-2.3-ec.jar /tmp
bin/hadoop fs -copyFromLocal $HIVE_HOME/lib/slf4j-api-1.6.1.jar /tmp
export LIB_JARS=hdfs:///tmp/HCatalog-core-0.5.0.jar,
hdfs:///tmp/hive-metastore-0.10.0.jar,
hdfs:///tmp/libthrift-0.7.0.jar,
hdfs:///tmp/hive-exec-0.10.0.jar,
hdfs:///tmp/libfb303-0.7.0.jar,
hdfs:///tmp/jdo2-api-2.3-ec.jar,
hdfs:///tmp/slf4j-api-1.6.1.jarUtilizzare il seguente comando per compilare ed eseguire il programma dato.
$HADOOP_HOME/bin/hadoop jar GroupByAge tmp/hiveOra controlla la tua directory di output (hdfs: user / tmp / hive) per l'output (part_0000, part_0001).
Il HCatLoader e HCatStorerLe API vengono utilizzate con gli script Pig per leggere e scrivere dati nelle tabelle gestite da HCatalog. Per queste interfacce non è richiesta alcuna configurazione specifica di HCatalog.
È meglio avere una certa conoscenza degli script di Apache Pig per capire meglio questo capitolo. Per ulteriore riferimento, segui il nostro tutorial su Apache Pig .
HCatloader
HCatLoader viene utilizzato con gli script Pig per leggere i dati dalle tabelle gestite da HCatalog. Utilizzare la sintassi seguente per caricare i dati in HDFS utilizzando HCatloader.
A = LOAD 'tablename' USING org.apache.HCatalog.pig.HCatLoader();È necessario specificare il nome della tabella tra virgolette singole: LOAD 'tablename'. Se stai utilizzando un database non predefinito, devi specificare il tuo input come "dbname.tablename'.
Il metastore Hive consente di creare tabelle senza specificare un database. Se hai creato tabelle in questo modo, il nome del database è'default' e non è richiesto quando si specifica la tabella per HCatLoader.
La tabella seguente contiene i metodi importanti e la descrizione della classe HCatloader.
| Sr.No. | Nome e descrizione del metodo |
|---|---|
| 1 | public InputFormat<?,?> getInputFormat()throws IOException Leggere il formato di input dei dati di caricamento utilizzando la classe HCatloader. |
| 2 | public String relativeToAbsolutePath(String location, Path curDir) throws IOException Restituisce il formato String di Absolute path. |
| 3 | public void setLocation(String location, Job job) throws IOException Imposta la posizione in cui il lavoro può essere eseguito. |
| 4 | public Tuple getNext() throws IOException Restituisce la tupla corrente (key e value) dal ciclo. |
HCatStorer
HCatStorer viene utilizzato con gli script Pig per scrivere dati nelle tabelle gestite da HCatalog. Utilizzare la seguente sintassi per l'operazione di memorizzazione.
A = LOAD ...
B = FOREACH A ...
...
...
my_processed_data = ...
STORE my_processed_data INTO 'tablename' USING org.apache.HCatalog.pig.HCatStorer();È necessario specificare il nome della tabella tra virgolette singole: LOAD 'tablename'. Sia il database che la tabella devono essere creati prima di eseguire lo script Pig. Se stai usando un database non predefinito, devi specificare il tuo input come'dbname.tablename'.
Il metastore Hive consente di creare tabelle senza specificare un database. Se hai creato tabelle in questo modo, il nome del database è'default' e non è necessario specificare il nome del database nel file store dichiarazione.
Per il USINGclausola, puoi avere un argomento stringa che rappresenta le coppie chiave / valore per le partizioni. Questo è un argomento obbligatorio quando si scrive su una tabella partizionata e la colonna della partizione non è nella colonna di output. I valori per le chiavi di partizione NON devono essere quotati.
La tabella seguente contiene i metodi importanti e la descrizione della classe HCatStorer.
| Sr.No. | Nome e descrizione del metodo |
|---|---|
| 1 | public OutputFormat getOutputFormat() throws IOException Leggere il formato di output dei dati memorizzati utilizzando la classe HCatStorer. |
| 2 | public void setStoreLocation (String location, Job job) throws IOException Imposta la posizione in cui eseguirlo store applicazione. |
| 3 | public void storeSchema (ResourceSchema schema, String arg1, Job job) throws IOException Memorizza lo schema. |
| 4 | public void prepareToWrite (RecordWriter writer) throws IOException Aiuta a scrivere dati in un particolare file utilizzando RecordWriter. |
| 5 | public void putNext (Tuple tuple) throws IOException Scrive i dati della tupla nel file. |
Esecuzione di maiale con HCatalog
Il maiale non preleva automaticamente i barattoli di HCatalog. Per portare i barattoli necessari, puoi usare un flag nel comando Pig o impostare le variabili d'ambientePIG_CLASSPATH e PIG_OPTS come descritto sotto.
Per portare i barattoli appropriati per lavorare con HCatalog, includi semplicemente il seguente flag:
pig –useHCatalog <Sample pig scripts file>Impostazione di CLASSPATH per l'esecuzione
Utilizzare la seguente impostazione CLASSPATH per sincronizzare HCatalog con Apache Pig.
export HADOOP_HOME = <path_to_hadoop_install>
export HIVE_HOME = <path_to_hive_install>
export HCAT_HOME = <path_to_hcat_install>
export PIG_CLASSPATH = $HCAT_HOME/share/HCatalog/HCatalog-core*.jar:\ $HCAT_HOME/share/HCatalog/HCatalog-pig-adapter*.jar:\
$HIVE_HOME/lib/hive-metastore-*.jar:$HIVE_HOME/lib/libthrift-*.jar:\
$HIVE_HOME/lib/hive-exec-*.jar:$HIVE_HOME/lib/libfb303-*.jar:\
$HIVE_HOME/lib/jdo2-api-*-ec.jar:$HIVE_HOME/conf:$HADOOP_HOME/conf:\ $HIVE_HOME/lib/slf4j-api-*.jarEsempio
Supponiamo di avere un file student_details.txt in HDFS con il seguente contenuto.
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, ChennaiAbbiamo anche uno script di esempio con il nome sample_script.pig, nella stessa directory HDFS. Questo file contiene istruzioni che eseguono operazioni e trasformazioni sustudent relazione, come mostrato di seguito.
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;
STORE student_order INTO 'student_order_table' USING org.apache.HCatalog.pig.HCatStorer();
student_limit = LIMIT student_order 4;
Dump student_limit;La prima istruzione dello script caricherà i dati nel file denominato student_details.txt come una relazione denominata student.
La seconda istruzione dello script disporrà le tuple della relazione in ordine decrescente, in base all'età, e la memorizzerà come student_order.
La terza dichiarazione memorizza i dati elaborati student_order risulta in una tabella separata denominata student_order_table.
La quarta istruzione dello script memorizzerà le prime quattro tuple di student_order come student_limit.
Infine la quinta affermazione scaricherà il contenuto della relazione student_limit.
Eseguiamo ora il file sample_script.pig come mostrato di seguito.
$./pig -useHCatalog hdfs://localhost:9000/pig_data/sample_script.pigOra controlla la tua directory di output (hdfs: user / tmp / hive) per l'output (part_0000, part_0001).