1. Exportación del esquema de SCOTT con Oracle Data Pump

Vamos a entrar como administrador y vamos a crear el directorio de Data Pump

Oracle Data Pump no trabaja con rutas del sistema operativo directamente. Necesita un objeto DIRECTORY dentro de Oracle que apunte a una carpeta real del sistema.

1CREATE OR REPLACE DIRECTORY ej1_dir AS '/home/oracle';

Este comando crea un objeto lógico dentro de Oracle. dp_dir es el nombre que usaremos en los comandos de expdp/impdp para referirnos a esa ruta. La carpeta indicada es la ruta real del sistema operativo donde se guardarán los ficheros; si no existe, se crea.

Ahora damos permiso a SCOTT para usar ese directorio

1GRANT READ, WRITE ON DIRECTORY ej1_dir TO c##scott;

Sin esto, SCOTT no puede leer ni escribir en ese directorio aunque exista.

Estimación previa del tamaño

Antes de exportar de verdad, hacemos una estimación del espacio necesario. Creamos un archivo de parámetros:

1nano /tmp/export_scott.par

1SCHEMAS=SCOTT
2CONTENT=ALL
3DIRECTORY=dp_dir
4DUMPFILE=scott_export.dmp
5LOGFILE=ej1_dir:scott_export.log
6EXCLUDE=TABLE:"='BONUS'"
7QUERY=SCOTT.EMP:"WHERE DEPTNO IN (SELECT DEPTNO FROM SCOTT.EMP GROUP BY DEPTNO HAVING COUNT(*) >= 2)"
8REUSE_DUMPFILES=YES

Y probamos:

1expdp c##scott/tiger@localhost:1521/orclpdb1 PARFILE=/tmp/export_scott.par

Explicación de los parámetros:

  • SCHEMAS=SCOTT: le decimos que queremos trabajar con el esquema (conjunto de objetos) de SCOTT
  • ESTIMATE_ONLY=YES: con esto no se exporta nada, solo calcula cuánto espacio ocuparía — muy útil antes de lanzar exportaciones grandes
  • DIRECTORY=dp_dir: usa el directorio Oracle que creamos antes
  • LOGFILE=ej1_dir:scott_export.log: genera un log con el resultado en ese directorio

Salida de expdp exportando el esquema de SCOTT: tablas DEPT y EMP exportadas

La exportación real con todas las condiciones

Ahora la exportación está completa. Hay que programarla para dentro de 2 minutos:

1echo "expdp c##scott/tiger@localhost:1521/orclpdb1 PARFILE=/tmp/export_scott.par" | at now + 2 minutes

Programación del job de exportación con at now + 2 minutes

Esperamos hasta la hora programada y luego comprobamos que el fichero se generó:

1ls -l

Listado del directorio con el fichero scott_export.log ya generado

Contenido del log confirmando que la exportación se completó correctamente

2. Importar el fichero en un usuario distinto de la misma base de datos

Creamos el usuario destino en Oracle

1ALTER SESSION SET CONTAINER = ORCLPDB1;
2
3CREATE USER scott2 IDENTIFIED BY tiger2;
4GRANT CONNECT, RESOURCE TO scott2;
5GRANT UNLIMITED TABLESPACE TO scott2;
6GRANT READ, WRITE ON DIRECTORY dp_dir TO scott2;

Creación del usuario scott2 y concesión de permisos en SQL*Plus

Ejecutamos la exportación de los datos

1expdp c##scott/tiger@localhost:1521/orclpdb1 PARFILE=/tmp/export_scott.par

Nueva ejecución de expdp para generar el dump que se va a importar en scott2

Y ahora la importamos

1impdp system/oracle@localhost:1521/orclpdb1 DIRECTORY=dp_dir DUMPFILE=scott_export.dmp LOGFILE=dp_dir:importacion_scott2.log REMAP_SCHEMA=SCOTT:SCOTT2

REMAP_SCHEMA=SCOTT:SCOTT2 es la clave: le dice a Data Pump que todo lo que pertenecía a SCOTT se cree en el esquema SCOTT2 en lugar de en el original.

Salida de impdp importando el esquema de SCOTT remapeado a SCOTT2

Verificamos

1sqlplus system/oracle@localhost:1521/orclpdb1
2SELECT TABLE_NAME FROM DBA_TABLES WHERE OWNER = 'SCOTT2';
3SELECT COUNT(*) FROM SCOTT2.EMP;
4SELECT COUNT(*) FROM SCOTT2.DEPT;

Verificación en SQL*Plus de las tablas EMP y DEPT ya presentes en el esquema SCOTT2

3. Exportación de la estructura completa con expdp (al menos 5 opciones)

Conceder permisos de exportación completa

El usuario c##scott necesita el rol DATAPUMP_EXP_FULL_DATABASE para poder realizar un export de toda la base de datos (FULL=YES). Sin este rol solo puede exportar su propio esquema.

1GRANT DATAPUMP_EXP_FULL_DATABASE TO c##scott;

Concesión del rol DATAPUMP_EXP_FULL_DATABASE a c##scott en SQL*Plus

Crear el fichero de parámetros (parfile)

En lugar de escribir todos los parámetros en la línea de comandos, Oracle Data Pump permite agruparlos en un fichero de parámetros (.par). Esto facilita la reutilización y documentación del proceso.

1FULL=YES
2CONTENT=METADATA_ONLY
3DIRECTORY=dp_dir
4DUMPFILE=full_estructura.dmp
5LOGFILE=root_dir:full_estructura.log
6COMPRESSION=METADATA_ONLY
7FLASHBACK_TIME=SYSTIMESTAMP
8REUSE_DUMPFILES=YES
9METRICS=YES

Fichero de parámetros export_full.par abierto en nano

Al menos cinco opciones documentadas:

  • FULL=YES: exporta toda la base de datos completa, no solo un esquema
  • CONTENT=METADATA_ONLY: exporta únicamente la estructura DDL (CREATE TABLE, CREATE INDEX…), sin datos
  • COMPRESSION=METADATA_ONLY: comprime los metadatos dentro del fichero .dmp para reducir su tamaño
  • FLASHBACK_TIME=SYSTIMESTAMP: garantiza consistencia exportando todos los objetos en el mismo punto exacto del tiempo
  • REUSE_DUMPFILES=YES: si el fichero .dmp ya existe lo sobreescribe en lugar de dar error
  • METRICS=YES: añade al log información detallada de rendimiento y tiempo por cada objeto exportado

Ejecutar la exportación

1expdp c##scott/tiger@localhost:1521/orclpdb1 PARFILE=/tmp/export_full.par

Salida de expdp exportando la estructura completa de la base de datos

4. Importación/exportación con MySQL desde línea de comandos

MySQL y MariaDB incluyen la herramienta mysqldump para exportar bases de datos a ficheros SQL de texto plano. Estos ficheros contienen todas las sentencias necesarias para recrear la estructura y los datos. En este ejercicio se crea una base de datos de prueba, se exporta desde el servidor de bases de datos y se importa en otra máquina.

Crear la base de datos ej4 en servidorbd

Se crea una base de datos llamada ej4 con dos tablas de prueba: empleados y departamentos, con datos representativos.

Comprobación de las tablas y datos de la base de datos ej4 recién creada

Exportar con mysqldump

mysqldump genera un fichero .sql con todas las sentencias CREATE TABLE e INSERT necesarias para recrear la base de datos completa. Es la herramienta estándar de exportación en MySQL y MariaDB.

1mysqldump -u root -p ej4 > /tmp/ej4.sql

Ahora nos la pasamos por scp:

1scp /tmp/ej4.sql oracle@192.168.122.48:/tmp/

Exportación con mysqldump y transferencia del fichero por scp

Ahora en nuestra otra máquina creamos una base de datos llamada ej4_importacion para importar la base de datos:

Creación de la base de datos ej4_importacion en MariaDB

Importamos el fichero a nuestra bd nueva

1sudo mysql -u root -p ej4_importacion < /tmp/ej4.sql

Importación del volcado SQL en la base de datos ej4_importacion

Verificamos

Verificación en MariaDB: tablas y datos de empleados y departamentos ya presentes en ej4_importacion

5. Importación/exportación con PostgreSQL desde línea de comandos

PostgreSQL incluye las herramientas pg_dump y pg_dumpall para exportar bases de datos. pg_dump exporta una base de datos concreta, mientras que pg_dumpall exporta toda la instancia. El fichero generado contiene sentencias SQL estándar compatibles con psql para la importación.

Aquí en Postgres haremos lo mismo: crearemos una base de datos llamada ej5 y repetiremos el mismo proceso que en MariaDB.

Creación de la base de datos ej5 en PostgreSQL

Comprobación de las tablas y datos de ej5 recién creada

Exportar con pg_dump

pg_dump genera un fichero SQL con toda la estructura y datos de la base de datos indicada. A diferencia de mysqldump, pg_dump por defecto no incluye la instrucción CREATE DATABASE, por lo que hay que crearla manualmente antes de importar.

1sudo -u postgres pg_dump ej5 > /tmp/ej5.sql

Lo pasamos a nuestro otro servidor:

1scp /tmp/ej5.sql oracle@192.168.122.48:/tmp/

Exportación con pg_dump y transferencia del fichero por scp

Ahora creamos la base de datos destino y la importamos.

Importamos el fichero

1sudo -u postgres psql ej5_importada < /tmp/ej5.sql

Salida de la importación del volcado SQL en PostgreSQL: tablas y secuencias creadas

Verificamos

Verificación en psql: datos de empleados y departamentos ya presentes en la base de datos importada

6. Exportar documentos de MongoDB filtrados por condición

MongoDB utiliza las herramientas mongoexport y mongoimport, que permiten exportar e importar documentos en formato JSON o CSV, con la posibilidad de filtrar por condición.

Crear la colección de prueba en servidorbd

Se crea la base de datos ej6 con una colección empleados que incluye un campo activo (booleano) que usaremos como condición de filtrado en la exportación.

Inserción de documentos de prueba en la colección empleados, con el campo activo

Exportar con condición usando mongoexport

mongoexport permite filtrar los documentos a exportar mediante el parámetro --query, que acepta un filtro en formato JSON, igual que los filtros de MongoDB.

1mongoexport --db ej6 --collection empleados --query '{"activo": true}' --out /tmp/ej6.json

Parámetros utilizados:

  • --db ej6: base de datos origen
  • --collection empleados: colección a exportar
  • --query '{"activo": true}': filtro — solo documentos donde activo sea true. Exporta 3 de los 5 documentos
  • --out /tmp/ej6.json: fichero de salida en formato JSON (un documento por línea)

Ahora transferimos el fichero JSON al servidor:

1scp /tmp/ej6.json oracle@192.168.122.48:/tmp/

Exportación filtrada con mongoexport y transferencia del JSON por scp

Importación

1mongoimport --db ej6_importada --collection empleados --file /tmp/ej6.json

Importación de los 3 documentos filtrados con mongoimport

Verificamos

1mongosh
2use ej6
3db.empleados.find().pretty()

Verificación en mongosh: solo los documentos con activo true importados correctamente

7. Carga masiva de MariaDB a Oracle con SQL*Loader

SQL*Loader es la herramienta de carga masiva de Oracle. Permite cargar grandes volúmenes de datos desde ficheros de texto plano (CSV, delimitado por tabuladores, de ancho fijo…) a tablas Oracle. Requiere dos ficheros principales: el fichero de datos y el fichero de control.

Exportar tablas de MariaDB a texto plano

Se exportan las tablas de la base de datos ej4 a ficheros CSV usando el modo batch de MySQL. Este modo genera la salida separada por tabuladores, sin cabeceras ni formato.

1mysql -u root -p ej4 -e "SELECT * FROM empleados" --batch --silent > /tmp/empleados.csv
2mysql -u root -p ej4 -e "SELECT * FROM departamentos" --batch --silent > /tmp/departamentos.csv

El parámetro --batch activa el modo no interactivo (salida separada por tabuladores) y --silent elimina las cabeceras de columna y mensajes de estado.

Exportación de las tablas empleados y departamentos a CSV con el modo batch de MySQL

Pasamos los CSV a la máquina Oracle con scp:

1scp /tmp/empleados.csv oracle@192.168.122.48:/tmp/
2scp /tmp/departamentos.csv oracle@192.168.122.48:/tmp/

Transferencia de los dos ficheros CSV a la máquina Oracle por scp

Crear las tablas destino en Oracle

 1CREATE TABLE empleados (
 2    id NUMBER PRIMARY KEY,
 3    nombre VARCHAR2(50),
 4    departamento VARCHAR2(50),
 5    salario NUMBER(10,2),
 6    fecha_alta DATE
 7);
 8
 9CREATE TABLE departamentos (
10    id NUMBER PRIMARY KEY,
11    nombre VARCHAR2(50),
12    ubicacion VARCHAR2(100)
13);

Creación de las tablas empleados y departamentos en Oracle vía SQL*Plus

Crear los ficheros de control (.ctl)

El fichero de control es el núcleo de SQL*Loader. Define todo lo necesario para interpretar el fichero de datos y cargarlo en Oracle.

1cat /tmp/empleados.ctl

 1LOAD DATA
 2INFILE '/tmp/empleados.csv'
 3INTO TABLE empleados
 4FIELDS TERMINATED BY X'09'
 5TRAILING NULLCOLS
 6(
 7    id           CHAR,
 8    nombre       CHAR,
 9    departamento CHAR,
10    salario      CHAR "TO_NUMBER(:salario, '9999.99')",
11    fecha_alta   DATE "YYYY-MM-DD"
12)

1cat /tmp/departamentos.ctl

 1LOAD DATA
 2INFILE '/tmp/departamentos.csv'
 3INTO TABLE departamentos
 4FIELDS TERMINATED BY '\t'
 5TRAILING NULLCOLS
 6(
 7    id,
 8    nombre,
 9    ubicacion
10)

Contenido de los dos ficheros de control empleados.ctl y departamentos.ctl

Explicación de las directivas del fichero de control:

  • LOAD DATA: indica el inicio de la definición de carga
  • INFILE: ruta al fichero de datos a cargar
  • INTO TABLE: tabla Oracle destino donde se insertarán los datos
  • FIELDS TERMINATED BY X'09': el delimitador es el tabulador — se usa la notación hexadecimal porque '\t' no funciona directamente en SQL*Loader
  • TRAILING NULLCOLS: si el último campo de un registro está vacío, inserta NULL en lugar de dar error
  • CHAR: SQL*Loader lee el campo como texto; luego la conversión al tipo NUMBER o DATE se hace con la función indicada
  • TO_NUMBER(:salario, '9999.99'): convierte el texto (p. ej. '2500.00') al tipo NUMBER de Oracle usando la máscara de formato indicada
  • DATE "YYYY-MM-DD": convierte el texto (p. ej. '2022-03-15') al tipo DATE de Oracle usando el formato de fecha indicado

Ejecutar SQL*Loader

Cargamos los datos de departamentos:

1sqlldr system/oracle@localhost:1521/orclpdb1 \
2  CONTROL=/tmp/departamentos.ctl \
3  LOG=/tmp/departamentos.log \
4  BAD=/tmp/departamentos.bad

Carga de la tabla departamentos con sqlldr: 3 filas cargadas correctamente

Y cargamos los datos de los empleados:

1sqlldr system/oracle@localhost:1521/orclpdb1 \
2  CONTROL=/tmp/empleados.ctl \
3  LOG=/tmp/empleados.log \
4  BAD=/tmp/empleados.bad

Carga de la tabla empleados con sqlldr: 5 filas cargadas correctamente

Interpretar el fichero de log

El fichero de log generado por SQL*Loader contiene información muy detallada del proceso de carga. Las secciones más importantes son:

  • Archivo de Control: ruta al fichero .ctl utilizado
  • Archivo de Datos: ruta al fichero de datos procesado
  • Archivo de Errores (.bad): ruta donde se guardaron los registros rechazados
  • Ruta de acceso utilizada: Convencional (inserción fila a fila) o Direct (carga directa sin pasar por el buffer, más rápida para grandes volúmenes)
  • Opción INSERT/APPEND/REPLACE: INSERT inserta solo si la tabla está vacía, APPEND agrega sin borrar, REPLACE borra todo y recarga
  • Tabla X: N Filas cargadas: resumen del resultado por tabla
  • Total de registros leídos: cuántos registros se leyeron del fichero de datos
  • Total de registros rechazados: cuántos no pudieron insertarse (van al .bad)
  • Total de registros desechados: cuántos no cumplieron la cláusula WHEN (van al .dsc)
  • Tiempo transcurrido / Tiempo de CPU: duración total y consumo de CPU de la operación de carga
1cat /tmp/empleados.log

Log completo de la carga de empleados: 5 filas cargadas, 0 rechazadas, 0 desechadas

1cat /tmp/departamentos.log

Log completo de la carga de departamentos: 3 filas cargadas, 0 rechazadas, 0 desechadas