Início / dba / Perguntas / 334386
Accepted
gotqn
Asked: 2023-12-28 18:12:28 +0800 CST

"+" é mais lento que "CONCAT" para strings grandes?

  • 772

Sempre pensei que a função CONCAT fosse na verdade um wrapper sobre o + (Concatenação de Strings) com algumas verificações adicionais para facilitar nossa vida.

Não encontrei nenhum detalhe interno sobre como as funções são implementadas. Quanto ao desempenho, parece que há sobrecarga para chamar CONCATquando os dados estão concatenando em um loop (o que parece normal, pois há identificadores adicionais para NULLs).

Há poucos dias, um desenvolvedor modificou algum código de concatenação de strings (de +para CONCAT)porque não gostou da sintaxe e me disse que ficou mais rápido.

Para verificar o caso, usei o seguinte código:

DECLARE @V1 NVARCHAR(MAX)
       ,@V2 NVARCHAR(MAX)
       ,@V3 NVARCHAR(MAX);

DECLARE @R NVARCHAR(MAX);

SELECT  @V1 = REPLICATE(CAST('V1' AS NVARCHAR(MAX)), 50000000)
       ,@V2 = REPLICATE(CAST('V2' AS NVARCHAR(MAX)), 50000000)
       ,@V3 = REPLICATE(CAST('V3' AS NVARCHAR(MAX)), 50000000);

onde esta é a variante um:

SELECT @R = CAST('' AS NVARCHAR(MAX)) + '{some small text}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') + ISNULL(@V3, '{}'); 
SELECT LEN(@R); -- 1200000017

e esta é a variante dois:

SELECT @R = CONCAT('{some small text}',ISNULL(@V1, '{}'), ISNULL(@V2, '{}'), ISNULL(@V3, '{}'))
SELECT LEN(@R); -- 1200000017

Para strings menores, não há diferenças. Em algum momento, a CONCATvariante se torna mais rápida:

insira a descrição da imagem aqui

Eu me pergunto se alguém pode compartilhar alguns detalhes internos ou explicar o comportamento, pois parece que pode haver uma regra de que é melhor concatenar strings grandes usando CONCAT.

Versão:

Microsoft SQL Server 2022 (RTM-CU8) (KB5029666) - 16.0.4075.1 (X64) 23 de agosto de 2023 14:04:50 Copyright (C) 2022 Microsoft Corporation Standard Edition (64 bits) no Windows Server 2019 Standard 10.0 (Build 17763 : ) (Hipervisor)

O script exato é semelhante ao seguinte:

DECLARE @V1 NVARCHAR(MAX)
       ,@V2 NVARCHAR(MAX)
       ,@V3 NVARCHAR(MAX);

DECLARE @R NVARCHAR(MAX);

SELECT  @V1 = REPLICATE(CAST('V1' AS NVARCHAR(MAX)), 50000000)
       ,@V2 = REPLICATE(CAST('V2' AS NVARCHAR(MAX)), 50000000)
       ,@V3 = REPLICATE(CAST('V3' AS NVARCHAR(MAX)), 50000000);



--SELECT @R = CAST('' AS NVARCHAR(MAX)) + '{some small text}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') + ISNULL(@V3, '{}'); -- 00:00:45 -- 00:01:22 -- 00:01:20
--SELECT LEN(@R); -- 300000017

SELECT @R = CONCAT('{some small text}',ISNULL(@V1, '{}'), ISNULL(@V2, '{}'), ISNULL(@V3, '{}')) -- 00:00:11 -- 00:00:16 -- 00:00:10
SELECT LEN(@R); -- 300000017

onde estou alterando o último argumento das funções REPLICATE para gerar strings maiores para a concatenação. Então, estou executando cada variante três vezes.

sql-server

1 respostas

  1. Best Answer

    "+" é mais lento que "CONCAT" para strings grandes?

    Parece que sim. Observando as páginas alocadas e desalocadas tempdbpara armazenamento desses dados LOB, parece que cada instância acaba +criando uma nova string e alocando e desalocando páginas para ela tempdb(das quais apenas a final é necessária).

    Considerando que CONCATapenas usa as páginas necessárias para o tamanho do resultado final e não se degrada à medida que mais +são adicionadas, alocando páginas para (e escrevendo) strings intermediárias desnecessárias.

    Método páginas_recentemente alocadas new_deallocated_pages páginas_novas_em_uso
    + 249280 249280 0
    Concat 99696 99696 0

    O comprimento dos dados do resultado final é 800000034 bytes (para meu código abaixo, que inclui uma @V4concatenação extra). O CONCATmétodo alocou 99.696 páginas. Uma média de 8.024,4 bytes por página. O SQL Server usa páginas de 8 KB, mas é necessário algum espaço para sobrecarga do cabeçalho da página.

    Pois +você pode ver como ele chega a esse número tentando as expressões intermediárias como abaixo (cada etapa usa um número razoável de páginas adicionais para o comprimento dos dados de seu resultado, mas isso é igual ao uso da página das etapas anteriores, não em vez disso de ).

    Expressão Comprimento de dados páginas_allocadas Diferença Comprimento/Diferença de dados
    CAST('' AS NVARCHAR(MAX)) + '{algum texto pequeno}' 34 0 0
    CAST('' AS NVARCHAR(MAX)) + '{algum texto pequeno}' + ISNULL(@V1, '{}') 200000034 24920 24920 8025.683547
    CAST('' AS NVARCHAR(MAX)) + '{algum texto pequeno}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') 400000034 74768 49848 8024.39484
    CAST('' AS NVARCHAR(MAX)) + '{algum texto pequeno}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') + ISNULL(@V3, '{}' ) 600000034 149552 74784 8023.107001
    CAST('' AS NVARCHAR(MAX)) + '{algum texto pequeno}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') + ISNULL(@V3, '{}' ) + ISNULL(@V4, '{}') 800000034 249280 99728 8021.81969

    Como David Browne - Microsoft diz nos comentários...

    Isso faz sentido, pois +é um operador binário e CONCATé uma N-aryfunção. Portanto, sem otimização especial, a+b+cé avaliado como (a+b)+c, exigindo duas novas strings. Embora CONCAT(A,B,C)seja mais fácil construir uma nova string

    No script abaixo, não atribuo à @Rvariável, pois isso exige que as páginas sejam alocadas e estou apenas focando nas páginas usadas pelos métodos de concatenação.

    DECLARE @internal_objects_alloc_page_count1 BIGINT, 
        @internal_objects_alloc_page_count2 BIGINT,
        @internal_objects_dealloc_page_count1 BIGINT, 
        @internal_objects_dealloc_page_count2 BIGINT
       ,@V1 NVARCHAR(MAX)
       ,@V2 NVARCHAR(MAX)
       ,@V3 NVARCHAR(MAX)
       ,@V4 NVARCHAR(MAX)
       ,@TestConcat BIT = 0;

DECLARE @R NVARCHAR(MAX);

SELECT  @V1 = REPLICATE(CAST('V1' AS NVARCHAR(MAX)), 50000000)
       ,@V2 = REPLICATE(CAST('V2' AS NVARCHAR(MAX)), 50000000)
       ,@V3 = REPLICATE(CAST('V3' AS NVARCHAR(MAX)), 50000000)
       ,@V4 = REPLICATE(CAST('V4' AS NVARCHAR(MAX)), 50000000);

SELECT @internal_objects_alloc_page_count1 = internal_objects_alloc_page_count, 
       @internal_objects_dealloc_page_count1 = internal_objects_dealloc_page_count
from sys.dm_db_task_space_usage
WHERE session_id = @@spid

IF @TestConcat = 1
    SELECT DATALENGTH(CONCAT('{some small text}',ISNULL(@V1, '{}'), ISNULL(@V2, '{}'), ISNULL(@V3, '{}'), ISNULL(@V4, '{}')))
ELSE
    SELECT DATALENGTH(CAST('' AS NVARCHAR(MAX)) + '{some small text}' + ISNULL(@V1, '{}') + ISNULL(@V2, '{}') + ISNULL(@V3, '{}') + ISNULL(@V4, '{}'));


SELECT @internal_objects_alloc_page_count2 = internal_objects_alloc_page_count, 
       @internal_objects_dealloc_page_count2 = internal_objects_dealloc_page_count
from sys.dm_db_task_space_usage
WHERE session_id = @@spid


SELECT @internal_objects_alloc_page_count2-@internal_objects_alloc_page_count1 AS newly_allocated_pages,
       @internal_objects_dealloc_page_count2-@internal_objects_dealloc_page_count1 AS newly_deallocated_pages,
       (@internal_objects_alloc_page_count2 - @internal_objects_dealloc_page_count2) - (@internal_objects_alloc_page_count1 - @internal_objects_dealloc_page_count1) as new_in_use_pages
    • 11

relate perguntas