SIN POSTUREOCatamos y probamos a fondo antes de recomendarte nada
Ilustración de papel recortado: un rollo gigante de papel cuadriculado pasa por una pequeña máquina de manivela que lo corta en paquetes pequeños

Importar un CSV enorme en PHP con poca memoria y poder reanudarlo

domin9 min de lectura

“Tienes un CSV de 10 GB y 512 MB de RAM. ¿Cómo lo procesas?”. Es una pregunta de entrevista que vi en un artículo de Medium, resuelta en Java. La idea está genial y yo me lo he montado en PHP 8.5 en lugar de Java, con un CSV random, y lo he matado a mitad para ver si se recupera.

  • Lee un registro cada vez con fgetcsv(). Con tres millones de filas, PHP no ha pasado de 2 MB.
  • No partas las líneas con explode(','): se rompe con comas o saltos de línea dentro de las comillas.
  • Para reanudar, guarda la posición del fichero (ftell()) en la misma transacción que las filas.
  • Desde PHP 8.4, pasa escape: '' a fgetcsv() o te saldrá un warning de deprecated.

El CSV de prueba

No tengo un CSV de 10 GB de clientes por ahí, así que lo genero. Tiene 3 millones de pedidos y pesa 661 MB, más de lo que cabe en los 512 MB que le doy al contenedor. Lleva las tres cosas que rompen los importadores caseros: comas dentro de un campo, comillas escapadas y saltos de línea dentro de un comentario.

id,cliente,comentario,importe
1,"García, Ana 1","Primera línea
segunda línea",1.37
4,"García, Ana 4","Entrega en portería, ""llamar antes""",5.48

Una pregunta antes de seguir: si cuentas las líneas con wc -l, ¿cuántas salen? Tres millones de registros más la cabecera darían 3.000.001.

Terminal
wc -l < datos.csv
3750001

Salen 750.000 de más, una por cada comentario con salto de línea. Es decir, en un CSV una línea no es un registro.

Todo está probado con la imagen oficial php:8.5-cli (PHP 8.5.12) y limitando el contenedor con docker run --memory=512m.

Por qué file() revienta

La forma más cómoda de leer un fichero es file(), que te devuelve un array con todas las líneas. El problema es que lo carga entero en memoria:

$lineas = file('datos.csv');
Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 692228096 bytes)

Ese límite de 128 MB no es el del contenedor: es el memory_limit de PHP, que la imagen oficial deja en su valor por defecto. Salta antes que los 512 MB de Docker, y aunque lo subieras a 512 MB, el fichero entero seguiría sin caber.

Con file_get_contents() pasa lo mismo. Da igual lo rápido que vaya luego: si el fichero no cabe, no cabe.

explode(’,’) rompe los registros

Lo siguiente que se le ocurre a todo el mundo es leer línea a línea con fgets() y partir por comas. Es lo que hace el artículo original con split(","). Con las primeras líneas de mi CSV sale esto:

4 campos: ["1","\"García"," Ana 1\"","\"Primera línea"]
2 campos: ["segunda línea\"","1.37"]
6 campos: ["4","\"García"," Ana 4\"","\"Entrega en portería"," \"\"llamar antes\"\"\"","5.48"]

La coma de «García, Ana» parte el nombre en dos, y el salto de línea parte el registro 1 en dos trozos. No da ningún error, simplemente mete basura en la base de datos.

fgetcsv() lee un registro entero, aunque ocupe dos líneas

fgetcsv() entiende las comillas: si un campo abre comillas y no las cierra en esa línea, sigue leyendo hasta cerrarlas. Devuelve un registro cada vez, y lo que ya has procesado no se queda en memoria.

$f = fopen('datos.csv', 'r');
while (($fila = fgetcsv($f, escape: '')) !== false) {
// $fila es un array con los 4 campos, comentario con salto incluido
}

Lo de escape: '' no es de adorno. Si no lo pasas, PHP 8.5 te suelta esto:

Deprecated: fgetcsv(): the $escape parameter must be provided as its default value will change

Por defecto PHP usa la barra invertida como carácter de escape, que no forma parte del estándar CSV. En el estándar, una comilla dentro de un campo se escribe doble (""). Con escape: '' lo desactivas y PHP lee el CSV como lo escriben Excel o LibreOffice.

Importar por lotes y seguir tras una caída

Leer a trozos es la mitad. La otra mitad es que si el proceso muere a los veinte minutos, no quieres empezar de cero ni meter filas repetidas. Yo lo vuelco a SQLite, pero con MariaDB o PostgreSQL es lo mismo.

La idea es apuntar en la base de datos por qué byte del fichero voy. Al arrancar, si hay posición guardada, salto ahí con fseek():

$f = fopen($csv, 'r');
$consulta = $db->prepare('SELECT posicion FROM progreso WHERE archivo = ?');
$consulta->execute([$csv]);
$posicion = $consulta->fetchColumn();
if ($posicion === false) {
fgetcsv($f, escape: ''); // primera vez: me salto la cabecera
} else {
fseek($f, (int) $posicion); // ya había empezado: sigo donde lo dejé
}

Luego, cada 5.000 filas, guardo la posición dentro de la misma transacción que esas filas:

$db->beginTransaction();
while (($fila = fgetcsv($f, escape: '')) !== false) {
$insertar->execute($fila);
if (++$hechas % $lote === 0) {
$apuntar->execute([$csv, ftell($f)]);
$db->commit();
$db->beginTransaction();
}
}
$apuntar->execute([$csv, ftell($f)]); // el último lote, aunque sea pequeño
$db->commit();

ftell() devuelve la posición justo después del último registro que ha leído fgetcsv(), aunque ese registro ocupara dos líneas. Por eso sirve como marca para volver.

El script completo, con la creación de tablas, lo tienes al final.

Lo he matado a mitad y ha seguido

Lancé la importación y a los 8 segundos maté el contenedor con docker kill, que no le deja ni despedirse. En la base de datos había esto:

tras el kill: 1105000 filas, posicion 253050546

Al relanzar el mismo comando:

Sigo desde el byte 253050546
1895000 filas, pico de memoria: 2.0 MB

1.105.000 más 1.895.000 son los 3 millones. Lo comprobé contando en la tabla: 3.000.000 de filas, 3.000.000 de ids distintos, del 1 al 3.000.000. Ni repetidos ni huecos.

La importación entera, sin matarla, tardó 22 segundos en mi máquina, arranque del contenedor incluido. La memoria no pasa de 2 MB porque nunca hay más de un registro en mano. Con 10 GB de registros parecidos tardaría más, pero la memoria se quedaría igual. Lo que sí la dispara es un único registro gigante, porque fgetcsv() lo devuelve entero.

Los dos fallos del original

El planteamiento del artículo es el bueno: leer a trozos, lotes y un punto de control. Pero tiene dos fallos que en producción te dan un susto.

  • Se pierde el último lote. Solo guarda cuando el lote llega a 5.000. Si el fichero tiene 3.001.234 filas, las últimas 1.234 no se escriben nunca. Es decir, después del bucle siempre hay que guardar lo que quede.
  • La posición va por un lado y los datos por otro. Si guardas la posición en un fichero o en otra transacción y el proceso muere entre una cosa y la otra, al reanudar repites un lote o te saltas uno. Si van en la misma transacción, o entran las dos o ninguna.

Hay un tercer detalle que en PHP no aplica. En Java, el BufferedReader lee por delante, así que su posición no coincide con la última línea procesada. ftell() sobre un fichero abierto con fopen() sí te da la posición real después del registro.

Cuántas filas meter en cada commit

Pruébalo tú: cambia $lote = 5000 por $lote = 1, es decir, un commit por fila. ¿Cuánto más lento crees que va?

Lo probé con un trozo de 8.984 registros. Con lotes de 5.000 tardó 0,22 segundos. Con lotes de 1, 9,09 segundos: unas 40 veces más lento, y la memoria igual en los dos casos.

Con la configuración por defecto, cada commit obliga a SQLite a sincronizar con el disco. Lotes más grandes son más rápidos, pero si el proceso cae pierdes más trabajo. Entre 1.000 y 10.000 filas suele ser un término medio razonable; mídelo con tus datos.

Cuándo no hace falta PHP

Si solo quieres sacar una columna o sumar importes, no hace falta montar todo esto. En el post de awk cuento que awk -F, tiene el mismo problema que explode() con las comas entre comillas, y que gawk tiene la opción --csv para leerlo bien.

PHP compensa cuando hay que validar, transformar e insertar en una base de datos, y sobre todo cuando un corte a mitad no puede dejarte los datos a medias.

El script completo

<?php
declare(strict_types=1);
[, $csv, $rutaDb] = $argv;
$lote = 5000;
$db = new PDO("sqlite:$rutaDb", options: [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
$db->exec('CREATE TABLE IF NOT EXISTS pedidos (id INTEGER PRIMARY KEY, cliente TEXT, comentario TEXT, importe REAL)');
$db->exec('CREATE TABLE IF NOT EXISTS progreso (archivo TEXT PRIMARY KEY, posicion INTEGER)');
$f = fopen($csv, 'r');
$consulta = $db->prepare('SELECT posicion FROM progreso WHERE archivo = ?');
$consulta->execute([$csv]);
$posicion = $consulta->fetchColumn();
if ($posicion === false) {
fgetcsv($f, escape: ''); // primera vez: me salto la cabecera
} else {
fseek($f, (int) $posicion); // ya había empezado: sigo donde lo dejé
echo "Sigo desde el byte $posicion\n";
}
$insertar = $db->prepare('INSERT INTO pedidos VALUES (?, ?, ?, ?)');
$apuntar = $db->prepare('INSERT OR REPLACE INTO progreso VALUES (?, ?)');
$hechas = 0;
$db->beginTransaction();
while (($fila = fgetcsv($f, escape: '')) !== false) {
$insertar->execute($fila);
if (++$hechas % $lote === 0) {
$apuntar->execute([$csv, ftell($f)]); // la posición va en la misma transacción
$db->commit();
$db->beginTransaction();
}
}
$apuntar->execute([$csv, ftell($f)]); // el último lote, aunque sea pequeño
$db->commit();
printf("%d filas, pico de memoria: %.1f MB\n", $hechas, memory_get_peak_usage(true) / 1048576);

Para lanzarlo con el mismo límite de memoria que yo:

Terminal
docker run --rm --memory=512m -v "$PWD":/w -w /w php:8.5-cli \
php importar.php datos.csv pedidos.db

Si el fichero cambia entre una ejecución y otra, la posición guardada ya no vale. Para eso no hay truco: empieza con una base de datos nueva. Si solo borras la fila de progreso, los pedidos de antes siguen ahí y saltará la clave duplicada.

Gracias y saluditos! 🍻

Fuentes

En calidad de Afiliado de Amazon, obtengo ingresos por las compras adscritas que cumplen los requisitos aplicables. Más detalles en el aviso de afiliados.

Compartir