Louis Somers's questions

Tenho uma hierarquia de configurações que tem um padrão para todos, podem ser substituídas por grupos, ou por um usuário individual, para uma tela específica, etc...

Eles são armazenados em uma tabela com um Hiarchy-ID para classificar, assim:

HIERARCHY | SETTING | OPTION | PREFERENCE | COLOR |
----------+---------+--------+------------+-------+
100       | NULL    | 1      | NULL       | NULL  |
10        | NULL    | 2      | square     |       |
1         | 0       | 3      | rounded    | green |

O resultado que procuro é para cada coluna, o primeiro valor não nulo (e seria ótimo se eu também pudesse esmagar um NULLIF(COLOR, '') também). Neste exemplo o resultado seria:

SETTING | OPTION | PREFERENCE | COLOR |
--------+--------+------------+-------+
0       | 1      | square     | green |

Atualmente estou fazendo uma consulta separada para cada coluna, mas espero que isso possa ser alcançado de uma maneira mais elegante?

Estou trabalhando com MS SQL Server (e preciso suportar a versão 2005).

Estou escrevendo uma instrução de inserção de processamento em lote e gostaria de usar uma tabela temporária para acompanhar os IDs inseridos em vez de fazer um loop pelos itens e chamar SCOPE_IDENTITY() para cada linha inserida.

Os dados que precisam ser inseridos possuem ID's (temporários) ligando-os a outros dados que também devem ser inseridos em outra tabela, então preciso de uma referência cruzada do Id real e do Id temporário.

Este é um exemplo do que tenho até agora:

-- The existing table 
DECLARE @MyTable TABLE (ID INT IDENTITY(1,1), [Name] NVARCHAR(MAX));

-- My data I want to insert
DECLARE @MyInsertData TABLE (ID INT, [Name] NVARCHAR(MAX));
INSERT INTO @MyInsertData ( ID,Name)
VALUES ( -1 , 'bla'),(-2,'test'),(-3,'last');

DECLARE @MyCrossRef TABLE ([NewId] INT, OldId INT);

INSERT INTO @MyTable ( [Name] )
   OUTPUT Inserted.ID, INS.ID INTO @MyCrossRef
   SELECT [NAME] FROM @MyInsertData INS

-- Check the result
SELECT * FROM @MyCrossRef

O problema é que não consigo fazer com que a cláusula OUTPUT INTO aceite o ID, já tentei @MyInsertData.IDe outros truques juntando a tabela a ela mesma, mas nada parece funcionar.

Estou tentando construir uma cláusula where que exija que um número X de filhos tenha uma relação com um pai específico com um relacionamento N para N. Algo semelhante a "Receba todos os recibos onde esses produtos foram vendidos juntos". Um cenário de exemplo é mais fácil de explicar:

DECLARE @Nodes TABLE(
  Id INT
);

DECLARE @Arc TABLE(
  Id INT IDENTITY(1,1),
  Source INT, -- FK @Nodes.Id
  Dest INT    -- FK @Nodes.Id
);

INSERT INTO @Nodes (Id) VALUES (1),(2),(3),(4);

INSERT INTO @Arc (Source, Dest) VALUES
   (1, 2)
  ,(1, 3)
  ,(1, 3)
  ,(2, 1)
  ,(2, 3)
  ,(2, 4);

No SP, a entrada é pré-processada em uma tabela como esta:

DECLARE @InputConnectedNodes TABLE ( Id INT );
INSERT INTO @InputConnectedNodes (Id) VALUES (3),(4); -- not a fixed number of nodes

Neste exemplo, queremos todos os nós que tenham um arco para os nós 3 e 4 (somente o nó 2 no exemplo acima). Atualmente temos isso:

SELECT DISTINCT Source 
    FROM @Arc
    WHERE Dest IN (SELECT Id FROM @InputConnectedNodes);

Em seguida, temos um código processual feio que percorre a entrada e a saída (aninhada) verificando todos os relacionamentos. Eu gostaria de substituí-lo por algo declarativo. O melhor que consegui até agora é este:

SELECT Source 
    FROM @Arc 
    WHERE Dest IN (SELECT Id FROM @InputConnectedNodes) 
    GROUP BY Source
    HAVING COUNT(Source) = (SELECT COUNT(*) FROM @InputConnectedNodes)

Mas falhará quando os nós tiverem vários arcos (idênticos) como (1->3) no meu exemplo.

Eu também poderia resolver isso gerando dinamicamente uma cláusula where, mas prefiro uma solução totalmente declarativa.

Parece que uma segunda variável em uma expressão está determinando o comprimento máximo da minha primeira variável.

Um exemplo é mais fácil de explicar:

DECLARE @MyDest AS NVARCHAR(MAX) = 'Some long text, for testing';
DECLARE @MySrc AS NVARCHAR(6) = '';

SELECT @MyDest = ISNULL(NULLIF(@MySrc, N''), @MyDest);

SELECT @MyDest;

O resultado é 'Some l'enquanto eu esperaria 'Some long text, for testing'.

Esta é uma versão simplificada de um bug mais complicado que estou tentando corrigir. Isso é um bug no servidor SQL ou devo fazer isso de maneira diferente?

Estou procurando uma "melhor prática" ou "padrão" específica sobre entidades que são compartilhadas entre diferentes entidades, tendo uma relação com uma de muitas.

Por exemplo, pode-se ter a entidade genérica "Endereço", que poderia ser utilizada para armazenar os campos de endereços comuns para clientes, fornecedores, funcionários, etc...

Um DBA experiente seguiria esse caminho ou preferiria adicionar os campos às entidades correspondentes? Também estou pensando em manutenção, restrições que podem (no futuro) diferir dependendo da entidade, coisas assim.

Eu adoraria obter referências a qualquer trabalho autoritário ou estabelecido sobre o assunto.

Estou tentando otimizar um gatilho em uma tabela em um banco de dados de terceiros. Não tenho permissão para alterar ou adicionar nenhuma coluna ao esquema.

A tabela possui uma chave primária composta, uma coluna é um número inteiro e a outra é nvarchar.

Como posso recuperar as linhas excluídas sem usar uma tabela temporária?

No momento, estou concatenando as chaves em uma string na cláusula where assim:

SELECT FROM deleted WHERE (deleted.a + CAST(deleted.b as nvarchar) 
       NOT IN (SELECT deleted.a + CAST(deleted.b as nvarchar) 
       FROM inserted, deleted 
       WHERE inserted.a = deleted.a 
         and inserted.b = deleted.b))

Eu também tentei várias variantes deleted.%%physloc%%de tentativas, mas sem sorte. Existe alguma maneira mais elegante de filtrar os registros excluídos?

Eu tenho uma visão que une várias tabelas, apenas para simplificar uma consulta frequentemente chamada. Esta exibição possui uma cláusula ORDER BY em um campo calculado (a ordem nunca será diferente). (no SQL Server Express 2008 R2).

A ideia básica é assim (simplificada):

SELECT [EventType].Name, 
    [EventType].TotalOccurrences, 
    [Session].ID, 
    [Session].TotalOccurrences, 
    [Session].TotalOccurrences / [EventType].TotalOccurrences AS saturation
FROM [EventType]
    INNER JOIN [Session] ON [EventType].ID = [Session].Event
ORDER BY saturation

Essa visão nunca será chamada sem uma cláusula where (que no meu caso quase retornaria o banco de dados inteiro). Estará sempre com WHERE [EventType].ID = x. No entanto, assim que adiciono a cláusula where, a cláusula ORDER BY é ignorada! Sem a cláusula where, está funcionando conforme o esperado.

Na verdade, uma pergunta diferente, mas estou jogando aqui enquanto estou nisso, existe uma maneira melhor de recuperar essas informações? O [EventType].Namee [EventType].TotalOccurrencesserá idêntico para todas as linhas retornadas, o que é um pequeno desperdício de largura de banda da rede. Não que isso seja um problema, mas estou me perguntando se existe algo para resolver isso sem a sobrecarga de latência de várias viagens de ida e volta ao banco de dados.

[Editar] A amostra acima foi simplificada demais, o campo calculado tem outros fatores para que ele retorne uma ordem diferente do ORDER BY [Session].TotalOccurrencesque seria simplesmente neste exemplo, mas o princípio deve ser claro.

[Edit2] Da resposta chego à conclusão de que o Designer Gráfico tem mais recursos do que o banco de dados subjacente:

Informação básica

• Banco de dados: SQL Server Express 2008 R2
• Cliente: SQL Server Management Studio

Backround (pular se não estiver interessado):

Um projeto que estou mantendo usa um ORM, que aparentemente armazenou meus valores enum (que herdam de Byte) em objetos .Net serializados binários armazenados em um campo varbinary(max). Só descobri que isso estava acontecendo depois que surgiu um novo requisito ditando que meu código fosse executado em confiança média. Como o formatador binário .Net precisa de confiança total para ser chamado, ele começou a travar nos enums.

Para limpar a bagunça, preciso criar scripts de migração que converterão esses valores (varbinary(max)) de volta em valores inteiros. Existem apenas alguns valores diferentes, portanto não deve ser um grande problema (pensei).

O problema :

Consigo obter representações de string dos blobs ao selecionar:

SELECT BinValue FROM MyTable where Type = 'Object';

Ele retorna uma string '0x...(uma matriz de valores hexadecimais)'.

Mas quando tento selecionar na coluna usando copiar e colar, certificando-me de ter o equivalente binário exato:

SELECT ItemId FROM MyTable WHERE Value=convert(varbinary(max), '0x...')

não retorna nenhum registro.

Então é possível resolver isso usando um cliente (como o Management Studio)?

Se sim, qual seria a sintaxe correta?