Principio de sqoop

1. Información general

Sqoop es una herramienta de Apache que "transfiere datos entre Hadoop y bases de datos relacionales".

Importar datos: importe datos de MySQL y Oracle a HDFS, HIVE, HBASE y otros sistemas de almacenamiento de datos de Hadoop.
Exportar datos: exportar datos del sistema de archivos Hadoop a una base de datos relacional

2. Mecanismo de trabajo de Sqoop

Traducir comandos de importación y exportación a la implementación del programa MapReduce
El MapReduce traducido está personalizado principalmente para el formato de entrada y el formato de salida.

3. Comparación de las arquitecturas Sqoop1 y Sqoop2

Sqoop ha evolucionado hacia dos arquitecturas diferentes durante su desarrollo.

3.1 Arquitectura Sqoop1

El número de versión es 1.4.x para sqoop1.
En términos de arquitectura: sqoop1 usa el cliente sqoop para enviar directamente
Método de acceso: acceso a la consola CLI
Seguridad: especifique el nombre de la base de datos del usuario y la contraseña en el comando o script

3.2 Arquitectura Sqoop2

El número de versión es 1.99x para sqoop2
En términos de arquitectura: sqoop2 presenta el servidor sqoop para implementar la gestión centralizada de conectores.
Método de acceso: API REST, API JAVA, UI WEB y consola CLI.

Comparar	Sqoop1	Sqoop2
Arquitectura	Simplemente use un cliente Sqoop	Se introdujo el conector de administración centralizada de Sqoop Server, API de descanso, interfaz de usuario web y se introdujo un mecanismo de seguridad.
desplegar	La implementación es simple, la instalación requiere permisos de root y el conector debe ajustarse al modelo JBDC	La arquitectura es ligeramente compleja y la configuración y el despliegue son engorrosos.
usar	El método de comando es propenso a errores, el formato está estrechamente acoplado, no puede admitir todos los tipos de datos y el mecanismo de seguridad no es perfecto, como la exposición de contraseñas.	Múltiples métodos de interacción, línea de comando, WebUI, API de descanso, administración centralizada del conector, todas las conexiones están instaladas en el servidor Sqoop, mecanismo de administración de permisos perfecto, el conector está estandarizado y solo es responsable de la lectura y escritura de datos.

4. Instalación e implementación de Sqoop

La instalación de Sqoop es muy sencilla, puedes utilizarlo después de descomprimirlo y realizar modificaciones sencillas.

4.1 Paso 1: Descargue el paquete de instalación

https://mirrors.bfsu.edu.cn/apache/sqoop/1.4.7

4.2 Paso 2: Cargar y descomprimir

Cargue el paquete de instalación que descargamos en la ruta /kkb/soft del servidor ==node03== y luego descomprímalo.

cd /opt/soft/
tar -xzvf sqoop-1.4.7.bin__hadoop-2.6.0.tar.gz -C /opt/install

4.3 Paso 3: Modificar el archivo de configuración

cd /opt/install/sqoop-1.4.7.bin__hadoop-2.6.0/conf/
mv sqoop-env-template.sh sqoop-env.sh
vim sqoop-env.sh

#Set path to where bin/hadoop is available
export HADOOP_COMMON_HOME=/kkb/install/hadoop-3.1.4

#Set path to where hadoop-*-core.jar is available
export HADOOP_MAPRED_HOME=/kkb/install/hadoop-3.1.4

#set the path to where bin/hbase is available
export HBASE_HOME=/kkb/install/hbase-2.2.2

#Set the path to where bin/hive is available
export HIVE_HOME=/kkb/install/apache-hive-3.1.2

#Set the path for where zookeper config dir is
export ZOOCFGDIR=/kkb/install/apache-zookeeper-3.6.2-bin

4.4 Paso 4: Agregue dos paquetes de frascos necesarios

Sqoop requiere dos paquetes jar dependientes adicionales. Agregue los dos paquetes jar en los materiales del curso al directorio lib de sqoop.

cd /opt/soft
cp java-json.jar mysql-connector-java-5.1.38.jar /opt/install/sqoop-1.4.7.bin__hadoop-2.6.0/lib/

4.5 Paso 5: Configurar las variables de entorno de Sqoop

Modificar y agregar de la siguiente manera

sudo vim /etc/profile	
export SQOOP_HOME=/kkb/install/sqoop-1.4.7.bin__hadoop-2.6.0
export PATH=:$SQOOP_HOME/bin:$PATH

Hacer que las variables de entorno sean efectivas

source /etc/profile

4.6 La ayuda de Sqoop tiene registros de advertencia

Ejecute el comando `sqoop help` y habrá un registro de advertencia.

solución

[hadoop@node03 bin]$ pwd
/opt/install/sqoop-1.4.7.bin__hadoop-2.6.0/bin
# 搜索HCAT_HOME,将下图红框内容注释掉
[hadoop@node03 bin]$ vim configure-sqoop

4.7 La ayuda de Sqoop tiene errores

Hay un error al ejecutar la ayuda de sqoop:

- Error: la clase principal org.apache.hadoop.hbase.util.GetJavaProperty no se puede encontrar o no se puede cargar

Este error no afecta a sqoop; puede ignorarse

- Si tienes misofobia, puedes ver las siguientes formas de solucionarla

4.7.1 Solución 1

La forma sencilla es reemplazar directamente los archivos hbase en el directorio `/kkb/install/hbase-2.2.2/bin` de los tres nodos del clúster con los archivos hbase modificados.

Simplemente reinicie el clúster hbase

4.7.2 Solución 2

node01 modifica el archivo de comando hbase

[hadoop@node01 bin]$ cd /opt/install/hbase-2.2.2/bin/
[hadoop@node01 bin]$ vim hbase

Añade el contenido del primer cuadro rojo; presta atención a la sangría.

    # Needed for GetJavaProperty check below
    add_to_cp_if_exists "${HBASE_HOME}/hbase-server/target/classes"

Comente el contenido del segundo cuadro rojo.

Continúe buscando el archivo hbase y localice el siguiente contenido del cuadro amarillo

Agregue el código de ① en la figura siguiente en la línea 322 (el primer cuadro amarillo) en la figura anterior; == Preste atención a la sangría ==

  temporary_cp=
  for f in "${HBASE_HOME}"/lib/hbase-server*.jar; do
    if [[ ! "${f}" =~ ^.*\-tests\.jar$ ]]; then
      temporary_cp=":$f"
    fi
  done

Modifique el contenido del segundo cuadro amarillo en la imagen de arriba al código en la imagen de abajo; == Preste atención a la sangría ==

  HADOOP_JAVA_LIBRARY_PATH=$(HADOOP_CLASSPATH="$CLASSPATH${temporary_cp}" "${    HADOOP_IN_PATH}" \

Guardar y Salir

Distribuir hbase a otros dos nodos

[hadoop@node01 bin]$ pwd
/opt/install/hbase-2.2.2/bin
[hadoop@node01 bin]$ scp hbase node02:$PWD
[hadoop@node01 bin]$ scp hbase node03:$PWD

Reiniciar hbase

5. Importación de datos de Sqoop

5.1 Listar todas las bases de datos

Ayuda de vista de línea de comando

sqoop help
sqoop list-databases --help

Listar todas las bases de datos en el host node03

sqoop list-databases --connect jdbc:mysql://node03:3306/ --username root --password 123456

Ver todas las tablas de datos en una determinada base de datos (reemplace el nombre de la base de datos con uno de sus propios nombres de base de datos)

sqoop list-tables --connect jdbc:mysql://node03:3306/hive --username root --password 123456

5.2 Preparar datos de la tabla

Hay una biblioteca userdb en mysql con tres tablas: emp, emp_add y emp_conn.

Empezar tabla:

identificación	nombre	grados	salario	departamento
1201	gopal	gerente	50.000	TP
1202	manisha	lector de pruebas	50.000	TP
1203	khalil	desarrollador de php	30.000	C.A.
1204	prasanth	desarrollador de php	30.000	C.A.
1205	kranthi	administración	20.000	TP

Tabla emp_add:

identificación	hno	calle	ciudad
1201	288A	vgiri	jubileo
1202	108I	aoc	segundo-malo
1203	144Z	pguta	hidraulico
1204	78B	ciudad Vieja	segundo-malo
1205	720X	hitec	segundo-malo

Tabla emp_conn:

identificación	fono	correo electrónico
1201	2356742	[email protected]
1202	1661663	[email protected]
1203	8887776	[email protected]
1204	9988774	[email protected]
1205	1231231	[email protected]

La declaración de creación de la tabla es la siguiente:

CREATE DATABASE /*!32312 IF NOT EXISTS*/`userdb` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `userdb`;

DROP TABLE IF EXISTS `emp`;

CREATE TABLE `emp` (
  `id` INT(11) DEFAULT NULL,
  `name` VARCHAR(100) DEFAULT NULL,
  `deg` VARCHAR(100) DEFAULT NULL,
  `salary` INT(11) DEFAULT NULL,
  `dept` VARCHAR(10) DEFAULT NULL,
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `is_delete` BIGINT(20) DEFAULT '1'
) ENGINE=INNODB DEFAULT CHARSET=latin1;

INSERT  INTO `emp`(`id`,`name`,`deg`,`salary`,`dept`) VALUES (1201,'gopal','manager',50000,'TP'),(1202,'manisha','Proof reader',50000,'TP'),(1203,'khalil','php dev',30000,'AC'),(1204,'prasanth','php dev',30000,'AC'),(1205,'kranthi','admin',20000,'TP');

DROP TABLE IF EXISTS `emp_add`;

CREATE TABLE `emp_add` (
  `id` INT(11) DEFAULT NULL,
  `hno` VARCHAR(100) DEFAULT NULL,
  `street` VARCHAR(100) DEFAULT NULL,
  `city` VARCHAR(100) DEFAULT NULL,
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `is_delete` BIGINT(20) DEFAULT '1'
) ENGINE=INNODB DEFAULT CHARSET=latin1;

INSERT  INTO `emp_add`(`id`,`hno`,`street`,`city`) VALUES (1201,'288A','vgiri','jublee'),(1202,'108I','aoc','sec-bad'),(1203,'144Z','pgutta','hyd'),(1204,'78B','old city','sec-bad'),(1205,'720X','hitec','sec-bad');

DROP TABLE IF EXISTS `emp_conn`;
CREATE TABLE `emp_conn` (
  `id` INT(100) DEFAULT NULL,
  `phno` VARCHAR(100) DEFAULT NULL,
  `email` VARCHAR(100) DEFAULT NULL,
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `is_delete` BIGINT(20) DEFAULT '1'
) ENGINE=INNODB DEFAULT CHARSET=latin1;

INSERT  INTO `emp_conn`(`id`,`phno`,`email`) VALUES (1201,'2356742','[email protected]'),(1202,'1661663','[email protected]'),(1203,'8887776','[email protected]'),(1204,'9988774','[email protected]'),(1205,'1231231','[email protected]');

5.3 Importar datos de la tabla de la base de datos a HDFS

Antes de utilizar el comando sqoop para importar y exportar datos, primero debe iniciar el clúster de hadoop.
El siguiente comando se utiliza para importar HDFS desde la tabla emp en el servidor de base de datos MySQL.

sqoop import --connect jdbc:mysql://node03:3306/userdb --password 123456 --username root --table emp -m 1

Si se ejecuta correctamente, obtendrá el siguiente resultado.

Para verificar los datos importados en HDFS, use el siguiente comando para ver los datos importados

hdfs dfs -ls /user/hadoop/emp

Hay parámetros arriba --m 1, lo que significa que solo se iniciará una tarea de mapa para importar datos.
Si desea abrir varias tareas de mapas, debe agregarlas al comando --split-by column-name, de la siguiente manera, donde el número de mapas es 4

sqoop import --connect jdbc:mysql://node03:3306/userdb --password 123456 --username root --table emp -m 4 --split-by id

5.4 Importar el directorio especificado de HDFS

Al importar datos de tablas a HDFS utilizando la herramienta de importación Sqoop, podemos especificar el directorio de destino.
Utilice el parámetro --target-dir para especificar el destino de la exportación.
Utilice el parámetro --delete-target-dir para determinar si el directorio de exportación existe. Si existe, elimínelo.

sqoop import --connect jdbc:mysql://node03:3306/userdb --username root --password 123456 --delete-target-dir --table emp --target-dir /sqoop/emp -m 1

Ver datos exportados

hdfs dfs -text /sqoop/emp/part-m-00000

Separará los datos y campos de la tabla emp_add con comas (,).

1201,gopal,manager,50000,TP
1202,manisha,Proof reader,50000,TP
1203,khalil,php dev,30000,AC
1204,prasanth,php dev,30000,AC
1205,kranthi,admin,20000,TP

5.5 Importar al directorio especificado de hdfs y especificar el separador entre campos

sqoop import --connect jdbc:mysql://node03:3306/userdb --username root --password 123456 --delete-target-dir --table emp --target-dir /sqoop/emp2 -m 1 --fields-terminated-by '\t'

Ver contenido del archivo

hdfs dfs -text /sqoop/emp2/part-m-00000

5.6 Importar la tabla relacional a Hive

1) Paso uno: copie el paquete jar

Para importar los datos de nuestra tabla mysql directamente a la tabla de colmena, necesitamos copiar un paquete jar de colmena llamado hive-exec-3.1.2.jar al directorio lib de sqoop.

cd /kkb/install/apache-hive-3.1.2/lib/
cp hive-exec-3.1.2.jar /kkb/install/sqoop-1.4.7.bin__hadoop-2.6.0/lib/

2) Paso 2: preparar la base de datos y las tablas de Hive

Importar los datos de nuestro mysql a la tabla de colmena

hive (default)> create database sqooptohive;
hive (default)> use sqooptohive;
hive (sqooptohive)> create external table emp_hive(id int,name string,deg string,salary int ,dept string) row format delimited fields terminated by '\001';

3) Paso 3: Comience a importar

sqoop import --connect jdbc:mysql://node03:3306/userdb --username root --password 123456 --table emp --fields-terminated-by '\001' --hive-import --hive-table sqooptohive.emp_hive --hive-overwrite --delete-target-dir --m 1

4) Paso 4: Ver los datos de la tabla de colmena

select * from emp_hive;

5.7 Importar tablas relacionales a Hive y crear automáticamente tablas de Hive

También podemos importar nuestra tabla mysql directamente a la tabla de colmena mediante comandos

sqoop import --connect jdbc:mysql://node03:3306/userdb --username root --password 123456 --table emp_conn --hive-import -m 1 --hive-database sqooptohive

A través de este comando, podemos verter directamente los datos y la estructura de la tabla en nuestra tabla mysql en Hive.

5.8 Importar datos de tablas mysql a hbase

Nota especial: la última versión 1.4.7 de sqoop1 actualmente solo es compatible con hbase 1.x

Primero necesitas abrir el clúster hbase.

1) Paso uno: modificar el archivo de configuración de sqoop

Para importar y exportar datos de HBase desde sqoop, debe modificar el archivo de configuración de sqoop sqoop-env.sh.

cd /opt/install/sqoop-1.4.7.bin__hadoop-2.6.0/conf
vim sqoop-env.sh

Modifique el valor HBASE_HOME de la siguiente manera:

#Set path to where bin/hadoop is available
export HADOOP_COMMON_HOME=/kkb/install/hadoop-3.1.4

#Set path to where hadoop-*-core.jar is available
export HADOOP_MAPRED_HOME=/kkb/install/hadoop-3.1.4

#set the path to where bin/hbase is available
export HBASE_HOME=/kkb/install/hbase-2.2.2

#Set the path to where bin/hive is available
export HIVE_HOME=/kkb/install/apache-hive-3.1.2

#Set the path for where zookeper config dir is
export ZOOCFGDIR=/kkb/install/apache-zookeeper-3.6.2-bin

2) Paso 2: Crear una base de datos y una tabla de base de datos en mysql e insertar datos

Crear tabla de base de datos

CREATE DATABASE IF NOT EXISTS library;
USE library;
CREATE TABLE book(
id INT(4) PRIMARY KEY NOT NULL AUTO_INCREMENT, 
NAME VARCHAR(255) NOT NULL, 
price VARCHAR(255) NOT NULL);

Insertar datos

INSERT INTO book(NAME, price) VALUES('Lie Sporting', '30'); 
INSERT INTO book (NAME, price) VALUES('Pride & Prejudice', '70'); 
INSERT INTO book (NAME, price) VALUES('Fall of Giants', '50');

3) Paso 3: Importar los datos de la tabla mysql a la tabla HBase

Ejecute el siguiente comando para importar los datos de la tabla mysql a HBase

sqoop import \
--connect jdbc:mysql://node03:3306/library \
--username root \
--password 123456 \
--table book \
--columns "id,name,price" \
--column-family "info" \
--hbase-create-table \
--hbase-row-key "id" \
--hbase-table "hbase_book" \
--num-mappers 1 \
--split-by id

4) Paso 4: Ver los datos de la tabla en HBase

Ingrese al cliente shell de hbase y vea los datos mediante escaneo

hbase(main):057:0> scan 'hbase_book'
ROW           COLUMN+CELL                            
 1            column=info:name, timestamp=1550634017823, value=Lie Sporting   
 1            column=info:price, timestamp=1550634017823, value=30       
 2            column=info:name, timestamp=1550634017823, value=Pride & Prejudice 
 2            column=info:price, timestamp=1550634017823, value=70       
 3            column=info:name, timestamp=1550634017823, value=Fall of Giants  
 3            column=info:price, timestamp=1550634017823, value=50

5.9 Importar subconjuntos de datos de tablas

Podemos importar tablas usando la herramienta de importación Sqoop, un subconjunto de la cláusula "dónde". Ejecuta la consulta SQL correspondiente en el servidor de base de datos respectivo y almacena los resultados en el directorio de destino de HDFS.
La sintaxis de la cláusula donde es la siguiente.

 --where <condition>

Busque de acuerdo con las condiciones y use el parámetro --where para encontrar todos los datos cuyo valor de campo de ciudad sea sec-bad en la tabla emp_add e importarlos a hdfs.

bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root --password 123456 --table emp_add \
--target-dir /sqoop/emp_add -m 1 --delete-target-dir \
--where "city = 'sec-bad'"

5.10 Búsqueda e importación de sentencias SQL a HDFS

También podemos especificar nuestra declaración SQL a través del parámetro –query y filtrar nuestros datos para importarlos a través de la declaración SQL.

bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb --username root --password 123456 \
--delete-target-dir -m 1 \
--query 'select phno from emp_conn where 1=1 and  $CONDITIONS' \
--target-dir /sqoop/emp_conn

Ver contenido de datos hdfs

hdfs dfs -text /sqoop/emp_conn/part*

Aviso:

1. Cuando se utilizan sentencias SQL para buscar, no se puede agregar el parámetro --table
2. Y se debe agregar una condición donde,
3. Y la condición donde debe ir seguida de la cadena $CONDICIONES.
4. Y esta declaración SQL debe usar comillas simples, no comillas dobles.

5.11 Importación incremental

En el trabajo real, la importación de datos a menudo solo requiere la importación de datos incrementales. No es necesario importar todos los datos de la tabla a Hive o HDF. Definitivamente habrá datos duplicados, por lo que generalmente seleccionamos algunos campos para la importación incremental. Para admitir la importación incremental, sqoop también tiene en cuenta esta situación y admite la importación incremental de datos.
La importación incremental es una técnica que consiste en importar solo filas de tablas recién agregadas.
Requiere agregar opciones 'incremental', 'columna de verificación' y 'último valor' para realizar la importación incremental.
La siguiente sintaxis se utiliza para las opciones de incremento del comando de importación de Sqoop.

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

1) La primera importación incremental se implementa utilizando las opciones anteriores.

Importe todos los datos con ID mayor que 1202 en la tabla emp
Nota: Al realizar una importación incremental, no debe agregar el parámetro --delete-target-dir; de lo contrario, se informará un error.

bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp \
--incremental append \
--check-column id \
--last-value 1202 \
-m 1 \
--target-dir /sqoop/increment

Ver contenido de datos

hdfs dfs -text /sqoop/increment/part*

2) El segundo tipo de importación incremental se implementa mediante la condición --where

O podemos usar --where para controlar la selección de datos, que será más precisa.

bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp \
--incremental append \
--where "create_time > '2018-06-17 00:00:00' and is_delete='1' and create_time < '2018-06-17 23:59:59'" \
--target-dir /sqoop/incement2 \
--check-column id \
--m 1

Tarea: ¿Cómo implementar la importación incremental en la tabla de colmena? ? ?
Pregunta de la entrevista: ¿Cómo solucionar la reducción de datos? ? ?

6. Exportación de datos de Sqoop

6.1 Exportar archivos de datos desde HDFS a la base de datos RDBMS

La tabla de destino debe existir en la base de datos de destino antes de exportar.
La operación predeterminada es insertar datos del archivo en la tabla usando la instrucción INSERT
En el modo de actualización, se genera una declaración UPDATE para actualizar los datos de la tabla.
Los datos están en el siguiente directorio/sqoop/emp en HDFS y el contenido de los datos es el siguiente

1201,gopal,manager,50000,TP,2018-06-17 18:54:32.0,2018-06-17 18:54:32.0,1
1202,manisha,Proof reader,50000,TP,2018-06-15 18:54:32.0,2018-06-17 20:26:08.0,1
1203,khalil,php dev,30000,AC,2018-06-17 18:54:32.0,2018-06-17 18:54:32.0,1
1204,prasanth,php dev,30000,AC,2018-06-17 18:54:32.0,2018-06-17 21:05:52.0,0
1205,kranthi,admin,20000,TP,2018-06-17 18:54:32.0,2018-06-17 18:54:32.0,1

6.1.1 Paso 1: crear una tabla mysql

use userdb;

CREATE TABLE `emp_out` (
  `id` INT(11) DEFAULT NULL,
  `name` VARCHAR(100) DEFAULT NULL,
  `deg` VARCHAR(100) DEFAULT NULL,
  `salary` INT(11) DEFAULT NULL,
  `dept` VARCHAR(10) DEFAULT NULL,
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `is_delete` BIGINT(20) DEFAULT '1'
) ENGINE=INNODB DEFAULT CHARSET=utf8;

6.1.2 Paso 2: ejecutar el comando de exportación

Utilice kkb para exportar datos y exportar datos hdfs a mysql.

bin/sqoop export \
--connect jdbc:mysql://node03:3306/userdb \
--username root --password 123456 \
--table emp_out \
--export-dir /sqoop/emp \
--input-fields-terminated-by ","

6.1.3 Paso 3: Verificar los datos de la tabla MySQL

6.2 Exportar datos de Hbase a mysql

Exportar los datos de la tabla hbase_book a mysql
Nota: sqoop no nos permite exportar datos directamente desde HBase, por lo que podemos exportarlos mediante la siguiente conversión: Hbase → tabla externa de hive → tabla interna de hive → a través de sqoop → mysql

6.2.1 Paso 1: crear una tabla externa de colmena

Ingrese al cliente de Hive, cree una tabla externa de Hive y asigne la tabla hbase_book en hbase.

CREATE EXTERNAL TABLE course.hbase2mysql (id int,name string,price int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES (
"hbase.columns.mapping" =
":key,info:name, info:price"
)
TBLPROPERTIES( "hbase.table.name" = "hbase_book",
"hbase.mapred.output.outputtable" = "hbase2mysql");

6.2.2 Paso 2: Crear una tabla interna de Hive e insertar datos de la tabla externa en la tabla interna

Ingrese al cliente de Hive y ejecute el siguiente comando para crear la tabla interna de Hive e insertar los datos de la tabla externa en la tabla interna de Hive.

CREATE TABLE course.hbase2mysqlin(id int,name string,price int);

6.2.3 Paso 3: Insertar datos de la tabla externa en la tabla interna

Ingrese al cliente de Hive y ejecute el siguiente comando para insertar los datos de la tabla externa de Hive en la tabla interna de Hive.

insert overwrite table course.hbase2mysqlin select * from course.hbase2mysql;

6.2.4 Paso 4: Borrar datos de la tabla MySQL

Ingrese al cliente mysql y ejecute el siguiente comando para borrar los datos de la tabla mysql

use library;
TRUNCATE TABLE book;

6.2.5 Paso 5: Ejecute sqoop para exportar los datos de la tabla interna de Hive a

bin/sqoop export --connect jdbc:mysql://node03:3306/library --username root --password 123456 --table book --export-dir /user/hive/warehouse/course.db/hbase2mysqlin --input-fields-terminated-by '\001' --input-null-string '\\N' --input-null-non-string '\\N';

Luego consulte los datos de la tabla de libros de mysql.

mysql> select * from book;

7. Comandos y parámetros comunes de Sqoop

7.1 Lista de comandos comunes

Aquí hay una lista de algunos parámetros comunes utilizados en las operaciones de Sqoop como referencia. Aquellos que necesiten un estudio en profundidad pueden consultar el código fuente de la clase correspondiente.

número de serie	Orden	amable	ilustrar
1	importar	Importar herramienta	Importar datos al clúster
2	exportar	Exportar herramienta	Exportar datos del clúster
3	codificación	Herramienta CodeGen	Obtenga datos de una determinada tabla en la base de datos, genere Java y empaquete Jar
4	crear-tabla-colmena	CrearHiveTableHerramienta	Crear tabla de colmena
5	evaluar	HerramientaEvalSql	Ver resultados de ejecución de SQL
6	importar-todas-las-tablas	Importar todas las tablas	Importar todas las tablas de una base de datos a HDFS
7	trabajo	Herramienta de trabajo	Se utiliza para generar una tarea sqoop. Después de la generación, la tarea no se ejecutará a menos que se use un comando para ejecutar la tarea.
8	lista-bases de datos	Lista de bases de datosHerramienta	Listar todos los nombres de bases de datos
9	tablas de lista	Herramienta ListaTablas	Listar todas las tablas bajo una base de datos
10	unir	Herramienta de combinación	Combine datos en diferentes directorios en HDFS y guárdelos en el directorio especificado
11	metastore	MetastoreHerramienta	Registre la información de metadatos del trabajo de sqoop. Si la instancia de metastore no se inicia, el directorio de almacenamiento de metadatos predeterminado es: ~/.sqoop. Si desea cambiar el directorio de almacenamiento, puede cambiarlo en el archivo de configuración sqoop-site. xml.
12	ayuda	Herramienta de ayuda	Imprimir información de ayuda de sqoop
13	versión	VersionTool	打印sqoop版本信息

7.2、命令&参数详解

刚才列举了一些Sqoop的常用命令，对于不同的命令，有不同的参数，让我们来一一列举说明。首先来我们来介绍一下公用的参数，所谓公用参数，就是大多数命令都支持的参数。

7.2.1、公用参数：数据库连接

序号	参数	说明
1	--connect	连接关系型数据库的URL
2	--connection-manager	指定要使用的连接管理类
3	--driver	JDBC的driver class
4	--help	打印帮助信息
5	--password	连接数据库的密码
6	--username	连接数据库的用户名
7	--verbose	在控制台打印出详细信息

7.2.2、公用参数：import

序号	参数	说明
1	--enclosed-by <char>	给字段值前后加上指定的字符
2	--escaped-by <char>	对字段中的双引号加转义符
3	--fields-terminated-by <char>	设定每个字段是以什么符号作为结束，默认为逗号
4	--lines-terminated-by <char>	设定每行记录之间的分隔符，默认是\n
5	--mysql-delimiters	Mysql默认的分隔符设置，字段之间以逗号分隔，行之间以\n分隔，默认转义符是\，字段值以单引号包裹。
6	--optionally-enclosed-by <char>	给带有双引号或单引号的字段值前后加上指定字符。

7.2.3、公用参数：export

序号	参数	说明
1	--input-enclosed-by <char>	对字段值前后加上指定字符
2	--input-escaped-by <char>	对含有转移符的字段做转义处理
3	--input-fields-terminated-by <char>	字段之间的分隔符
4	--input-lines-terminated-by <char>	行之间的分隔符
5	--input-optionally-enclosed-by <char>	给带有双引号或单引号的字段前后加上指定字符

7.2.4、公用参数：hive

序号	参数	说明
1	--hive-delims-replacement <arg>	用自定义的字符串替换掉数据中的\r\n和\013 \010等字符
2	--hive-drop-import-delims	在导入数据到hive时，去掉数据中的\r\n\013\010这样的字符
3	--map-column-hive <map>	生成hive表时，可以更改生成字段的数据类型
4	--hive-partition-key	创建分区，后面直接跟分区名，分区字段的默认类型为string
5	--hive-partition-value <v>	导入数据时，指定某个分区的值
6	--hive-home <dir>	hive的安装目录，可以通过该参数覆盖之前默认配置的目录
7	--hive-import	将数据从关系数据库中导入到hive表中
8	--hive-overwrite	覆盖掉在hive表中已经存在的数据
9	--create-hive-table	默认是false，即，如果目标表已经存在了，那么创建任务失败。
10	--hive-table	后面接要创建的hive表,默认使用MySQL的表名
11	--table	指定关系数据库的表名

公用参数介绍完之后，我们来按照命令介绍命令对应的特有参数。

7.2.5、命令&参数：import

将关系型数据库中的数据导入到HDFS（包括Hive，HBase）中，如果导入的是Hive，那么当Hive中没有对应表时，则自动创建。

1）命令

如：导入数据到hive中

$ bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp \
--hive-import

如：增量导入数据到hive中，mode=append

append导入：

$ bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp \
--num-mappers 1 \
--fields-terminated-by "\t" \
--target-dir /user/hive/warehouse/emp \
--check-column id \
--incremental append \
--last-value 3

易错提醒：append不能与--hive-等参数同时使用（Append mode for hive imports is not yet supported. Please remove the parameter --append-mode）

如：增量导入数据到hdfs中，mode=lastmodified

先在mysql中建表并插入几条数据：

mysql> create table company.staff_timestamp(id int(4), name varchar(255), sex varchar(255), last_modified timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP);
mysql> insert into company.staff_timestamp (id, name, sex) values(1, 'AAA', 'female');
mysql> insert into company.staff_timestamp (id, name, sex) values(2, 'BBB', 'female');

先导入一部分数据：

$ bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_conn \
--delete-target-dir \
--m 1

再增量导入一部分数据：

mysql> insert into company.staff_timestamp (id, name, sex) values(3, 'CCC', 'female');
$ bin/sqoop import \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_conn \
--check-column last_modified \
--incremental lastmodified \
--last-value "2018-0-28 22:20:38" \
-m 1 \
--append

易错提醒：使用lastmodified方式导入数据要指定增量数据是要--append（追加）还是要--merge-key（合并）

易错提醒：--incremental lastmodified模式下，last-value指定的值是会包含于增量导入的数据中。

2）参数

序号	参数	说明
1	--append	将数据追加到HDFS中已经存在的DataSet中，如果使用该参数，sqoop会把数据先导入到临时文件目录，再合并。
2	--as-avrodatafile	将数据导入到一个Avro数据文件中
3	--as-sequencefile	将数据导入到一个sequence文件中
4	--as-textfile	将数据导入到一个普通文本文件中
5	--boundary-query <statement>	边界查询，导入的数据为该参数的值（一条sql语句）所执行的结果区间内的数据。
6	--columns <col1, col2, col3>	指定要导入的字段
7	--direct	直接导入模式，使用的是关系数据库自带的导入导出工具，以便加快导入导出过程。
8	--direct-split-size	在使用上面direct直接导入的基础上，对导入的流按字节分块，即达到该阈值就产生一个新的文件
9	--inline-lob-limit	设定大对象数据类型的最大值
10	--m或–num-mappers	启动N个map来并行导入数据，默认4个。
11	--query或--e <statement>	将查询结果的数据导入，使用时必须伴随参--target-dir，--hive-table，如果查询中有where条件，则条件后必须加上$CONDITIONS关键字
12	--split-by <column-name>	按照某一列来切分表的工作单元，不能与--autoreset-to-one-mapper连用（请参考官方文档）
13	--table <table-name>	关系数据库的表名
14	--target-dir <dir>	指定HDFS路径
15	--warehouse-dir <dir>	与14参数不能同时使用，导入数据到HDFS时指定的目录
16	--where	从关系数据库导入数据时的查询条件
17	--z或--compress	允许压缩
18	--compression-codec	指定hadoop压缩编码类，默认为gzip(Use Hadoop codec default gzip)
19	--null-string <null-string>	string类型的列如果null，替换为指定字符串
20	--null-non-string <null-string>	非string类型的列如果null，替换为指定字符串
21	--check-column <col>	作为增量导入判断的列名
22	--incremental <mode>	mode：append或lastmodified
23	--last-value <value>	指定某一个值，用于标记增量导入的位置

7.2.6、命令&参数：export

从HDFS（包括Hive和HBase）中奖数据导出到关系型数据库中。

1）命令

如：

$ bin/sqoop export \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_add \
--export-dir /user/company \
--input-fields-terminated-by "\t" \
--num-mappers 1

2）参数

序号	参数	说明
1	--direct	利用数据库自带的导入导出工具，以便于提高效率
2	--export-dir <dir>	存放数据的HDFS的源目录
3	-m或--num-mappers <n>	启动N个map来并行导入数据，默认4个
4	--table <table-name>	指定导出到哪个RDBMS中的表
5	--update-key <col-name>	对某一列的字段进行更新操作
6	--update-mode <mode>	updateonly allowinsert(默认)
7	--input-null-string <null-string>	请参考import该类似参数说明
8	--input-null-non-string <null-string>	请参考import该类似参数说明
9	--staging-table <staging-table-name>	创建一张临时表，用于存放所有事务的结果，然后将所有事务结果一次性导入到目标表中，防止错误。
10	--clear-staging-table	如果第9个参数非空，则可以在导出操作执行前，清空临时事务结果表

7.2.7、命令&参数：codegen

将关系型数据库中的表映射为一个Java类，在该类中有各列对应的各个字段。如：

$ bin/sqoop codegen \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_add \
--bindir /home/admin/Desktop/staff \
--class-name Staff \
--fields-terminated-by "\t"

序号	参数	说明
1	--bindir <dir>	指定生成的Java文件、编译成的class文件及将生成文件打包为jar的文件输出路径
2	--class-name <name>	设定生成的Java文件指定的名称
3	--outdir <dir>	生成Java文件存放的路径
4	--package-name <name>	包名，如com.z，就会生成com和z两级目录
5	--input-null-non-string <null-str>	在生成的Java文件中，可以将null字符串或者不存在的字符串设置为想要设定的值（例如空字符串）
6	--input-null-string <null-str>	将null字符串替换成想要替换的值（一般与5同时使用）
7	--map-column-java <arg>	数据库字段在生成的Java文件中会映射成各种属性，且默认的数据类型与数据库类型保持对应关系。该参数可以改变默认类型，例如：--map-column-java id=long, name=String
8	--null-non-string <null-str>	在生成Java文件时，可以将不存在或者null的字符串设置为其他值
9	--null-string <null-str>	在生成Java文件时，将null字符串设置为其他值（一般与8同时使用）
10	--table <table-name>	对应关系数据库中的表名，生成的Java文件中的各个属性与该表的各个字段一一对应

7.2.8、命令&参数：create-hive-table

生成与关系数据库表结构对应的hive表结构。

命令：

$ bin/sqoop create-hive-table \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_add \
--hive-table emp_add

参数：

序号	参数	说明
1	--hive-home <dir>	Hive的安装目录，可以通过该参数覆盖掉默认的Hive目录
2	--hive-overwrite	覆盖掉在Hive表中已经存在的数据
3	--create-hive-table	默认是false，如果目标表已经存在了，那么创建任务会失败
4	--hive-table	后面接要创建的hive表
5	--table	指定关系数据库的表名

7.2.9、命令&参数：eval

可以快速的使用SQL语句对关系型数据库进行操作，经常用于在import数据之前，了解一下SQL语句是否正确，数据是否正常，并可以将结果显示在控制台。

命令：

$ bin/sqoop eval \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--query "SELECT * FROM emp"

参数：

序号	参数	说明
1	--query或--e

7.2.10、命令&参数：import-all-tables

可以将RDBMS中的所有表导入到HDFS中，每一个表都对应一个HDFS目录

命令：

$ bin/sqoop import-all-tables \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--warehouse-dir /all_tables

参数：

序号	参数	说明
1	--as-avrodatafile	这些参数的含义均和import对应的含义一致
2	--as-sequencefile
3	--as-textfile
4	--direct
5	--direct-split-size <n>
6	--inline-lob-limit <n>
7	--m或—num-mappers <n>
8	--warehouse-dir <dir>
9	-z或--compress
10	--compression-codec

7.2.11、命令&参数：job

用来生成一个sqoop任务，生成后不会立即执行，需要手动执行。

命令：

$ bin/sqoop job \
 --create myjob -- import-all-tables \
 --connect jdbc:mysql://node03:3306/userdb \
 --username root \
 --password 123456
$ bin/sqoop job \
--list
$ bin/sqoop job \
--exec myjob

易错提醒：注意import-all-tables和它左边的--之间有一个空格

易错提醒：如果需要连接metastore，则--meta-connect jdbc:hsqldb:hsql://node03:16000/sqoop

参数：

序号	参数	说明
1	--create <job-id>	创建job参数
2	--delete <job-id>	删除一个job
3	--exec <job-id>	执行一个job
4	--help	显示job帮助
5	--list	显示job列表
6	--meta-connect <jdbc-uri>	用来连接metastore服务
7	--show <job-id>	显示一个job的信息
8	--verbose	打印命令运行时的详细信息

易错提醒：在执行一个job时，如果需要手动输入数据库密码，可以做如下优化

<property>
	<name>sqoop.metastore.client.record.password</name>
	<value>true</value>
	<description>If true, allow saved passwords in the metastore.</description>
</property>

7.2.12、命令&参数：list-databases

命令：

$ bin/sqoop list-databases \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456

参数：与公用参数一样

7.2.13、命令&参数：list-tables

命令：

$ bin/sqoop list-tables \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456

参数：与公用参数一样

7.2.14、命令&参数：merge

将HDFS中不同目录下面的数据合并在一起并放入指定目录中

数据环境：

new_staff
1       AAA     male
2       BBB     male
3       CCC     male
4       DDD     male
old_staff
1       AAA     female
2       CCC     female
3       BBB     female
6       DDD     female

易错提醒：上边数据的列之间的分隔符应该为\t，行与行之间的分割符为\n，如果直接复制，请检查之。

命令：

创建JavaBean：

$ bin/sqoop codegen \
--connect jdbc:mysql://node03:3306/userdb \
--username root \
--password 123456 \
--table emp_conn \
--bindir /home/admin/Desktop/staff \
--class-name EmpConn \
--fields-terminated-by "\t"

开始合并：

$ bin/sqoop merge \
--new-data /test/new/ \
--onto /test/old/ \
--target-dir /test/merged \
--jar-file /home/admin/Desktop/staff/EmpConn.jar \
--class-name Staff \
--merge-key id

结果：

1	AAA	MALE
2	BBB	MALE
3	CCC	MALE
4	DDD	MALE
6	DDD	FEMALE

参数：

序号	参数	说明
1	--new-data <path>	HDFS 待合并的数据目录，合并后在新的数据集中保留
2	--onto <path>	HDFS合并后，重复的部分在新的数据集中被覆盖
3	--merge-key <col>	合并键，一般是主键ID
4	--jar-file <archivo>	El paquete jar introducido durante la fusión se genera a través de la herramienta Codegen.
5	--nombre-clase <clase>	El nombre de la tabla correspondiente o el nombre del objeto, la clase está incluida en el paquete jar
6	--target-dir <ruta>	El directorio donde se almacenan los datos combinados en HDFS

7.2.15 Comando y parámetros: metastore

Se registra la información de metadatos del trabajo Sqoop. Si el servicio no se inicia, el directorio de almacenamiento de metadatos del trabajo predeterminado es ~/.sqoop, que se puede modificar en sqoop-site.xml.

Orden:

Por ejemplo: inicie el servicio metastore de sqoop

$ bin/sqoop metastore

parámetro:

número de serie	parámetro	ilustrar
1	--cerrar	Cerrar metastore

8. Trabajo rápido

Nota: Trabajo Sqoop: ejecute tareas de importación y exportación de datos predefinidas de acuerdo con el proceso especificado

8.1 Gramática

La siguiente es la sintaxis para crear un trabajo Sqoop.

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

8.2 Crear trabajo (--create)

Aquí creamos un trabajo llamado myjob, que puede importar datos de la tabla RDBMS a HDFS.

bin/sqoop job --create myjob2 -- import --connect jdbc:mysql://node03:3306/userdb --username root --password 123456 --table emp --delete-target-dir

Este comando crea un trabajo que importa desde la tabla de empleados de la biblioteca de base de datos a un archivo HDFS.

8.3 Trabajo de verificación (--list)

El parámetro '--list' se utiliza para verificar los trabajos guardados. El siguiente comando se utiliza para verificar la lista de trabajos de Sqoop guardados.

bin/sqoop job --list

Muestra la lista de trabajos guardados.

Verificar trabajos (--show) '--show'

Los parámetros se utilizan para comprobar o verificar un trabajo específico y sus detalles. Los siguientes comandos y resultados de muestra se utilizan para verificar un trabajo llamado myjob.

$ sqoop job --show myjob

Muestra las herramientas y su selección que se utilizan en el trabajo myjob.

8.4 Ejecutar trabajo (--exec)

La opción '--exec' se utiliza para ejecutar el trabajo guardado. El siguiente comando se utiliza para ejecutar un trabajo guardado llamado myjob.

bin/sqoop job --exec myjob2

Artículo reimpreso de: 1. Introducción a Sqoop - Zhihu

1. Información general

2. Mecanismo de trabajo de Sqoop

3. Comparación de las arquitecturas Sqoop1 y Sqoop2

3.1 Arquitectura Sqoop1

3.2 Arquitectura Sqoop2

4. Instalación e implementación de Sqoop

4.1 Paso 1: Descargue el paquete de instalación

4.2 Paso 2: Cargar y descomprimir

4.3 Paso 3: Modificar el archivo de configuración

4.4 Paso 4: Agregue dos paquetes de frascos necesarios

4.5 Paso 5: Configurar las variables de entorno de Sqoop

4.6 La ayuda de Sqoop tiene registros de advertencia

4.7 La ayuda de Sqoop tiene errores

4.7.1 Solución 1

4.7.2 Solución 2

5. Importación de datos de Sqoop

5.1 Listar todas las bases de datos

5.2 Preparar datos de la tabla

5.3 Importar datos de la tabla de la base de datos a HDFS

5.4 Importar el directorio especificado de HDFS

5.5 Importar al directorio especificado de hdfs y especificar el separador entre campos

5.6 Importar la tabla relacional a Hive

1) Paso uno: copie el paquete jar

2) Paso 2: preparar la base de datos y las tablas de Hive

3) Paso 3: Comience a importar

4) Paso 4: Ver los datos de la tabla de colmena

5.7 Importar tablas relacionales a Hive y crear automáticamente tablas de Hive

5.8 Importar datos de tablas mysql a hbase

1) Paso uno: modificar el archivo de configuración de sqoop

2) Paso 2: Crear una base de datos y una tabla de base de datos en mysql e insertar datos

3) Paso 3: Importar los datos de la tabla mysql a la tabla HBase

4) Paso 4: Ver los datos de la tabla en HBase

5.9 Importar subconjuntos de datos de tablas

5.10 Búsqueda e importación de sentencias SQL a HDFS

5.11 Importación incremental

1) La primera importación incremental se implementa utilizando las opciones anteriores.

2) El segundo tipo de importación incremental se implementa mediante la condición --where

6. Exportación de datos de Sqoop

6.1 Exportar archivos de datos desde HDFS a la base de datos RDBMS

6.1.1 Paso 1: crear una tabla mysql

6.1.2 Paso 2: ejecutar el comando de exportación

6.1.3 Paso 3: Verificar los datos de la tabla MySQL

6.2 Exportar datos de Hbase a mysql

6.2.1 Paso 1: crear una tabla externa de colmena

6.2.2 Paso 2: Crear una tabla interna de Hive e insertar datos de la tabla externa en la tabla interna

6.2.3 Paso 3: Insertar datos de la tabla externa en la tabla interna

6.2.4 Paso 4: Borrar datos de la tabla MySQL

6.2.5 Paso 5: Ejecute sqoop para exportar los datos de la tabla interna de Hive a

7. Comandos y parámetros comunes de Sqoop

7.1 Lista de comandos comunes

7.2、命令&参数详解

7.2.1、公用参数：数据库连接

7.2.2、公用参数：import

7.2.3、公用参数：export

7.2.4、公用参数：hive

7.2.5、命令&参数：import

1） 命令

2）参数

7.2.6、命令&参数：export

1）命令

2）参数

7.2.7、命令&参数：codegen

7.2.8、命令&参数：create-hive-table

7.2.9、命令&参数：eval

7.2.10、命令&参数：import-all-tables

7.2.11、命令&参数：job

7.2.12、命令&参数：list-databases

7.2.13、命令&参数：list-tables

7.2.14、命令&参数：merge

7.2.15 Comando y parámetros: metastore

8. Trabajo rápido

8.1 Gramática

8.2 Crear trabajo (--create)

8.3 Trabajo de verificación (--list)

8.4 Ejecutar trabajo (--exec)

Supongo que te gusta

1）命令