Hive

En los bloques anteriores hemos guardado archivos, elegido formatos y ejecutado procesos sobre ellos. Hive añade una forma de consultarlos mediante HiveQL, un lenguaje próximo a SQL. Para interpretar un archivo necesita su esquema, formato y ubicación: esa descripción vive en el metastore. Los bytes de las filas siguen estando en el almacenamiento.

De una consulta a sus archivos

Beeline → HiveServer2 → análisis y plan → motor de ejecución → HDFS
               │
               └── Metastore: esquema, formato, ubicación y particiones

Sigue SELECT AVG(salario) FROM empleados_texto: Beeline envía la consulta al servidor; este consulta el esquema y ubicación, comprueba la expresión y construye el plan; el motor lee los archivos con el lector adecuado y devuelve el resultado. El metastore contiene la definición de salario, no la lista de salarios.

Elemento	Responsabilidad	Comprobación si falla
Beeline	Cliente JDBC que envía HiveQL	URL y conexión al servidor.
HiveServer2	Sesiones y ejecución de consultas	Disponibilidad y registros.
Metastore	Definiciones y ubicaciones de tablas	Base activa y esquema.
Motor	Ejecutar el plan	Recursos y mensajes del trabajo.
HDFS	Guardar los archivos reales	Rutas, permisos y réplicas.

Declarar Parquet sobre CSV no convierte archivos: el lector intentará interpretar bytes que no corresponden al formato. Un orden incorrecto de columnas también puede producir nulos o valores desplazados aunque el SQL sea válido.

Preparación del laboratorio

La receta histórica de DOCUMENTACION/M01/curso_siguiente/6hive.md utiliza un metastore Derby y prepara /user/hive/warehouse en HDFS. El laboratorio conserva esa separación y utiliza la imagen oficial Hive 4.0.1 con HiveServer2, siguiendo el quickstart oficial Docker. La arquitectura descrita por Aitor Medrano permite reconocer las mismas responsabilidades: HDFS, catálogo y servidor SQL. Su despliegue completo usa un metastore MySQL compartido y más motores; aquí se prepara únicamente el recorrido Hive ya incluido en M01.

El laboratorio conserva Derby en un volumen Docker y los archivos en el HDFS del clúster de modulo01/. Usa MapReduce local dentro de HiveServer2: estudiamos tablas y almacenamiento; las pruebas de procesamiento distribuido se realizan en 03–04 con YARN. La imagen Hive es amd64 y requiere emulación en Apple Silicon. La primera descarga ronda 1 GB y el healthcheck puede tardar 1–2 minutos. No se comparará su rendimiento con producción.

Arrancar Hadoop y HiveServer2

En el anfitrión, usa el mismo repositorio que en 03–04. Si todavía no lo has clonado, ejecuta estas órdenes:

git clone https://github.com/josepgarcia/BigDataAplicadoLab_2627.git
cd BigDataAplicadoLab_2627/modulo01

Si ya lo tienes, ejecuta git pull desde su raíz y entra en modulo01/. Ejecuta desde modulo01/ todas las órdenes del anfitrión. Si sigue activo hadoop-manual o hadoop-manual-web, detén ese contenedor para liberar los puertos compartidos.

make up
make hive-up

El clúster usa bda-m01-hadoop:3.4.1-r3. Hive usa bda-m01-hive:4.0.1-r2, el proyecto Compose m01-hive y la red externa m01-yarn_default del clúster. Publica en localhost los puertos 10000 (JDBC) y 10002 (interfaz web). HiveServer2 suma alrededor de 1 GB al consumo del clúster. Las consultas del bloque funcionan también sobre HDFS en modo mini. Para usarlo, sustituye make up por make up-mini y ejecuta después make hive-up.

make hive-up prepara los directorios HDFS como hadoop para la cuenta hive y espera a que HiveServer2 esté listo. Si usas PowerShell sin Make, ejecuta estas órdenes en su lugar:

docker compose -f hadoop/compose.yaml up -d --wait
docker compose -f hadoop/compose.yaml exec --user hadoop master hdfs dfs -mkdir -p /user/hive/warehouse /user/hive/external /tmp
docker compose -f hadoop/compose.yaml exec --user hadoop master hdfs dfs -chown -R hive /user/hive
docker compose -f hadoop/compose.yaml exec --user hadoop master hdfs dfs -chmod 1777 /tmp
docker compose -f hive/compose.yaml up -d --build --wait

Para usar el modo mini sin Make, sustituye solo la primera orden por las dos órdenes Compose del modo mini en el README del laboratorio. Si cambias de modo con Hive en marcha, detén antes Hive con docker compose -f hive/compose.yaml down y vuelve a levantarlo con la receta anterior para que se conecte al clúster recién configurado.

El permiso 1777 permite temporales y aplica el bit sticky: una cuenta ordinaria no puede borrar archivos ajenos solo por escribir en ese directorio. Es una configuración específica de /tmp, no una solución general de permisos.

Abrir Beeline

Abre Beeline dentro de HiveServer2:

make hive-beeline

El healthcheck ejecuta SELECT 1. Si falla, consulta los registros con make hive-logs antes de recrear datos. Equivalentes sin Make para abrir Beeline y consultar los registros, respectivamente:

docker compose -f hive/compose.yaml exec hiveserver2 beeline -u 'jdbc:hive2://localhost:10000/default' -n hive
docker compose -f hive/compose.yaml logs --tail=80 hiveserver2

Los bloques sql siguientes se escriben en Beeline. Usa !quit para volver al anfitrión. localhost es correcto porque cliente y servidor están en el mismo contenedor; HDFS, en cambio, se localiza mediante master en la red de Compose.

Un conjunto de datos conocido

El archivo modulo01/hive/datos/empleados.csv se monta, en solo lectura, como /datos-entrada/empleados.csv:

empleados.csv

Ana,datos,32000
Bruno,infraestructura,28000
Carla,datos,36000

No tiene cabecera. El esquema es nombre,departamento,salario, por ese orden. No hay comas dentro de los campos ni valores entrecomillados. El lector delimitado se utiliza con esta muestra sencilla; un CSV general necesita un SerDe compatible con sus reglas. SerDe significa serializador/deserializador: interpreta cómo los bytes se convierten en columnas y viceversa.

Bases, tablas y carga

CREATE DATABASE IF NOT EXISTS m01_empresa;
USE m01_empresa;
CREATE TABLE IF NOT EXISTS empleados_texto (
  nombre STRING,
  departamento STRING,
  salario DOUBLE
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
STORED AS TEXTFILE
TBLPROPERTIES ('transactional'='false');

LOAD DATA LOCAL INPATH '/datos-entrada/empleados.csv'
OVERWRITE INTO TABLE empleados_texto;
SELECT COUNT(*) AS filas FROM empleados_texto;

CREATE DATABASE organiza las definiciones; USE fija dónde se crean y buscan tablas. ROW FORMAT declara el separador y TEXTFILE el lector. LOCAL significa local al servidor HiveServer2, no al portátil del alumno: por eso el archivo está montado en el servicio.

El resultado debe ser 3. OVERWRITE sustituye la carga anterior de esta tabla de prueba; permite repetirla sin duplicar registros. No se usa sobre datos que haya que conservar. La tabla no es transaccional en este recorrido: no se está demostrando ACID de Hive ni equivalencia con PostgreSQL.

SHOW TABLES;
DESCRIBE empleados_texto;
DESCRIBE FORMATTED empleados_texto;

Localiza tipo de tabla, Location y formato. Anota la ubicación real: será la que comprobarás desde HDFS, en vez de suponer una ruta para cualquier instalación.

Consultas sobre la misma muestra

SELECT departamento, COUNT(*) AS personas, AVG(salario) AS salario_medio
FROM empleados_texto
GROUP BY departamento
ORDER BY departamento;

GROUP BY reúne las filas del mismo departamento; COUNT cuenta y AVG calcula su media. ORDER BY hace predecible el orden mostrado. Deben aparecer datos,2,34000 e infraestructura,1,28000, aunque cambie el formato decimal.

Para una unión necesitamos otra tabla preparada:

CREATE TABLE IF NOT EXISTS departamentos (
  departamento STRING, responsable STRING
) STORED AS TEXTFILE TBLPROPERTIES ('transactional'='false');
INSERT OVERWRITE TABLE departamentos VALUES
('datos','Eva'),('infraestructura','Luis');

SELECT e.nombre, d.responsable
FROM empleados_texto e LEFT JOIN departamentos d
ON e.departamento=d.departamento
ORDER BY e.nombre;

LEFT JOIN conserva cada empleado aunque no encuentre coincidencia. Comprueba antes el resultado a mano: Ana y Carla se asocian con Eva; Bruno con Luis.

Formato físico y tablas gestionadas o externas

Una tabla gestionada permite a Hive administrar su ciclo de vida, incluidos los datos. Una externa describe archivos cuyo ciclo de vida puede pertenecer a otros procesos. En ambas hay metadatos; cambia la responsabilidad sobre archivos.

CREATE EXTERNAL TABLE IF NOT EXISTS empleados_ext (
  nombre STRING, departamento STRING, salario DOUBLE
)
STORED AS PARQUET
LOCATION '/user/hive/external/empleados_parquet'
TBLPROPERTIES ('external.table.purge'='false');

INSERT OVERWRITE TABLE empleados_ext SELECT * FROM empleados_texto;
SELECT COUNT(*) AS filas_parquet FROM empleados_ext;
DESCRIBE FORMATTED empleados_ext;

LOCATION registra dónde leer; no convierte nada. INSERT ... SELECT lee las filas de texto y escribe Parquet, porque ese es el formato del destino. Debe volver a haber tres filas. Comparar el recuento es un primer control, al que se añaden una muestra y la agregación por departamento para verificar el contenido.

Operación	Origen	Efecto en este laboratorio
LOAD DATA LOCAL INPATH	Archivo local a HiveServer2	Copia al almacén HDFS de la tabla.
LOAD DATA INPATH	Archivo en HDFS	Normalmente mueve al destino; ciertos casos/versiones reescriben la carga como inserción.
LOCATION	Ruta de almacenamiento	Registra ubicación, sin transformar archivos.
INSERT ... SELECT	Filas de otra tabla	Ejecuta consulta y escribe en el formato destino.

La conservación de una externa al borrarla depende también de sus propiedades.

El laboratorio configura metastore.metadata.transformer.class con un espacio en <value> </value> para desactivarlo y reproducir la distinción clásica gestionada/externa de los apuntes anteriores. Hive 4 puede transformar una tabla no ACID en externa con purga automática; por eso no basta con inferir el tipo a partir de la presencia de EXTERNAL en la sentencia: se debe comprobar Table Type y las propiedades. Este ajuste está documentado en HIVE-28198.

external.table.purge=true puede permitir eliminar archivos con DROP TABLE; nuestro ejemplo fija false. Revisa DESCRIBE FORMATTED antes del borrado.

Particiones: almacenamiento y catálogo

Una partición organiza archivos por un valor habitual de filtro. Usamos fecha, como en el bloque 05, pero hay que mantener alineados directorios y metastore:

CREATE EXTERNAL TABLE IF NOT EXISTS ventas_por_fecha (
  producto STRING, categoria STRING, importe DECIMAL(12,2)
)
PARTITIONED BY (fecha DATE)
STORED AS PARQUET
LOCATION '/user/hive/external/ventas_por_fecha'
TBLPROPERTIES ('external.table.purge'='false');

INSERT OVERWRITE TABLE ventas_por_fecha PARTITION(fecha='2026-10-22')
SELECT 'teclado','perifericos',CAST(75.00 AS DECIMAL(12,2));
SHOW PARTITIONS ventas_por_fecha;
SELECT fecha, SUM(importe) AS total
FROM ventas_por_fecha WHERE fecha='2026-10-22' GROUP BY fecha;

La partición estática recibe la fecha en la orden; el registro aporta las otras tres columnas. Deben aparecer una partición y total 75. El filtro permite limitar los archivos considerados, aunque esta muestra no sirve para medir aceleración.

Cuando otro proceso escribe una partición, hay que registrarla. Esta instrucción registra la ruta ya creada sin duplicarla gracias a IF NOT EXISTS:

ALTER TABLE ventas_por_fecha
ADD IF NOT EXISTS PARTITION(fecha='2026-10-22')
LOCATION '/user/hive/external/ventas_por_fecha/fecha=2026-10-22';

En un caso nuevo, comprueba primero archivos, esquema y ubicación. Registrar una partición no fabrica los datos que falten en su directorio.

Tipos complejos y formatos

Hive admite ARRAY<STRING>, MAP<STRING,INT> y STRUCT<edad:INT,activo:BOOLEAN>. Un array representa una colección ordenada; un mapa asocia claves con valores; un struct reúne campos con nombre. Se usan cuando la estructura real lo necesita, no para complicar una tabla plana.

Parquet y ORC soportan estructuras complejas y lectura columnar. ORC tiene una integración estrecha con Hive; Parquet facilita intercambio entre motores. El criterio sigue siendo consumidor, patrón de acceso y comparación sobre la misma muestra, como en el bloque 05.

Ejecutar el recorrido automatizado

Tras salir de Beeline con !quit, make hive-recorrido ejecuta /sql/recorrido.sql en HiveServer2. Crea la base m01_empresa si falta y sobrescribe las cargas de las tablas de práctica. Si no tienes Make, usa:

docker compose -f hive/compose.yaml exec hiveserver2 beeline -u 'jdbc:hive2://localhost:10000/default' -n hive -f /sql/recorrido.sql

Comprobar el ciclo de vida

Vuelve a abrir Beeline con make hive-beeline, selecciona la base con USE m01_empresa; y crea una copia gestionada de práctica. Anota ambas ubicaciones:

CREATE TABLE empleados_copia_gestionada
STORED AS PARQUET TBLPROPERTIES ('transactional'='false')
AS SELECT * FROM empleados_texto;
DESCRIBE FORMATTED empleados_copia_gestionada;
DESCRIBE FORMATTED empleados_ext;

Sal con !quit. En el anfitrión usa el cliente HDFS para comprobar la ubicación externa y repite -ls con la ubicación gestionada que has anotado:

docker compose -f hadoop/compose.yaml exec --user hadoop master hdfs dfs -ls /user/hive/external/empleados_parquet

Vuelve a Beeline y borra exclusivamente las dos definiciones de práctica:

USE m01_empresa;
DROP TABLE empleados_copia_gestionada;
DROP TABLE empleados_ext;

La copia gestionada desaparece de su ubicación original; si hay papelera, puede conservarse allí. Los archivos externos permanecen porque no se habilitó purga. Sal con !quit y repite las dos comprobaciones con -ls desde el anfitrión. Vuelve a abrir Beeline, selecciona m01_empresa y ejecuta solo el CREATE EXTERNAL TABLE de empleados_ext. Al repetir el recuento, debe leer tres filas sin insertar de nuevo. Una tabla externa no es una copia de seguridad.

Exportar un resultado

INSERT OVERWRITE LOCAL DIRECTORY 'file:///opt/hive/trabajo/resumen'
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
SELECT departamento, AVG(salario)
FROM empleados_ext GROUP BY departamento;

LOCAL vuelve a referirse al servidor. El prefijo file:/// identifica además su sistema de archivos local, evitando resolver la ruta contra HDFS. Tras !quit, inspecciona los archivos en el anfitrión:

docker compose -f hive/compose.yaml exec hiveserver2 bash -lc 'ls -l /opt/hive/trabajo/resumen && cat /opt/hive/trabajo/resumen/*'

El resumen contiene estas dos filas, en cualquier orden:

datos,34000.0
infraestructura,28000.0

La exportación está en la capa escribible del contenedor. Para conservarla antes de down, cópiala desde el anfitrión con docker compose -f hive/compose.yaml cp hiveserver2:/opt/hive/trabajo/resumen ./resumen-hive-m01. Esto no copia el metastore ni los archivos HDFS: conserva solo el resultado local.

Actividades

Son actividades formativas. Conserva identificador, SQL y salidas relevantes. Solo las actividades expresamente anunciadas como calificables tendrán ese uso.

M01-HIVE-01 — Consulta y diagnóstico

Reproduce carga, agregación y unión con departamentos. Entrega SQL, recuento y una tabla con esquema, ubicación y formato. Deben aparecer tres empleados y ninguna fila perdida en la unión. Explica qué revisarías si la tabla existe pero está vacía.

M01-HIVE-02 — Tablas y ciclo de vida

Convierte empleados a Parquet. Crea la copia gestionada, predice y comprueba los dos borrados y recupera la definición externa. Entrega ubicaciones y evidencias antes/después. La externa recreada debe recuperar tres filas sin una nueva carga.

M01-HIVE-03 — Partición y exportación

Añade a ventas una partición 2026-10-23, producto raton, categoría perifericos e importe 25.00. Consulta cada fecha y el total conjunto. Exporta el resumen de empleados. Debes obtener dos particiones, totales 75 y 25 y conjunto 100. Explica la diferencia entre exportar archivos locales y registrar una partición HDFS.

Diagnóstico y cierre

Síntoma	Primera comprobación
Red m01-yarn_default inexistente	Arrancar antes el clúster con make up o make up-mini.
Derby bloqueado	No compartir el volumen con otra instancia simultánea.
Permiso HDFS denegado	Propietario de /user/hive, sin abrir todo HDFS.
Columnas desplazadas	Orden, separador, cabecera y formato real.
Partición ausente	Archivos y registro en el metastore.
Datos eliminados con DROP	Tipo de tabla y propiedad de purga.

Si necesitas una comprobación rápida, make test-hive ejecuta una prueba de humo en una base temporal. make hive-down detiene Hive y conserva Derby si necesitas seguir usando HDFS. Al acabar, make down detiene Hive y después el clúster, conservando los volúmenes para la próxima sesión. Sin Make, ejecuta las dos órdenes en este orden:

docker compose -f hive/compose.yaml down
docker compose -f hadoop/compose.yaml down

Derby y los archivos HDFS son almacenes distintos. Si necesitas reiniciar el catálogo, make hive-clean ejecuta docker compose -f hive/compose.yaml down -v y borra Derby. Los archivos del clúster HDFS se conservan. El apartado final relaciona las decisiones aprendidas con el diseño de persistencia que continuará en M02.