O desafio

Em meu aplicativo (React Spring Boot Oracle), lidar com grandes conjuntos de dados levou a um tempo de processamento frustrantemente lento. Eu precisava de uma solução para acelerar o desempenho sem comprometer a precisão ou a integridade.

A solução: processamento paralelo NTILE

NTILE é uma poderosa função de janela SQL projetada para particionar um conjunto de resultados em um número especificado de pedaços de tamanhos aproximadamente iguais, conhecidos como "blocos". Cada linha recebe um número de partição com base em sua posição no conjunto ordenado.

Ao usar NTILE, divido os resultados da consulta em partes gerenciáveis ​​e processei essas partições em paralelo. Essa abordagem me permitiu buscar e manipular dados simultaneamente, reduzindo significativamente os tempos de espera.

Aqui está um exemplo prático de como implementar isso:

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)

No trecho SQL acima:

• NTILE(2) divide os dados em dois pedaços iguais que serão classificados com base no sales_id.
• Substitua :partitionNumber por 1 ou 2 para buscar dados da partição correspondente.

No frontend, você pode usar o processamento paralelo para buscar cada partição de forma eficiente:

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);
    }
}

Neste código:

• fetchPartition recupera dados de uma partição específica.
• fetchData executa ambas as operações de busca em paralelo e processa os resultados combinados.

Como você também pode fazer isso

• Identifique as consultas pesadas: encontre as consultas que estão deixando seu aplicativo lento.
• Aplicar NTILE: Use a função NTILE para dividir os resultados da consulta em partes menores.
• Processamento paralelo: execute essas consultas menores em paralelo, aproveitando a capacidade do seu aplicativo de lidar com tarefas simultâneas.

Se você deseja aumentar o desempenho em seus aplicativos com muitos dados, experimente este método. É uma maneira inteligente e eficaz de fazer com que suas consultas funcionem mais, e não mais.

Consideração importante

Ao lidar com solicitações simultâneas, a demanda por conexões de banco de dados pode se tornar significativa. Essa utilização intensa de conexões pode sobrecarregar seu banco de dados, levando potencialmente a gargalos de desempenho. É essencial monitorar e gerenciar o número de solicitações simultâneas para garantir que seu banco de dados permaneça responsivo e tenha um desempenho eficiente.