Cómo guardar una página web completa en MySQL con PHP (urlencode, BLOB y otras técnicas)

En muchos proyectos web puede ser útil guardar el HTML completo de una página dentro de una base de datos MySQL:

• Crear un sistema de caché personalizado.
• Guardar “fotografías” (snapshots) de páginas externas.
• Versionar contenido generado dinámicamente.
• Almacenar plantillas completas que luego se renderizan bajo demanda.

En este artículo veremos varias formas de guardar una página web completa en MySQL usando PHP, incluyendo:

• Texto plano (TEXT / MEDIUMTEXT / LONGTEXT).
• Codificación con urlencode() / urldecode().
• Uso de campos BLOB con o sin compresión.

Además, comentaremos ventajas, inconvenientes y recomendaciones prácticas para usarlo en un entorno como WordPress (por ejemplo, integrándolo en un plugin propio).

---

1. Diseño básico de la tabla en MySQL

Primero necesitamos una tabla donde guardar la información de la página. Un ejemplo genérico podría ser:

CREATE TABLE paginas_guardadas (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    url VARCHAR(2000) NOT NULL,
    html MEDIUMTEXT NOT NULL,
    metodo_almacenamiento ENUM('texto','urlencode','blob') NOT NULL DEFAULT 'texto',
    fecha_creacion DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Explicación rápida:

• url: la URL original de la página que guardamos.
• html: el contenido HTML de la página.
• metodo_almacenamiento: indica cómo lo hemos guardado.
• MEDIUMTEXT soporta hasta 16 MB de texto. Si esperas páginas muy grandes, puedes usar LONGTEXT.

Más adelante veremos variaciones si quieres usar BLOB o guardar el contenido codificado.

---

2. Obtener el HTML de una página con PHP

Para guardar una página en MySQL primero necesitamos obtener su HTML. La forma más simple (para ejemplos) es usar file_get_contents:

$url = 'https://www.ejemplo.com/';
$html = file_get_contents($url);

if ($html === false) {
    die('Error al descargar la página');
}

En entornos más serios es mejor usar cURL (control de cabeceras, timeouts, user-agent, etc.), pero para el concepto general esto es suficiente.

---

3. Conexión a MySQL con PDO en PHP

Para los ejemplos usaremos PDO, que es una forma moderna y segura de conectarse a MySQL.

$dsn = 'mysql:host=localhost;dbname=mi_base;charset=utf8mb4';
$usuario = 'mi_usuario';
$contrasena = 'mi_password';

try {
    $pdo = new PDO($dsn, $usuario, $contrasena, [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    ]);
} catch (PDOException $e) {
    die('Error de conexión: ' . $e->getMessage());
}

Asegúrate de que tanto la base de datos como la conexión usen utf8mb4 para evitar problemas con caracteres especiales.

---

4. Método 1: guardar la página como texto plano (TEXT / MEDIUMTEXT)

Este es el método más sencillo y, en la mayoría de casos, el más recomendable.

4.1. Insertar la página en la base de datos

$url = 'https://www.ejemplo.com/';
$html = file_get_contents($url);

if ($html === false) {
    die('Error al descargar la página');
}

$sql = 'INSERT INTO paginas_guardadas (url, html, metodo_almacenamiento)
        VALUES (:url, :html, :metodo)';

$stmt = $pdo->prepare($sql);
$stmt->execute([
    ':url'    => $url,
    ':html'   => $html,
    ':metodo' => 'texto',
]);

echo 'Página guardada correctamente.';

Puntos clave:

• No necesitamos urlencode() aquí. MySQL soporta texto con caracteres especiales si la conexión está correctamente configurada.
• Usamos MEDIUMTEXT para tener margen de tamaño.

4.2. Recuperar y mostrar la página

$id = 1; // por ejemplo

$sql = 'SELECT html FROM paginas_guardadas WHERE id = :id LIMIT 1';
$stmt = $pdo->prepare($sql);
$stmt->execute([':id' => $id]);
$pagina = $stmt->fetch();

if (!$pagina) {
    die('Página no encontrada');
}

$html = $pagina['html'];

echo $html; // Imprime el HTML tal cual

Con esto ya tendríamos la página original renderizada por el navegador.

---

5. Método 2: guardar la página con urlencode() / urldecode()

urlencode() convierte una cadena en un formato seguro para URL, sustituyendo caracteres especiales por secuencias como %20, %3C, etc. Aunque se usa principalmente en query strings, también podemos usarlo para guardar el HTML de forma codificada en la base de datos.

5.1. Cuándo puede tener sentido usar urlencode

• Si por algún motivo tienes una base de datos antigua o mal configurada donde el juego de caracteres da problemas.
• Si quieres asegurarte de que todos los caracteres se almacenan como ASCII (aunque pierdes legibilidad).

En la práctica, suele ser mejor arreglar la configuración de codificación que usar urlencode() para todo, pero es una técnica que puedes necesitar en algunos casos.

5.2. Guardar usando urlencode

Ampliamos la tabla para tener una columna específica, o reutilizamos html. Aquí lo haremos en la misma columna, indicando el método.

$url = 'https://www.ejemplo.com/';
$html = file_get_contents($url);

if ($html === false) {
    die('Error al descargar la página');
}

$html_codificado = urlencode($html);

$sql = 'INSERT INTO paginas_guardadas (url, html, metodo_almacenamiento)
        VALUES (:url, :html, :metodo)';

$stmt = $pdo->prepare($sql);
$stmt->execute([
    ':url'    => $url,
    ':html'   => $html_codificado,
    ':metodo' => 'urlencode',
]);

echo 'Página guardada con urlencode.';

5.3. Recuperar usando urldecode

$id = 1; // ejemplo

$sql = 'SELECT html, metodo_almacenamiento
        FROM paginas_guardadas
        WHERE id = :id LIMIT 1';

$stmt = $pdo->prepare($sql);
$stmt->execute([':id' => $id]);
$pagina = $stmt->fetch();

if (!$pagina) {
    die('Página no encontrada');
}

$html = $pagina['html'];

if ($pagina['metodo_almacenamiento'] === 'urlencode') {
    $html = urldecode($html);
}

// Ahora $html contiene la página original
echo $html;

---

6. Método 3: guardar la página como BLOB (opcionalmente comprimida)

Otra alternativa es usar un campo BLOB (Binary Large Object). Esto es útil si quieres:

• Comprimir el contenido antes de guardarlo.
• Guardar no solo HTML, sino también otros formatos binarios (por ejemplo, la página comprimida en GZIP, o incluso PDFs generados).

6.1. Tabla usando BLOB

Podrías usar una tabla adicional o reemplazar html:

CREATE TABLE paginas_guardadas_blob (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    url VARCHAR(2000) NOT NULL,
    datos LONGBLOB NOT NULL,
    comprimido TINYINT(1) NOT NULL DEFAULT 0,
    fecha_creacion DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB;

6.2. Guardar HTML como BLOB sin compresión

$url = 'https://www.ejemplo.com/';
$html = file_get_contents($url);

if ($html === false) {
    die('Error al descargar la página');
}

$sql = 'INSERT INTO paginas_guardadas_blob (url, datos, comprimido)
        VALUES (:url, :datos, 0)';

$stmt = $pdo->prepare($sql);
$stmt->bindParam(':url', $url, PDO::PARAM_STR);
$stmt->bindParam(':datos', $html, PDO::PARAM_LOB);
$stmt->execute();

echo 'Página guardada en BLOB (sin compresión).';

6.3. Guardar HTML como BLOB comprimido

Para ahorrar espacio, puedes comprimir la página con gzcompress() antes de guardarla.

$url = 'https://www.ejemplo.com/';
$html = file_get_contents($url);

if ($html === false) {
    die('Error al descargar la página');
}

$html_comprimido = gzcompress($html, 9); // nivel de compresión 9 (máximo)

$sql = 'INSERT INTO paginas_guardadas_blob (url, datos, comprimido)
        VALUES (:url, :datos, 1)';

$stmt = $pdo->prepare($sql);
$stmt->bindParam(':url', $url, PDO::PARAM_STR);
$stmt->bindParam(':datos', $html_comprimido, PDO::PARAM_LOB);
$stmt->execute();

echo 'Página guardada en BLOB comprimido.';

6.4. Recuperar desde BLOB

$id = 1;

$sql = 'SELECT datos, comprimido
        FROM paginas_guardadas_blob
        WHERE id = :id LIMIT 1';

$stmt = $pdo->prepare($sql);
$stmt->execute([':id' => $id]);
$pagina = $stmt->fetch();

if (!$pagina) {
    die('Página no encontrada');
}

$datos = $pagina['datos'];

if ($pagina['comprimido']) {
    $html = gzuncompress($datos);
} else {
    $html = $datos;
}

echo $html;

---

7. Comparativa de métodos

7.1. Guardar como texto (TEXT/MEDIUMTEXT/LONGTEXT)

Ventajas:

• Sencillo de implementar.
• Fácil de depurar y leer directamente desde MySQL.
• Ideal para WordPress y la mayoría de aplicaciones.

Inconvenientes:

• Puede ocupar más espacio si las páginas son enormes.
• No hay compresión por defecto (aunque MySQL puede comprimir a nivel de tablas/innodb).

7.2. Guardar con urlencode()

Ventajas:

• Garantiza que todo se almacena como ASCII.
• Evita problemas en bases de datos con codificaciones mal configuradas.

Inconvenientes:

• El contenido será ilegible en la base de datos.
• Aumenta algo el tamaño (los caracteres especiales se expanden).
• Obliga a usar urldecode() siempre que quieras recuperar el HTML.

En general es una solución de nicho, solo recomendable si no puedes cambiar la configuración de la base de datos.

7.3. Guardar como BLOB (con o sin compresión)

Ventajas:

• Permite comprimir el contenido y ahorrar espacio.
• Puedes almacenar cualquier tipo de dato binario (no solo HTML).

Inconvenientes:

• Es más difícil de inspeccionar directamente desde la base de datos.
• Necesitas siempre un paso de descompresión/conversión al leer.

Es una buena opción cuando se almacenan muchas páginas grandes o cuando el espacio en disco es crítico.

---

8. Integración básica con WordPress (idea general)

Si quieres usar esto dentro de WordPress, por ejemplo en un plugin, puedes apoyarte en la variable global $wpdb.

Ejemplo muy simplificado de uso con $wpdb guardando como texto plano:

function mi_plugin_guardar_pagina($url) {
    global $wpdb;

    $html = file_get_contents($url);
    if ($html === false) {
        return new WP_Error('error_descarga', 'No se pudo descargar la página.');
    }

    $tabla = $wpdb->prefix . 'paginas_guardadas';

    $datos = [
        'url'                  => $url,
        'html'                 => $html,
        'metodo_almacenamiento'=> 'texto',
        'fecha_creacion'       => current_time('mysql'),
    ];

    $formato = ['%s', '%s', '%s', '%s'];

    $insertado = $wpdb->insert($tabla, $datos, $formato);

    if ($insertado === false) {
        return new WP_Error('error_bd', 'Error al guardar en la base de datos.');
    }

    return $wpdb->insert_id;
}

A partir de aquí puedes:

• Crear una página en el backend de WordPress para listar las páginas guardadas.
• Añadir botones para ver el HTML, regenerar la copia, borrar, etc.
• Usar shortcodes o bloques para mostrar el contenido guardado en el frontend.

---

9. Recomendaciones finales

1. Si no tienes un motivo fuerte para complicarlo, usa texto plano (TEXT / MEDIUMTEXT / LONGTEXT) con codificación utf8mb4. Es la opción más directa y compatible.
2. Revisa el tamaño máximo de tus campos: si vas a guardar páginas muy grandes, plantéate LONGTEXT o incluso BLOB.
3. urlencode() / urldecode() pueden ser útiles en casos especiales, pero no deberían ser tu primera opción si tu entorno está bien configurado.
4. Los BLOB, combinados con compresión (gzcompress / gzuncompress), son potentes si necesitas almacenar gran cantidad de datos y quieres optimizar espacio a costa de complejidad.
5. Ten presente la seguridad: nunca muestres directamente contenido externo sin sanear si hay riesgo de XSS. Si solo lo usas como caché o copia, intenta mantenerlo en contextos controlados.

Con estas técnicas, puedes diseñar en PHP y MySQL un sistema flexible para guardar páginas web completas y reutilizarlas en tu proyecto o en un plugin de WordPress.