Requêtes SQL lentes ? Boostez les performances de votre application avec cette technique

Le défi

Dans mon application (React + Spring Boot + Oracle), le traitement de grands ensembles de données entraînait un temps de traitement extrêmement lent. J'avais besoin d'une solution pour accélérer les performances sans compromettre la précision ou l'exhaustivité.

La solution : NTILE + traitement parallèle

NTILE est une puissante fonction de fenêtre SQL conçue pour partitionner un ensemble de résultats en un nombre spécifié de morceaux de taille à peu près égale, appelés « tuiles ». Chaque ligne se voit attribuer un numéro de partition en fonction de sa position dans l'ensemble ordonné.

En utilisant NTILE, j'ai divisé les résultats de la requête en morceaux gérables et j'ai traité ces partitions en parallèle. Cette approche m'a permis de récupérer et de gérer des données simultanément, réduisant ainsi considérablement les temps d'attente.

Voici un exemple pratique de la façon de mettre en œuvre cela :

WITH PartitionedSales AS (
    SELECT 
        sales_id,
        sales_amount,
        sales_date,
        NTILE(2) OVER (ORDER BY sales_id) AS partition_number -- Assigns a partition number (1 or 2) to each row
    FROM 
        sales
    WHERE 
        sales_date BETWEEN '2023-01-01' AND '2023-12-31'
)
SELECT * 
FROM PartitionedSales
WHERE partition_number = :partitionNumber -- Replace :partitionNumber with the actual partition number (1 or 2)

Dans l'extrait SQL ci-dessus :

• NTILE(2) divise les données en deux morceaux égaux qui seront triés en fonction de sales_id.
• Remplacez :partitionNumber par 1 ou 2 pour récupérer les données de la partition correspondante.

Sur le frontend, vous pouvez utiliser le traitement parallèle pour récupérer chaque partition efficacement :

async function fetchPartition(partitionNumber) {
    const response = await fetch('/api/sales?partition=' + partitionNumber});
    return response.json();
}

async function fetchData() {
    try {
        const [partition1, partition2] = await Promise.all([
            fetchPartition(1), // Fetch the first partition
            fetchPartition(2)  // Fetch the second partition
        ]);

        // Combine and process results
        const combinedResults = [...partition1, ...partition2];
        processResults(combinedResults);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

Dans ce code :

• fetchPartition récupère les données d'une partition spécifique.
• fetchData exécute les deux opérations de récupération en parallèle et traite les résultats combinés.

Comment vous pouvez le faire aussi

• Identifiez les requêtes lourdes : recherchez les requêtes qui ralentissent votre application.
• Appliquer NTILE : utilisez la fonction NTILE pour diviser les résultats de la requête en parties plus petites.
• Traitement parallèle : exécutez ces petites requêtes en parallèle, en tirant parti de la capacité de votre application à gérer des tâches simultanées.

Si vous souhaitez améliorer les performances de vos applications gourmandes en données, essayez cette méthode. C'est un moyen intelligent et efficace de rendre vos requêtes plus efficaces, pas plus longtemps.

Considération importante

Lors du traitement de requêtes simultanées, la demande en connexions à la base de données peut devenir importante. Cette utilisation intensive des connexions peut mettre à rude épreuve votre base de données, entraînant potentiellement des goulots d'étranglement en termes de performances. Il est essentiel de surveiller et de gérer le nombre de requêtes simultanées pour garantir que votre base de données reste réactive et fonctionne efficacement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!