Salta al contenuto principale
Sistemi Attivi
WP Planet — WordPress Cloud & Managed Services
Torna al MagazineWooCommerce

Importazione e export prodotti WooCommerce: operazioni batch senza far tremare il server

20 Nov 2026 — 09:30 8 min di lettura
Importazione e export prodotti WooCommerce: operazioni batch senza far tremare il server

Importare 5.000 prodotti da CSV o fare un export completo del catalogo non è un'operazione che potete lanciare e aspettare. Senza chunking e gestione della memoria, il PHP esaurisce il limite e l'operazione muore a metà.

L'importazione di un catalogo completo è uno di quei lavori che sembrano semplici finché non ci provate. Un CSV con 5.000 prodotti, ognuno con nome, descrizione, prezzo, categoria, attributi e magari immagini — sono decine di migliaia di operazioni di database. Il problema non è la velocità del database, è la memoria PHP. WooCommerce carica ogni prodotto con `wc_get_product`, che istanzia l'oggetto completo con tutte le sue relazioni. A 5.000 prodotti, PHP accumula oggetti in memoria finché non raggiunge il limite (di default 128 o 256MB) e l'operazione muore con un fatal error.

Il sintomo è inequivocabile: l'import si ferma a metà, il server restituisce 500, e avete 2.300 prodotti importati e 2.700 no. Se riprendete, duplica i primi 2.300. Il risultato è un disastro di dati che richiede ore di pulizia manuale.

Chunking: la regola fondamentale

La soluzione è il chunking — dividere l'import in blocchi piccoli che PHP può elaborare senza esaurire la memoria. WP-CLI rende questo semplice con il parametro `--batch-size` e i metodi built-in. Per un import serio, non usate l'interfaccia web: usate WP-CLI:

PHP
// wp-content/mu-plugins/wpplanet-import.php
// Uso: wp wpplanet-import /percorso/catalogo.csv --batch=50
// Usa l'importer CSV ufficiale di WooCommerce, ma a blocchi:
// ogni blocco legge 50 righe, salva e libera la memoria.
if ( defined( 'WP_CLI' ) && WP_CLI ) {
    WP_CLI::add_command( 'wpplanet-import', function( $args, $assoc_args ) {
        $file  = $args[0];
        $batch = (int) ( $assoc_args['batch'] ?? 50 );

        include_once WC_ABSPATH . 'includes/import/class-wc-product-csv-importer.php';

        // Sospende il ricalcolo dei conteggi delle categorie fino alla fine
        wp_defer_term_counting( true );
        wp_suspend_cache_addition( true );

        $pos = 0;
        $totale = [ 'imported' => 0, 'updated' => 0, 'failed' => 0 ];
        do {
            $importer = new WC_Product_CSV_Importer( $file, [
                'start_pos'       => $pos,
                'lines'           => $batch,
                'update_existing' => true,
                'parse'           => true,
            ] );
            $risultato = $importer->import();
            foreach ( $totale as $k => $v ) {
                $totale[ $k ] += count( $risultato[ $k ] ?? [] );
            }
            $pos = $importer->get_file_position();
            WP_CLI::log( sprintf( '%d%% completato', $importer->get_percent_complete() ) );
            wp_cache_flush(); // libera la cache oggetti tra un blocco e l'altro
        } while ( $importer->get_percent_complete() < 100 );

        wp_defer_term_counting( false ); // ricalcola i conteggi una sola volta
        wp_suspend_cache_addition( false );
        WP_CLI::success( sprintf( 'Nuovi: %d · aggiornati: %d · errori: %d',
            $totale['imported'], $totale['updated'], $totale['failed'] ) );
    } );
}
Nota: wp_defer_term_counting(true) è il punto chiave: senza, WordPress ricalcola i conteggi delle categorie a ogni prodotto salvato, cioè 5.000 ricalcoli su 5.000 prodotti. Sospesi durante l'import e ricalcolati una volta alla fine (con false), il tempo si riduce sensibilmente. Eseguite sempre da terminale (SSH), non dal browser: da riga di comando non c'è il timeout di PHP-FPM. Provate prima su una copia del sito: con update_existing gli SKU già presenti vengono sovrascritti.

Export: il problema speculare

L'export ha lo stesso problema di memoria. Un export di 10.000 prodotti con `wc_get_product` per ognuno esaurisce la memoria. Il pattern corretto usa `get_posts` con paginazione invece di caricare tutti i prodotti in un colpo:

PHP
// Export a blocchi con WP-CLI: wp wpplanet-export
function wpplanet_export_prodotti( $args, $assoc_args ) {
    $page     = 1;
    $per_page = 100;
    $count    = 0;
    $output   = fopen( '/tmp/export.csv', 'w' );
    fputcsv( $output, [ 'SKU', 'Nome', 'Prezzo', 'Categoria', 'Stock' ] );

    while ( true ) {
        $products = wc_get_products( [
            'status'  => 'publish',
            'limit'   => $per_page,
            'page'    => $page,
            'orderby' => 'ID',
            'order'   => 'ASC',
        ] );
        if ( empty( $products ) ) {
            break;
        }

        foreach ( $products as $product ) {
            $categorie = wp_get_post_terms( $product->get_id(), 'product_cat', [ 'fields' => 'names' ] );
            fputcsv( $output, [
                $product->get_sku(),
                $product->get_name(),
                $product->get_price(),
                implode( ', ', is_wp_error( $categorie ) ? [] : $categorie ),
                $product->get_stock_quantity() ?? '',
            ] );
            $count++;
        }

        WP_CLI::log( "Esportati {$count} prodotti" );
        $page++;
        wp_cache_flush(); // evita che la cache oggetti cresca a ogni pagina
    }

    fclose( $output );
    WP_CLI::success( "Export completato: {$count} prodotti in /tmp/export.csv" );
}
if ( defined( 'WP_CLI' ) && WP_CLI ) {
    WP_CLI::add_command( 'wpplanet-export', 'wpplanet_export_prodotti' );
}
Nota: wc_get_products con limit e page legge i prodotti 100 alla volta (LIMIT in SQL): il catalogo non viene mai caricato tutto in memoria. Il wp_cache_flush() a fine pagina è quello che tiene stabile la memoria: senza, la cache oggetti di WordPress conserva ogni prodotto letto e su 10.000 prodotti il processo cresce fino a esaurire il memory_limit. Per le categorie usiamo wp_get_post_terms: il vecchio get_categories() del prodotto è deprecato e restituisce HTML, non un elenco.

Un'ultima nota pratica: gli import e export massivi sono il momento peggiore per il server. Se il vostro hosting ha limiti di memoria bassi (128MB su shared hosting), nemmeno il chunking basta. In quei casi, dividiamo il CSV in file da 500-1.000 righe e li importiamo sequenzialmente. Su un cloud con 512MB di memoria e WP-CLI, invece, 5.000 prodotti in un singolo chunked run sono routine.

Assistenza WooCommerce

Import o export di un catalogo importante? Non fatelo senza un piano.

Assistenza WooCommerce per operazioni batch: import/export di prodotti con chunking, WP-CLI e gestione della memoria per evitare timeout e duplicazioni.

Assistenza WooCommerce
Condividi