Início / dba / Perguntas / 29775
Accepted
Ario
Asked: 2012-12-05 05:42:12 +0800 CST

Juntar tabelas em uma correspondência de string parcial

  • 772

input: Eu tenho uma tabela contendo (qualquer número de) strings fornecidas pelo usuário:

╔═══════╗
║ Value ║
╠═══════╣
║ To    ║
║ An    ║
╚═══════╝

E uma tabela de detalhes do usuário:

╔════════╦══════════╗
║ UserID ║ UserName ║
╠════════╬══════════╣
║     12 ║ Tom      ║
║    132 ║ Ann      ║
║     32 ║ Dina     ║
║      2 ║ Mark     ║
╚════════╩══════════╝

Eu preciso de uma consulta para retornar todos os registros da tabela de usuários, onde UserNamehá uma correspondência de string parcial para qualquer Valueregistro na tabela de entrada. A saída esperada neste caso é:

╔════════╦══════════╗
║ UserID ║ UserName ║
╠════════╬══════════╣
║     12 ║ Tom      ║
║    132 ║ Ann      ║
╚════════╩══════════╝
sql-server t-sql

3 respostas

  1. Best Answer

    Isso deve fazer o que você deseja:

    DECLARE @Users AS TABLE
(
    UserID      integer,
    UserName    nvarchar(50)
);

INSERT @Users
    (UserID, UserName)
VALUES
    (12, N'Tom'),
    (132, N'Ann'),
    (32, N'Dina'),
    (2, N'Mark');

DECLARE @Input AS TABLE
(
    Value    nvarchar(500) NOT NULL
);

INSERT @Input (Value)
VALUES 
    (N'To'),
    (N'An');

SELECT * 
FROM @Users AS u 
WHERE 
    EXISTS 
    ( 
        SELECT * 
        FROM @Input AS i 
        WHERE 
            u.UserName LIKE N'%' + i.Value + N'%'
    );

    Resultado:

    ╔════════╦══════════╗
║ UserID ║ UserName ║
╠════════╬══════════╣
║     12 ║ Tom      ║
║    132 ║ Ann      ║
╚════════╩══════════╝
    • 7

  2. Com base no contexto de sua pergunta anterior, consulta SQL para combinações sem repetição , acho que você está procurando uma maneira de encontrar combinações de usuários e incluir o nome e o ID no conjunto de resultados. O script a seguir demonstra uma maneira de conseguir isso:

    Dados de amostra:

    DECLARE @Users AS TABLE
(
    UserID      integer,
    UserName    nvarchar(50)
);

INSERT @Users
    (UserID, UserName)
VALUES
    (12, N'Tom'),
    (132, N'Ann'),
    (32, N'Dina'),
    (2, N'Mark');

    Carregue os dados de origem em uma tabela configurada para facilitar a localização de combinações:

    -- Working table to find combinations
DECLARE @Combination AS TABLE 
(
    item_id     tinyint IDENTITY(1,1) PRIMARY KEY NONCLUSTERED,
    item        nvarchar(500) NOT NULL,
    item_value  integer NOT NULL,
    bit_value   AS 
                CONVERT
                (
                    integer, 
                    POWER(2, item_id - 1)
                )
                PERSISTED UNIQUE CLUSTERED
);    

-- Add user details to the working table
INSERT @Combination
    (item, item_value)
SELECT
    u.UserName,
    u.UserID
FROM @Users AS u;

    Use o fato de que os inteiros naturais têm um padrão de bits que corresponde às combinações que queremos encontrar. Determine o valor inteiro máximo que precisamos com base no número de itens na tabela de trabalho:

    -- Maximum integer needed for combination bit values
DECLARE 
    @max integer = 
    POWER(2,
        (
            SELECT COUNT_BIG(*) 
            FROM @Combination
        )
    ) - 1;

    Em vez de concatenar os membros do grupo usando FOR XML PATH, liste as combinações em linhas com um group_idpara identificar cada grupo:

    -- Find combinations
SELECT
    group_id = N.n,
    c.item,
    c.item_value
FROM @Combination AS c
JOIN dbo.Numbers AS N ON
    n.n & c.bit_value = c.bit_value
WHERE
    N.n BETWEEN 1 AND @max
ORDER BY
    group_id;

    Saída parcial:

    ╔══════════╦══════╦════════════╗
║ group_id ║ item ║ item_value ║
╠══════════╬══════╬════════════╣
║        1 ║ Tom  ║         12 ║
║        2 ║ Ann  ║        132 ║
║        3 ║ Ann  ║        132 ║
║        3 ║ Tom  ║         12 ║
║        4 ║ Dina ║         32 ║
║        5 ║ Dina ║         32 ║
║        5 ║ Tom  ║         12 ║
║        6 ║ Ann  ║        132 ║
║        6 ║ Dina ║         32 ║
║        7 ║ Dina ║         32 ║
║        7 ║ Ann  ║        132 ║
║        7 ║ Tom  ║         12 ║
║        8 ║ Mark ║          2 ║
║        9 ║ Mark ║          2 ║
║        9 ║ Tom  ║         12 ║
╚══════════╩══════╩════════════╝
    • 5

  3. Você pode ser mais específico no que está tentando realizar? Thomas está certo, parece que você deseja adotar uma abordagem processual para algo que pode ser feito de maneira definida.

    Se você deseja obter um conjunto de resultados e processá-los um de cada vez para um aplicativo, recomendo fortemente fazer esse processamento baseado em linha em seu aplicativo. O SQL Server foi projetado para funcionar com conjuntos e não com linhas.

    Se você deseja ter um procedimento que retorne a próxima linha toda vez que for chamado. Mais uma vez, sugiro extrair o conjunto de resultados como um todo e processar as operações baseadas em linha no código do aplicativo.

    Se você deve fazer isso em t-sql, então um cursor é o que você precisa. Eu recomendo fortemente contra isso, no entanto, uma vez que um cursor é uma linha por uma operação de linha agonizante e os cursores não têm muito desempenho.

    • 1

relate perguntas