Sqoop - Kurzanleitung

Das traditionelle Anwendungsverwaltungssystem, dh die Interaktion von Anwendungen mit relationalen Datenbanken mithilfe von RDBMS, ist eine der Quellen, die Big Data generieren. Solche von RDBMS generierten Big Data werden in Relational gespeichertDatabase Servers in der relationalen Datenbankstruktur.

Als Big Data-Speicher und -Analysatoren wie MapReduce, Hive, HBase, Cassandra, Pig usw. des Hadoop-Ökosystems ins Bild kamen, benötigten sie ein Tool für die Interaktion mit den relationalen Datenbankservern, um die darin enthaltenen Big Data zu importieren und zu exportieren. Hier nimmt Sqoop einen Platz im Hadoop-Ökosystem ein, um eine praktikable Interaktion zwischen dem relationalen Datenbankserver und dem HDFS von Hadoop zu ermöglichen.

Sqoop - "SQL zu Hadoop und Hadoop zu SQL"

Sqoop ist ein Tool zum Übertragen von Daten zwischen Hadoop und relationalen Datenbankservern. Es wird verwendet, um Daten aus relationalen Datenbanken wie MySQL, Oracle in Hadoop HDFS zu importieren und aus dem Hadoop-Dateisystem in relationale Datenbanken zu exportieren. Es wird von der Apache Software Foundation bereitgestellt.

Wie funktioniert Sqoop?

Das folgende Bild beschreibt den Workflow von Sqoop.

Sqoop Import

Das Import-Tool importiert einzelne Tabellen aus RDBMS in HDFS. Jede Zeile in einer Tabelle wird in HDFS als Datensatz behandelt. Alle Datensätze werden als Textdaten in Textdateien oder als Binärdaten in Avro- und Sequenzdateien gespeichert.

Sqoop Export

Das Export-Tool exportiert eine Reihe von Dateien aus HDFS zurück in ein RDBMS. Die als Eingabe für Sqoop angegebenen Dateien enthalten Datensätze, die als Zeilen in der Tabelle aufgerufen werden. Diese werden gelesen und in eine Reihe von Datensätzen analysiert und mit einem benutzerdefinierten Trennzeichen begrenzt.

Da Sqoop ein Teilprojekt von Hadoop ist, kann es nur unter Linux funktionieren. Führen Sie die folgenden Schritte aus, um Sqoop auf Ihrem System zu installieren.

Schritt 1: Überprüfen der JAVA-Installation

Vor der Installation von Sqoop muss Java auf Ihrem System installiert sein. Lassen Sie uns die Java-Installation mit dem folgenden Befehl überprüfen:

$ java –version

Wenn Java bereits auf Ihrem System installiert ist, wird die folgende Antwort angezeigt:

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)

Wenn Java nicht auf Ihrem System installiert ist, führen Sie die folgenden Schritte aus.

Java installieren

Befolgen Sie die folgenden einfachen Schritte, um Java auf Ihrem System zu installieren.

Schritt 1

Laden Sie Java (JDK <neueste Version> - X64.tar.gz) über den folgenden Link herunter .

Dann wird jdk-7u71-linux-x64.tar.gz auf Ihr System heruntergeladen.

Schritt 2

Im Allgemeinen finden Sie die heruntergeladene Java-Datei im Ordner Downloads. Überprüfen Sie dies und extrahieren Sie die Datei jdk-7u71-linux-x64.gz mit den folgenden Befehlen.

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

Schritt 3

Um Java allen Benutzern zur Verfügung zu stellen, müssen Sie es an den Speicherort "/ usr / local /" verschieben. Öffnen Sie root und geben Sie die folgenden Befehle ein.

$ su
password:

# mv jdk1.7.0_71 /usr/local/java
# exitStep IV:

Schritt 4

Fügen Sie zum Einrichten der Variablen PATH und JAVA_HOME die folgenden Befehle zur Datei ~ / .bashrc hinzu.

export JAVA_HOME=/usr/local/java
export PATH=$PATH:$JAVA_HOME/bin

Übernehmen Sie nun alle Änderungen in das aktuell laufende System.

$ source ~/.bashrc

Schritt 5

Verwenden Sie die folgenden Befehle, um Java-Alternativen zu konfigurieren:

# alternatives --install /usr/bin/java java usr/local/java/bin/java 2
# alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2
# alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2

# alternatives --set java usr/local/java/bin/java
# alternatives --set javac usr/local/java/bin/javac
# alternatives --set jar usr/local/java/bin/jar

Überprüfen Sie nun die Installation mit dem Befehl java -version vom Terminal wie oben erklärt.

Schritt 2: Überprüfen der Hadoop-Installation

Hadoop muss vor der Installation von Sqoop auf Ihrem System installiert sein. Lassen Sie uns die Hadoop-Installation mit dem folgenden Befehl überprüfen:

$ hadoop version

Wenn Hadoop bereits auf Ihrem System installiert ist, erhalten Sie die folgende Antwort:

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

Wenn Hadoop nicht auf Ihrem System installiert ist, fahren Sie mit den folgenden Schritten fort:

Hadoop herunterladen

Laden Sie Hadoop 2.4.1 mit den folgenden Befehlen von Apache Software Foundation herunter und extrahieren Sie es.

$ su
password:

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

Installieren von Hadoop im Pseudo Distributed Mode

Führen Sie die folgenden Schritte aus, um Hadoop 2.4.1 im pseudoverteilten Modus zu installieren.

Schritt 1: Hadoop einrichten

Sie können Hadoop-Umgebungsvariablen festlegen, indem Sie die folgenden Befehle an die Datei ~ / .bashrc anhängen.

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

Übernehmen Sie nun alle Änderungen in das aktuell ausgeführte System.

$ source ~/.bashrc

Schritt 2: Hadoop-Konfiguration

Sie finden alle Hadoop-Konfigurationsdateien unter dem Speicherort "$ HADOOP_HOME / etc / hadoop". Sie müssen geeignete Änderungen an diesen Konfigurationsdateien entsprechend Ihrer Hadoop-Infrastruktur vornehmen.

$ cd $HADOOP_HOME/etc/hadoop

Um Hadoop-Programme mit Java zu entwickeln, müssen Sie die Java-Umgebungsvariablen in zurücksetzen hadoop-env.sh Datei durch Ersetzen des JAVA_HOME-Werts durch den Speicherort von Java in Ihrem System.

export JAVA_HOME=/usr/local/java

Im Folgenden finden Sie eine Liste der Dateien, die Sie zum Konfigurieren von Hadoop bearbeiten müssen.

core-site.xml

Die Datei core-site.xml enthält Informationen wie die für die Hadoop-Instanz verwendete Portnummer, den für das Dateisystem zugewiesenen Speicher, das Speicherlimit zum Speichern der Daten und die Größe der Lese- / Schreibpuffer.

Öffnen Sie die Datei core-site.xml und fügen Sie die folgenden Eigenschaften zwischen den Tags <configuration> und </ configuration> hinzu.

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

hdfs-site.xml

Die Datei hdfs-site.xml enthält Informationen wie den Wert der Replikationsdaten, den Namensknotenpfad und den Datenknotenpfad Ihrer lokalen Dateisysteme. Dies ist der Ort, an dem Sie die Hadoop-Infrastruktur speichern möchten.

Nehmen wir die folgenden Daten an.

dfs.replication (data replication value) = 1

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

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

Öffnen Sie diese Datei und fügen Sie die folgenden Eigenschaften zwischen den Tags <configuration>, </ configuration> in dieser Datei hinzu.

<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 - In der obigen Datei sind alle Eigenschaftswerte benutzerdefiniert und Sie können Änderungen entsprechend Ihrer Hadoop-Infrastruktur vornehmen.

yarn-site.xml

Diese Datei wird verwendet, um Garn in Hadoop zu konfigurieren. Öffnen Sie die Datei yarn-site.xml und fügen Sie die folgenden Eigenschaften zwischen den Tags <configuration>, </ configuration> in dieser Datei hinzu.

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

mapred-site.xml

Diese Datei wird verwendet, um anzugeben, welches MapReduce-Framework wir verwenden. Standardmäßig enthält Hadoop eine Vorlage von yarn-site.xml. Zunächst müssen Sie die Datei mit dem folgenden Befehl von mapred-site.xml.template in die Datei mapred-site.xml kopieren.

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

Öffnen Sie die Datei mapred-site.xml und fügen Sie die folgenden Eigenschaften zwischen den Tags <configuration>, </ configuration> in dieser Datei hinzu.

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

Überprüfen der Hadoop-Installation

Die folgenden Schritte werden verwendet, um die Hadoop-Installation zu überprüfen.

Schritt 1: Namensknoten-Setup

Richten Sie den Namensknoten mit dem Befehl "hdfs namenode -format" wie folgt ein.

$ cd ~
$ hdfs namenode -format

Das erwartete Ergebnis ist wie folgt.

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

Schritt 2: Überprüfen von Hadoop dfs

Der folgende Befehl wird verwendet, um dfs zu starten. Durch Ausführen dieses Befehls wird Ihr Hadoop-Dateisystem gestartet.

$ start-dfs.sh

Die erwartete Ausgabe ist wie folgt:

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]

Schritt 3: Überprüfen des Garnskripts

Der folgende Befehl wird verwendet, um das Garnskript zu starten. Wenn Sie diesen Befehl ausführen, werden Ihre Garn-Dämonen gestartet.

$ start-yarn.sh

Die erwartete Ausgabe ist wie folgt:

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

Schritt 4: Zugriff auf Hadoop über den Browser

Die Standardportnummer für den Zugriff auf Hadoop ist 50070. Verwenden Sie die folgende URL, um Hadoop-Dienste in Ihrem Browser abzurufen.

http://localhost:50070/

Das folgende Bild zeigt einen Hadoop-Browser.

Schritt 5: Überprüfen Sie alle Anwendungen für Cluster

Die Standardportnummer für den Zugriff auf alle Anwendungen des Clusters lautet 8088. Verwenden Sie die folgende URL, um diesen Dienst aufzurufen.

http://localhost:8088/

Das folgende Bild zeigt den Hadoop-Cluster-Browser.

Schritt 3: Herunterladen von Sqoop

Wir können die neueste Version von Sqoop über den folgenden Link herunterladen. Für dieses Tutorial verwenden wir Version 1.4.5, d. H.sqoop-1.4.5.bin__hadoop-2.0.4-alpha.tar.gz.

Schritt 4: Sqoop installieren

Die folgenden Befehle werden verwendet, um den Sqoop-Teerball zu extrahieren und in das Verzeichnis "/ usr / lib / sqoop" zu verschieben.

$tar -xvf sqoop-1.4.4.bin__hadoop-2.0.4-alpha.tar.gz
$ su
password:

# mv sqoop-1.4.4.bin__hadoop-2.0.4-alpha /usr/lib/sqoop
#exit

Schritt 5: Konfigurieren von bashrc

Sie müssen die Sqoop-Umgebung einrichten, indem Sie die folgenden Zeilen an ~ / anhängen.bashrc Datei -

#Sqoop
export SQOOP_HOME=/usr/lib/sqoop export PATH=$PATH:$SQOOP_HOME/bin

Der folgende Befehl wird verwendet, um ~ / auszuführen.bashrc Datei.

$ source ~/.bashrc

Schritt 6: Konfigurieren von Sqoop

Um Sqoop mit Hadoop zu konfigurieren, müssen Sie das bearbeiten sqoop-env.sh Datei, die in der platziert wird $SQOOP_HOME/confVerzeichnis. Leiten Sie zunächst in das Sqoop-Konfigurationsverzeichnis um und kopieren Sie die Vorlagendatei mit dem folgenden Befehl:

$ cd $SQOOP_HOME/conf
$ mv sqoop-env-template.sh sqoop-env.sh

Öffnen sqoop-env.sh und bearbeiten Sie die folgenden Zeilen -

export HADOOP_COMMON_HOME=/usr/local/hadoop 
export HADOOP_MAPRED_HOME=/usr/local/hadoop

Schritt 7: Laden Sie mysql-connector-java herunter und konfigurieren Sie es

Wir können herunterladen mysql-connector-java-5.1.30.tar.gzDatei über den folgenden Link .

Die folgenden Befehle werden verwendet, um mysql-connector-java tarball zu extrahieren und zu verschieben mysql-connector-java-5.1.30-bin.jar in das Verzeichnis / usr / lib / sqoop / lib.

$ tar -zxf mysql-connector-java-5.1.30.tar.gz
$ su
password:

# cd mysql-connector-java-5.1.30
# mv mysql-connector-java-5.1.30-bin.jar /usr/lib/sqoop/lib

Schritt 8: Überprüfen von Sqoop

Der folgende Befehl wird verwendet, um die Sqoop-Version zu überprüfen.

$ cd $SQOOP_HOME/bin
$ sqoop-version

Erwartete Leistung -

14/12/17 14:52:32 INFO sqoop.Sqoop: Running Sqoop version: 1.4.5
Sqoop 1.4.5 git commit id 5b34accaca7de251fc91161733f906af2eddbe83
Compiled by abe on Fri Aug 1 11:19:26 PDT 2014

Die Installation von Sqoop ist abgeschlossen.

In diesem Kapitel wird beschrieben, wie Sie Daten aus der MySQL-Datenbank in Hadoop HDFS importieren. Das 'Import-Tool' importiert einzelne Tabellen von RDBMS nach HDFS. Jede Zeile in einer Tabelle wird in HDFS als Datensatz behandelt. Alle Datensätze werden als Textdaten in den Textdateien oder als Binärdaten in Avro- und Sequenzdateien gespeichert.

Syntax

Die folgende Syntax wird zum Importieren von Daten in HDFS verwendet.

$ sqoop import (generic-args) (import-args) 
$ sqoop-import (generic-args) (import-args)

Beispiel

Nehmen wir ein Beispiel für drei Tabellen mit dem Namen emp, emp_add, und emp_contact, die sich in einer Datenbank namens userdb auf einem MySQL-Datenbankserver befinden.

Die drei Tabellen und ihre Daten sind wie folgt.

emp:

Ich würde Name Grad Gehalt Abt
1201 gopal Manager 50.000 TP
1202 Manisha Korrekturleser 50.000 TP
1203 Khalil PHP Dev 30.000 AC
1204 Prasanth PHP Dev 30.000 AC
1204 kranthi Administrator 20.000 TP

emp_add:

Ich würde hno Straße Stadt
1201 288A vgiri jublee
1202 108I aoc sec-schlecht
1203 144Z pgutta hyd
1204 78B alte Stadt sec-schlecht
1205 720X hitec sec-schlecht

emp_contact:

Ich würde phno Email
1201 2356742 [email protected]
1202 1661663 [email protected]
1203 8887776 [email protected]
1204 9988774 [email protected]
1205 1231231 [email protected]

Tabelle importieren

Das Sqoop-Tool 'import' wird verwendet, um Tabellendaten aus der Tabelle als Textdatei oder Binärdatei in das Hadoop-Dateisystem zu importieren.

Der folgende Befehl wird zum Importieren von verwendet emp Tabelle vom MySQL-Datenbankserver zum HDFS.

$ sqoop import \
--connect jdbc:mysql://localhost/userdb \
--username root \
--table emp --m 1

Wenn es erfolgreich ausgeführt wird, erhalten Sie die folgende Ausgabe.

14/12/22 15:24:54 INFO sqoop.Sqoop: Running Sqoop version: 1.4.5
14/12/22 15:24:56 INFO manager.MySQLManager: Preparing to use a MySQL streaming resultset.
14/12/22 15:24:56 INFO tool.CodeGenTool: Beginning code generation
14/12/22 15:24:58 INFO manager.SqlManager: Executing SQL statement: 
   SELECT t.* FROM `emp` AS t LIMIT 1
14/12/22 15:24:58 INFO manager.SqlManager: Executing SQL statement: 
   SELECT t.* FROM `emp` AS t LIMIT 1
14/12/22 15:24:58 INFO orm.CompilationManager: HADOOP_MAPRED_HOME is /usr/local/hadoop
14/12/22 15:25:11 INFO orm.CompilationManager: Writing jar file: 
   /tmp/sqoop-hadoop/compile/cebe706d23ebb1fd99c1f063ad51ebd7/emp.jar
-----------------------------------------------------
-----------------------------------------------------
14/12/22 15:25:40 INFO mapreduce.Job: The url to track the job: 
   http://localhost:8088/proxy/application_1419242001831_0001/
14/12/22 15:26:45 INFO mapreduce.Job: Job job_1419242001831_0001 running in uber mode : 
   false
14/12/22 15:26:45 INFO mapreduce.Job: map 0% reduce 0%
14/12/22 15:28:08 INFO mapreduce.Job: map 100% reduce 0%
14/12/22 15:28:16 INFO mapreduce.Job: Job job_1419242001831_0001 completed successfully
-----------------------------------------------------
-----------------------------------------------------
14/12/22 15:28:17 INFO mapreduce.ImportJobBase: Transferred 145 bytes in 177.5849 seconds 
   (0.8165 bytes/sec)
14/12/22 15:28:17 INFO mapreduce.ImportJobBase: Retrieved 5 records.

Verwenden Sie den folgenden Befehl, um die in HDFS importierten Daten zu überprüfen.

$ $HADOOP_HOME/bin/hadoop fs -cat /emp/part-m-*

Es zeigt Ihnen die emp Tabellendaten und Felder werden durch Komma (,) getrennt.

1201, gopal,    manager, 50000, TP
1202, manisha,  preader, 50000, TP
1203, kalil,    php dev, 30000, AC
1204, prasanth, php dev, 30000, AC
1205, kranthi,  admin,   20000, TP

Importieren in das Zielverzeichnis

Wir können das Zielverzeichnis beim Importieren von Tabellendaten in HDFS mit dem Sqoop-Importtool angeben.

Im Folgenden finden Sie die Syntax zum Angeben des Zielverzeichnisses als Option für den Befehl Sqoop import.

--target-dir <new or exist directory in HDFS>

Der folgende Befehl wird zum Importieren verwendet emp_add Tabellendaten in das Verzeichnis '/ queryresult'.

$ sqoop import \
--connect jdbc:mysql://localhost/userdb \
--username root \
--table emp_add \
--m 1 \
--target-dir /queryresult

Der folgende Befehl wird verwendet, um die importierten Daten im Verzeichnisformular / queryresult zu überprüfen emp_add Tabelle.

$ $HADOOP_HOME/bin/hadoop fs -cat /queryresult/part-m-*

Es zeigt Ihnen die Tabellendaten emp_add mit durch Kommas (,) getrennten Feldern.

1201, 288A, vgiri,   jublee
1202, 108I, aoc,     sec-bad
1203, 144Z, pgutta,  hyd
1204, 78B,  oldcity, sec-bad
1205, 720C, hitech,  sec-bad

Teilmenge der Tabellendaten importieren

Wir können eine Teilmenge einer Tabelle mithilfe der 'where'-Klausel im Sqoop-Importtool importieren. Es führt die entsprechende SQL-Abfrage auf dem jeweiligen Datenbankserver aus und speichert das Ergebnis in einem Zielverzeichnis in HDFS.

Die Syntax für die where-Klausel lautet wie folgt.

--where <condition>

Der folgende Befehl wird verwendet, um eine Teilmenge von zu importieren emp_addTabellendaten. Die Teilmengenabfrage besteht darin, die Mitarbeiter-ID und -Adresse abzurufen, die in der Stadt Secunderabad lebt.

$ sqoop import \
--connect jdbc:mysql://localhost/userdb \
--username root \
--table emp_add \
--m 1 \
--where “city =’sec-bad’” \
--target-dir /wherequery

Der folgende Befehl wird verwendet, um die importierten Daten im Verzeichnis / wherequery aus dem zu überprüfen emp_add Tabelle.

$ $HADOOP_HOME/bin/hadoop fs -cat /wherequery/part-m-*

Es wird Ihnen das zeigen emp_add Tabellendaten mit durch Kommas (,) getrennten Feldern.

1202, 108I, aoc,     sec-bad
1204, 78B,  oldcity, sec-bad
1205, 720C, hitech,  sec-bad

Inkrementeller Import

Inkrementeller Import ist eine Technik, bei der nur die neu hinzugefügten Zeilen in einer Tabelle importiert werden. Für den inkrementellen Import müssen die Optionen 'inkrementell', 'Prüfspalte' und 'letzter Wert' hinzugefügt werden.

Die folgende Syntax wird für die inkrementelle Option im Befehl Sqoop import verwendet.

--incremental <mode>
--check-column <column name>
--last value <last check column value>

Nehmen wir die neu hinzugefügten Daten in an emp Tabelle ist wie folgt -

1206, satish p, grp des, 20000, GR

Der folgende Befehl wird verwendet, um den inkrementellen Import in die emp Tabelle.

$ sqoop import \
--connect jdbc:mysql://localhost/userdb \
--username root \
--table emp \
--m 1 \
--incremental append \
--check-column id \
-last value 1205

Der folgende Befehl wird verwendet, um die importierten Daten von zu überprüfen emp Tabelle in HDFS emp / Verzeichnis.

$ $HADOOP_HOME/bin/hadoop fs -cat /emp/part-m-*

Es zeigt Ihnen die emp Tabellendaten mit durch Kommas (,) getrennten Feldern.

1201, gopal,    manager, 50000, TP
1202, manisha,  preader, 50000, TP
1203, kalil,    php dev, 30000, AC
1204, prasanth, php dev, 30000, AC
1205, kranthi,  admin,   20000, TP
1206, satish p, grp des, 20000, GR

Der folgende Befehl wird verwendet, um die geänderten oder neu hinzugefügten Zeilen aus dem anzuzeigen emp Tabelle.

$ $HADOOP_HOME/bin/hadoop fs -cat /emp/part-m-*1

Es zeigt Ihnen die neu hinzugefügten Zeilen zum emp Tabelle mit durch Kommas (,) getrennten Feldern.

1206, satish p, grp des, 20000, GR

In diesem Kapitel wird beschrieben, wie Sie alle Tabellen vom RDBMS-Datenbankserver in das HDFS importieren. Alle Tabellendaten werden in einem separaten Verzeichnis gespeichert und der Verzeichnisname entspricht dem Tabellennamen.

Syntax

Die folgende Syntax wird zum Importieren aller Tabellen verwendet.

$ sqoop import-all-tables (generic-args) (import-args) 
$ sqoop-import-all-tables (generic-args) (import-args)

Beispiel

Nehmen wir ein Beispiel für den Import aller Tabellen aus dem userdbDatenbank. Die Liste der Tabellen, die die Datenbankuserdb enthält ist wie folgt.

+--------------------+
 |      Tables        |
 +--------------------+
 |      emp           |
 |      emp_add       |
 |      emp_contact   |
 +--------------------+

Der folgende Befehl wird verwendet, um alle Tabellen aus dem zu importieren userdb Datenbank.

$ sqoop import-all-tables \
--connect jdbc:mysql://localhost/userdb \
--username root

Note - Wenn Sie die Tabelle "Alle importieren" verwenden, muss jede Tabelle in dieser Datenbank über ein Primärschlüsselfeld verfügen.

Der folgende Befehl wird verwendet, um alle Tabellendaten in der userdb-Datenbank in HDFS zu überprüfen.

$ $HADOOP_HOME/bin/hadoop fs -ls

Es zeigt Ihnen die Liste der Tabellennamen in der userdb-Datenbank als Verzeichnisse.

Ausgabe

drwxr-xr-x - hadoop supergroup 0 2014-12-22 22:50 _sqoop
drwxr-xr-x - hadoop supergroup 0 2014-12-23 01:46 emp
drwxr-xr-x - hadoop supergroup 0 2014-12-23 01:50 emp_add
drwxr-xr-x - hadoop supergroup 0 2014-12-23 01:52 emp_contact

In diesem Kapitel wird beschrieben, wie Sie Daten aus dem HDFS zurück in die RDBMS-Datenbank exportieren. Die Zieltabelle muss in der Zieldatenbank vorhanden sein. Die Dateien, die als Eingabe für Sqoop angegeben werden, enthalten Datensätze, die in der Tabelle als Zeilen bezeichnet werden. Diese werden gelesen und in eine Reihe von Datensätzen analysiert und mit einem benutzerdefinierten Trennzeichen begrenzt.

Die Standardoperation besteht darin, den gesamten Datensatz aus den Eingabedateien mit der Anweisung INSERT in die Datenbanktabelle einzufügen. Im Aktualisierungsmodus generiert Sqoop die UPDATE-Anweisung, die den vorhandenen Datensatz in der Datenbank ersetzt.

Syntax

Das Folgende ist die Syntax für den Exportbefehl.

$ sqoop export (generic-args) (export-args) 
$ sqoop-export (generic-args) (export-args)

Beispiel

Nehmen wir ein Beispiel für die Mitarbeiterdaten in der Datei in HDFS. Die Mitarbeiterdaten sind in verfügbaremp_dataDatei im Verzeichnis 'emp /' in HDFS. Dasemp_data ist wie folgt.

1201, gopal,     manager, 50000, TP
1202, manisha,   preader, 50000, TP
1203, kalil,     php dev, 30000, AC
1204, prasanth,  php dev, 30000, AC
1205, kranthi,   admin,   20000, TP
1206, satish p,  grp des, 20000, GR

Die zu exportierende Tabelle muss manuell erstellt werden und in der Datenbank vorhanden sein, aus der sie exportiert werden muss.

Die folgende Abfrage wird verwendet, um die Tabelle 'Mitarbeiter' in der MySQL-Befehlszeile zu erstellen.

$ mysql
mysql> USE db;
mysql> CREATE TABLE employee ( 
   id INT NOT NULL PRIMARY KEY, 
   name VARCHAR(20), 
   deg VARCHAR(20),
   salary INT,
   dept VARCHAR(10));

Der folgende Befehl wird verwendet, um die Tabellendaten (die sich in befinden) zu exportieren emp_data Datei auf HDFS) in die Mitarbeitertabelle in der Datenbank des MySQL-Datenbankservers.

$ sqoop export \
--connect jdbc:mysql://localhost/db \
--username root \
--table employee \ 
--export-dir /emp/emp_data

Der folgende Befehl wird verwendet, um die Tabelle in der MySQL-Befehlszeile zu überprüfen.

mysql>select * from employee;

Wenn die angegebenen Daten erfolgreich gespeichert wurden, finden Sie die folgende Tabelle mit den angegebenen Mitarbeiterdaten.

+------+--------------+-------------+-------------------+--------+
| Id   | Name         | Designation | Salary            | Dept   |
+------+--------------+-------------+-------------------+--------+
| 1201 | gopal        | manager     | 50000             | TP     |
| 1202 | manisha      | preader     | 50000             | TP     |
| 1203 | kalil        | php dev     | 30000             | AC     |
| 1204 | prasanth     | php dev     | 30000             | AC     |
| 1205 | kranthi      | admin       | 20000             | TP     |
| 1206 | satish p     | grp des     | 20000             | GR     |
+------+--------------+-------------+-------------------+--------+

In diesem Kapitel wird beschrieben, wie Sie die Sqoop-Jobs erstellen und verwalten. Der Sqoop-Job erstellt und speichert die Import- und Exportbefehle. Es gibt Parameter zum Identifizieren und Abrufen des gespeicherten Jobs an. Dieses erneute Aufrufen oder erneute Ausführen wird beim inkrementellen Import verwendet, mit dem die aktualisierten Zeilen aus der RDBMS-Tabelle in HDFS importiert werden können.

Syntax

Das Folgende ist die Syntax zum Erstellen eines Sqoop-Jobs.

$ sqoop job (generic-args) (job-args)
   [-- [subtool-name] (subtool-args)]

$ sqoop-job (generic-args) (job-args)
   [-- [subtool-name] (subtool-args)]

Job erstellen (--create)

Hier erstellen wir einen Job mit dem Namen myjob, die die Tabellendaten aus der RDBMS-Tabelle in HDFS importieren können. Der folgende Befehl wird verwendet, um einen Job zu erstellen, der Daten aus dem importiertemployee Tabelle in der db Datenbank in die HDFS-Datei.

$ sqoop job --create myjob \
-- import \
--connect jdbc:mysql://localhost/db \
--username root \
--table employee --m 1

Job überprüfen (--list)

‘--list’Das Argument wird verwendet, um die gespeicherten Jobs zu überprüfen. Der folgende Befehl wird verwendet, um die Liste der gespeicherten Sqoop-Jobs zu überprüfen.

$ sqoop job --list

Es zeigt die Liste der gespeicherten Jobs.

Available jobs: 
   myjob

Job überprüfen (--show)

‘--show’Das Argument wird verwendet, um bestimmte Jobs und deren Details zu überprüfen oder zu überprüfen. Der folgende Befehl und die folgende Beispielausgabe werden verwendet, um einen aufgerufenen Job zu überprüfenmyjob.

$ sqoop job --show myjob

Es zeigt die Werkzeuge und ihre Optionen, die in verwendet werden myjob.

Job: myjob 
 Tool: import Options:
 ---------------------------- 
 direct.import = true
 codegen.input.delimiters.record = 0
 hdfs.append.dir = false 
 db.table = employee
 ...
 incremental.last.value = 1206
 ...

Job ausführen (--exec)

‘--exec’Option wird verwendet, um einen gespeicherten Job auszuführen. Der folgende Befehl wird verwendet, um einen gespeicherten Job namens aufzurufenmyjob.

$ sqoop job --exec myjob

Es zeigt Ihnen die folgende Ausgabe.

10/08/19 13:08:45 INFO tool.CodeGenTool: Beginning code generation 
...

Dieses Kapitel beschreibt die Bedeutung des Codegen-Tools. Aus Sicht der objektorientierten Anwendung verfügt jede Datenbanktabelle über eine DAO-Klasse, die die Methoden 'getter' und 'setter' zum Initialisieren von Objekten enthält. Dieses Tool (-codegen) generiert die DAO-Klasse automatisch.

Es generiert eine DAO-Klasse in Java basierend auf der Tabellenschemastruktur. Die Java-Definition wird als Teil des Importprozesses instanziiert. Die Hauptverwendung dieses Tools besteht darin, zu überprüfen, ob Java den Java-Code verloren hat. In diesem Fall wird eine neue Java-Version mit dem Standardtrennzeichen zwischen den Feldern erstellt.

Syntax

Das Folgende ist die Syntax für den Befehl Sqoop codegen.

$ sqoop codegen (generic-args) (codegen-args) 
$ sqoop-codegen (generic-args) (codegen-args)

Beispiel

Nehmen wir ein Beispiel, das Java-Code für das generiert emp Tabelle in der userdb Datenbank.

Der folgende Befehl wird verwendet, um das angegebene Beispiel auszuführen.

$ sqoop codegen \
--connect jdbc:mysql://localhost/userdb \
--username root \ 
--table emp

Wenn der Befehl erfolgreich ausgeführt wird, wird die folgende Ausgabe auf dem Terminal erzeugt.

14/12/23 02:34:40 INFO sqoop.Sqoop: Running Sqoop version: 1.4.5
14/12/23 02:34:41 INFO tool.CodeGenTool: Beginning code generation
……………….
14/12/23 02:34:42 INFO orm.CompilationManager: HADOOP_MAPRED_HOME is /usr/local/hadoop
Note: /tmp/sqoop-hadoop/compile/9a300a1f94899df4a9b10f9935ed9f91/emp.java uses or 
   overrides a deprecated API.
Note: Recompile with -Xlint:deprecation for details.

14/12/23 02:34:47 INFO orm.CompilationManager: Writing jar file: 
   /tmp/sqoop-hadoop/compile/9a300a1f94899df4a9b10f9935ed9f91/emp.jar

Überprüfung

Werfen wir einen Blick auf die Ausgabe. Der fett gedruckte Pfad ist der Speicherort, an dem sich der Java-Code befindetempTabelle generiert und speichert. Lassen Sie uns die Dateien an diesem Speicherort mit den folgenden Befehlen überprüfen.

$ cd /tmp/sqoop-hadoop/compile/9a300a1f94899df4a9b10f9935ed9f91/
$ ls
emp.class
emp.jar
emp.java

Wenn Sie die Tiefe überprüfen möchten, vergleichen Sie die emp Tabelle in der userdb Datenbank und emp.java im folgenden Verzeichnis

/ tmp / sqoop-hadoop / compile / 9a300a1f94899df4a9b10f9935ed9f91 /.

In diesem Kapitel wird die Verwendung des Sqoop-Tools "eval" beschrieben. Benutzer können benutzerdefinierte Abfragen für die jeweiligen Datenbankserver ausführen und eine Vorschau des Ergebnisses in der Konsole anzeigen. Der Benutzer kann also erwarten, dass die resultierenden Tabellendaten importiert werden. Mit eval können wir jede Art von SQL-Abfrage auswerten, die entweder eine DDL- oder eine DML-Anweisung sein kann.

Syntax

Die folgende Syntax wird für den Befehl Sqoop eval verwendet.

$ sqoop eval (generic-args) (eval-args) 
$ sqoop-eval (generic-args) (eval-args)

Wählen Sie Abfrageauswertung

Mit dem eval-Tool können wir jede Art von SQL-Abfrage auswerten. Nehmen wir ein Beispiel für die Auswahl begrenzter Zeilen in deremployee Tabelle dbDatenbank. Der folgende Befehl wird verwendet, um das angegebene Beispiel mithilfe einer SQL-Abfrage auszuwerten.

$ sqoop eval \
--connect jdbc:mysql://localhost/db \
--username root \ 
--query “SELECT * FROM employee LIMIT 3”

Wenn der Befehl erfolgreich ausgeführt wird, wird die folgende Ausgabe auf dem Terminal erzeugt.

+------+--------------+-------------+-------------------+--------+
| Id   | Name         | Designation | Salary            | Dept   |
+------+--------------+-------------+-------------------+--------+
| 1201 | gopal        | manager     | 50000             | TP     |
| 1202 | manisha      | preader     | 50000             | TP     |
| 1203 | khalil       | php dev     | 30000             | AC     |
+------+--------------+-------------+-------------------+--------+

Abfrageauswertung einfügen

Das Sqoop-Bewertungstool kann sowohl zum Modellieren als auch zum Definieren der SQL-Anweisungen verwendet werden. Das heißt, wir können eval auch zum Einfügen von Anweisungen verwenden. Der folgende Befehl wird verwendet, um eine neue Zeile in die einzufügenemployee Tabelle db Datenbank.

$ sqoop eval \
--connect jdbc:mysql://localhost/db \
--username root \ 
-e “INSERT INTO employee VALUES(1207,‘Raju’,‘UI dev’,15000,‘TP’)”

Wenn der Befehl erfolgreich ausgeführt wird, wird der Status der aktualisierten Zeilen auf der Konsole angezeigt.

Sie können auch die Mitarbeitertabelle in der MySQL-Konsole überprüfen. Der folgende Befehl wird verwendet, um die Zeilen von zu überprüfenemployee Tabelle db Datenbank mit select 'Abfrage.

mysql>
mysql> use db;
mysql> SELECT * FROM employee;
+------+--------------+-------------+-------------------+--------+
| Id   | Name         | Designation | Salary            | Dept   |
+------+--------------+-------------+-------------------+--------+
| 1201 | gopal        | manager     | 50000             | TP     |
| 1202 | manisha      | preader     | 50000             | TP     |
| 1203 | khalil       | php dev     | 30000             | AC     |
| 1204 | prasanth     | php dev     | 30000             | AC     |
| 1205 | kranthi      | admin       | 20000             | TP     |
| 1206 | satish p     | grp des     | 20000             | GR     |
| 1207 | Raju         | UI dev      | 15000             | TP     |
+------+--------------+-------------+-------------------+--------+

In diesem Kapitel wird beschrieben, wie Sie die Datenbanken mit Sqoop auflisten. Das Sqoop List-Databases-Tool analysiert und führt die Abfrage 'SHOW DATABASES' für den Datenbankserver aus. Danach werden die aktuellen Datenbanken auf dem Server aufgelistet.

Syntax

Die folgende Syntax wird für den Befehl Sqoop list-database verwendet.

$ sqoop list-databases (generic-args) (list-databases-args) 
$ sqoop-list-databases (generic-args) (list-databases-args)

Beispielabfrage

Mit dem folgenden Befehl werden alle Datenbanken auf dem MySQL-Datenbankserver aufgelistet.

$ sqoop list-databases \
--connect jdbc:mysql://localhost/ \
--username root

Wenn der Befehl erfolgreich ausgeführt wird, wird die Liste der Datenbanken in Ihrem MySQL-Datenbankserver wie folgt angezeigt.

...
13/05/31 16:45:58 INFO manager.MySQLManager: Preparing to use a MySQL streaming resultset.

mysql
test
userdb
db

In diesem Kapitel wird beschrieben, wie Sie die Tabellen einer bestimmten Datenbank im MySQL-Datenbankserver mit Sqoop auflisten. Das Tool "Sqoop List-Tables" analysiert und führt die Abfrage "SHOW TABLES" für eine bestimmte Datenbank aus. Danach werden die vorhandenen Tabellen in einer Datenbank aufgelistet.

Syntax

Die folgende Syntax wird für den Befehl Sqoop list-tables verwendet.

$ sqoop list-tables (generic-args) (list-tables-args) 
$ sqoop-list-tables (generic-args) (list-tables-args)

Beispielabfrage

Der folgende Befehl wird verwendet, um alle Tabellen in der Liste aufzulisten userdb Datenbank des MySQL-Datenbankservers.

$ sqoop list-tables \
--connect jdbc:mysql://localhost/userdb \
--username root

Wenn der Befehl erfolgreich ausgeführt wird, wird die Liste der Tabellen in der angezeigt userdb Datenbank wie folgt.

...
13/05/31 16:45:58 INFO manager.MySQLManager: Preparing to use a MySQL streaming resultset.

emp
emp_add
emp_contact

In diesem Kapitel wird beschrieben, wie Sie die Tabellen einer bestimmten Datenbank im MySQL-Datenbankserver mit Sqoop auflisten. Das Tool "Sqoop List-Tables" analysiert und führt die Abfrage "SHOW TABLES" für eine bestimmte Datenbank aus. Danach werden die vorhandenen Tabellen in einer Datenbank aufgelistet.

Syntax

Die folgende Syntax wird für den Befehl Sqoop list-tables verwendet.

$ sqoop list-tables (generic-args) (list-tables-args) 
$ sqoop-list-tables (generic-args) (list-tables-args)

Beispielabfrage

Der folgende Befehl wird verwendet, um alle Tabellen in der Liste aufzulisten userdb Datenbank des MySQL-Datenbankservers.

$ sqoop list-tables \
--connect jdbc:mysql://localhost/userdb \
--username root

Wenn der Befehl erfolgreich ausgeführt wird, wird die Liste der Tabellen in der angezeigt userdb Datenbank wie folgt.

...
13/05/31 16:45:58 INFO manager.MySQLManager: Preparing to use a MySQL streaming resultset.

emp
emp_add
emp_contact