IronicMuffin's questions

Estou apenas procurando entender por que isso está acontecendo, e minhas pesquisas no Google estavam falhando. Estamos no SQL Server 2016 SP1.

Esta é a situação: Tabela de fornecedores que gerencia os IDs acompanhando os valores atuais de cada tabela. Uma função pode ser chamada para retornar um bloco de IDs se você estiver fazendo uma inserção.

Então, configuramos uma tabela temporária selecionando da tabela real usando select into(estamos clonando um conjunto de dados para ser reinserido com um conjunto de propriedades diferente).

Em seguida, chamamos a função e obtemos novos ids para o número de registros (ela apenas retorna o ID máximo, então fazemos algumas contas para obter o próximo id).

Em seguida, atualizamos a tabela como tal:

update #temp set @nextId = Id = @nextId + 1

com a expectativa de que ele incremente em um para cada registro e defina os ids.

Em vez disso, o mesmo ID foi definido para cada 4 registros, então seria incrementado e os próximos 4 obteriam o próximo id, etc. Por que a cada 4 registros? O que deu errado?

Ainda mais divertido, se colocarmos um índice clusterizado na tabela, tudo funciona corretamente.

Tenho certeza que tem a ver com a mesa ser um monte... mas não sei por quê.

Link para o plano .

Pergunto porque este é um recurso mais antigo que descobri recentemente. A documentação menciona DateTime algumas vezes, mas não diz explicitamente que outros tipos de data são compatíveis ou não.

Eu tenho um Data Warehouse que acredito que poderia se beneficiar disso, mas 90% das datas que importam são tipos de data, não DateTime. Estou no SQL 2014, mas informações sobre qualquer versão seriam úteis.

Acabei de perceber isso e estava tendo dificuldade em encontrar uma razão técnica para isso.

As tabelas podem ser eliminadas usando nomes de três partes, mas as visualizações são restritas a nomes de duas partes.

Qual é o raciocínio por trás disso?

Aqui está um exemplo do que estou perguntando:

Tabela de detalhes:

HeaderId | DetailId
    1          100
    1          101
    2          100
    2          101
    3          101
    3          102
    3          103

Estou procurando uma estratégia de consulta que me forneça todos os IDs de cabeçalho com o mesmo conjunto de IDs de detalhes para cada um.

Então, no exemplo, eu gostaria que HeaderId 1 e 2 se unissem porque eles têm os mesmos dois registros de detalhes, mas 103 não corresponderia porque tem um terceiro item no conjunto.

A estratégia que estou adotando até agora é usar a STUFFtécnica para criar uma string separada por vírgulas de valores de detalhes, fazer a soma de verificação dessa string e, em seguida, unir o resultado da soma de verificação. Parece estar funcionando, mas não sei como otimizá-lo. Em um conjunto de cerca de 7.000 cabeçalhos, ele retorna em cerca de 6 a 7 segundos.

Aqui está a consulta:

with Details as 
(   
    select distinct t2.HeaderId, 
    checksum(stuff((
        select
            ',' + convert(varchar(15), t2.DetailId)
        from
            DetailTable t2
        where
            t2.HeaderId = t2.HeaderId
        for xml path('')
    ),1,1,'')) as ChkSum
from
      DetailTable t1
)
select
    *
from
    Details t1
        join Details t2
            on t2.ChkSum = t1.ChkSum
            and t2.HeaderId <> t1.HeaderId -- To avoid matching the same record

Então - esta é a abordagem correta? E se for, como posso otimizar? O plano de consulta não tem nada pulando para mim. O maior peso é dado a um carretel de mesa. Além disso, estou tentando fazer disso uma função ou proc, se isso ajudar.

Edit: comecei a pesquisar a divisão relacional, e acho que isso é relevante aqui, mas talvez não no contexto em que estou pensando. Para dar mais contexto, aqui está o caso de negócios que estou tentando resolver.

Eu tenho um conjunto de Promoções que podem ter qualquer número de UPCs neles. Estou tentando encontrar promoções que tenham exatamente o mesmo conjunto de UPCs. Muitas das soluções que estou vendo dependem do uso do count(*). Então - apenas algum contexto para quem está olhando para isso. Obrigado!

Já me deparei com isso várias vezes e tenho certeza de que há uma boa razão para isso - mas como evitá-lo?

Tenho certeza que tem a ver com as peculiaridades ao redor isnumeric. Em inglês, tenho uma visão que filtra em isnumeric(somefield) = 1. Em seguida, tento consultá-lo usando um intna minha wherecláusula e, como algum outro campo na tabela tem valores de caractere, a coisa toda falha.

Eu criei um violino SQL que mostra o erro.

Tentei fazer um cast/convertno select na view, mas o mecanismo de consulta parece ignorá-lo.

Então - por que isso acontece e existe uma maneira limpa de lidar com isso?

O violino original teve um erro muito semelhante devido à falta de aspas na inserção. Esse não é o problema que eu estava tentando destacar. Corrigi a visão adicionando aspas a todos os valores que estão sendo inseridos.

Tenho uma tabela de fatos que será executada com um plano apropriado durante nosso processamento matinal. Ocasionalmente, no final do dia, se eu for consultá-lo, ele terá um plano realmente estranho.

Ao consultar uma tabela particionada por data, você geralmente vê um predicado de busca como este:

Mas, por algum motivo, se transforma nisso:

Sim, estou ciente de que existem duas tabelas diferentes mostradas acima. Peguei o bom exemplo de uma tabela configurada de forma semelhante e ele exibe apropriadamente o predicado de busca que eu esperaria.

Ambos são operadores Clustered Index Seek. A atualização das estatísticas não parece ajudar, mas alguma parte dos scripts de manutenção de Ola parece corrigi-lo todas as manhãs.

alguém viu isso antes? Alguma dica sobre como restaurar o bom plano?

Tenho uma dimensão de cliente em nosso data warehouse (SSAS 2014 Multidimensional). Ele é configurado como um SCD Tipo II, com apenas os campos Data inicial e Final para rastrear as alterações. (data final nula = atual).

À medida que nossa carga diária é executada e vejo as mudanças fluindo, às vezes me preocupo com a criação de novos registros quando não deveria.

Que tipo de scripts podem ser executados para comparar cada cliente em seu respectivo histórico e garantir que ele esteja sendo alterado adequadamente?

Além disso, e acho que estou abordando o problema de lacunas e ilhas, quais estratégias existem para verificar se as datas de início e término são todas contíguas?

Quero me sentir confiante de que a tabela está relatando dados corretos dia a dia sem se tornar uma fera devido a alguma verificação nula, causando a criação de uma tonelada de registros a cada dia.

Obrigado por qualquer ajuda que você possa oferecer.

Configuração existente do SQL Server 2005 com tabela EAV padrão que os usuários desejam dividir com uma ferramenta de BI (Cognos).

Existe alguma esperança de que possamos transformar esses dados em um formato do qual possamos relatar? O Google me levou a acreditar que não há esperança. Eu gostaria de acreditar que algum tipo de solução está por aí.