Tenho duas tabelas e estou tendo problemas para descobrir como juntá-las para atender às minhas necessidades de projeção. Aqui está um cenário que ilustra o problema

1 . A primeira tabela possui um conjunto fixo de valores/linhas; neste caso Tipos de quarto

Tipos de quartos

Id | RoomType
--------------
1  | Bed Room
2  | Kitchen
3  | Half-Bath

2 . A segunda tabela mapeia os itens da primeira tabela para uma instância de uma propriedade . Uma propriedade pode ter 1 ou mais tipos de quartos

quartos de propriedade

Property | RoomTypeId
---------------------
  ABC    |     1
  ABC    |     3
  EFG    |     1
  XYZ    |     1
  XYZ    |     2
  XYZ    |     3

Observação : algumas das propriedades acima não são mapeadas para alguns tipos de quartos

3 . Eu gostaria de fazer uma projeção que unisse as linhas de forma que eu pudesse contabilizar facilmente os tipos de quarto que são mapeados e não mapeados para uma propriedade . Aqui está um resultado de amostra:

Property | RoomTypeId | PropertyHasRoom
---------------------------------------
   ABC   |     1      |      Yes
   ABC   |     2      |   No or NULL
   ABC   |     3      |      Yes
   EFG   |     1      |      Yes
   EFG   |     2      |   No or NULL
   EFG   |     3      |   No or NULL
   XYZ   |     1      |      Yes
   XYZ   |     2      |      Yes
   XYZ   |     3      |      Yes

Alguém pode explicar como isso pode ser feito em T-SQL.

Eu tenho uma mesa que ficou um pouco fora de controle. Eu não sou um DBA em si, mas pareço lembrar que a exclusão de um grande volume de linhas de uma só vez pode causar problemas no log de transações, prejudicar o desempenho geral do sistema durante a exclusão, etc ...

Existe uma maneira eficiente de criar um trabalho que exclua registros em pequenos lotes para dificultar outros acessos/desempenho e evitar problemas com o log de transações?

Esse processo pode ser bem lento é isso faz a diferença

Para contexto adicional, os critérios de exclusão serão baseados em algo como... where x like '%blah%'. Além disso, há um índice clusterizado e 5 índices não clusterizados.

Eu tenho uma tabela com uma coluna varchar contendo valores delimitados por pipe

Por exemplo:

Row 1 Column 1 = a|b|e|gg|foo 
Row 2 Column 1 = oV|foo|do 
Row 3 Column 1 = boop

Como posso consultar isso para retornar algo como? Duplicatas estão ok.

Resultados:

column
a
b
e
gg
foo
foo
oV
do
boop

Eu percebo que isso não é ideal, mas minhas mãos estão atadas com o esquema atual

Eu tenho um procedimento armazenado que calcula a duração média de um ciclo de solicitação/resposta em intervalos de 10 minutos. Isso funciona bem e atende às minhas necessidades de plotagem de gráficos. O que eu gostaria de fazer a seguir é calcular o valor mediano ... Suspeito que precisaria de uma subconsulta, mas não consigo descobrir como fazer isso.

SELECT dateadd(minute, 10 + (datediff(minute, 0, [Started]) / 10) * 10, 0) AS [Time]
     ,AVG(CASE WHEN Duration is null OR Duration = 0 
              THEN null ELSE Duration 
          END) AS [Mean Response Time]
FROM [Application].[Exchange] WITH (NOLOCK)
WHERE [Started] >= '24 Oct 2012' AND [Started] < '25 Oct 2012'
GROUP BY dateadd(minute, 10 + (datediff(minute, 0, [Started]) / 10) * 10, 0) 
ORDER BY dateadd(minute, 10 + (datediff(minute, 0, [Started]) / 10) * 10, 0)  

Alguém pode sugerir uma maneira que eu possa fazer isso?

Eu tenho uma coluna tinyint que representa um conjunto de sinalizadores. Supondo que eu queira saber se um bit específico foi definido ou não, como posso fazer AND/OR bit a bit em um procedimento armazenado?

Tenho uma tabela com o esquema a seguir, e preciso definir uma consulta que possa agrupar dados com base em intervalos de tempo ( Ex. registros por minuto ) e depois fornecer a soma das alterações no SnapShotValue desde o grupo anterior. No momento, o SnapShotValue sempre é incrementado, então eu só preciso da soma das diferenças. Alguém pode ajudar com uma consulta SQL Server T-SQL que pode fazer isso? Estou aberto a alterar o esquema, mas é o que tenho atualmente.

Esquema

CaptureTime   (datetime)
SnapShotValue (int)

Dados de amostra

1 Jan 2012 00:00:00,   100
1 Jan 2012 00:00:30,   125
1 Jan 2012 00:01:00,   200
1 Jan 2012 00:01:30,   300
1 Jan 2012 00:02:15,   400
1 Jan 2012 00:02:30,   425
1 Jan 2012 00:02:59,   500

Resultado da consulta desejado

1 Jan 2012 00:01:00,   225 -- Sum of all captured data changes up to the 1 minute mark
1 Jan 2012 00:02:00,   500 -- Sum of all captured data changes up to the 2 minute mark
1 Jan 2012 00:03:00,   125 -- Sum of all captured data changes up to the 3 minute mark

Estou movendo um aplicativo para o Azure e preciso obter conformidade com PCI para algumas colunas em uma única tabela. Sei que posso criptografar os dados antes de armazená-los, mas queria saber se havia um recurso no SQL Azure que pode gerenciar parte disso para mim. Eu fiz algumas leituras, mas não tenho certeza do que é; ou não é; com suporte no SQL Azure.

Eu li sobre padrões usando SQL Server ( e não SQL Azure ) onde a criptografia e descriptografia de dados foram aplicadas atrás de uma exibição. Nesse caso, todos os clientes acessaram os dados por meio de uma View e, conseqüentemente, foram abstraídos do processo de Criptografia/Descriptação. Com isso dito, parece um pouco perigoso.

Estou aberto a todas e quaisquer sugestões sobre como lidar com esta situação.

Acabei de começar a escrever um procedimento armazenado no SQL Server 2008 e tenho mais de 30 parâmetros. Eu nunca escrevi um com mais de ~10 parâmetros, e isso me fez pensar... Em que ponto existem muitos parâmetros?

Para contexto... este procedimento irá essencialmente INSERT uma única linha em uma única tabela. Haveria também um muito semelhante; embora um pouco menor; versão que realiza um UPDATE na mesma tabela. A maioria das colunas é relativamente pequena com uma mistura de int e strings ( varchar(200)).

Quais são os problemas; bom ou mal; a ter um procedimento com um grande número de parâmetros e qual é o limite onde devo começar a considerar outros padrões?

Eu tenho escrito alguns novos procedimentos armazenados e me encontro retornando entre 6-8 conjuntos de resultados em alguns casos. Sempre trabalhei com a suposição de que havia certas ineficiências com conjuntos de resultados que deveriam ser evitadas.

Parece que minhas opções são usar conjuntos de resultados ou construir uma representação xml dos objetos complexos e retorná-los usando canais SQL-XML ( isso é para evitar truncamento dos blogs, por clientes ADO ). Alguém tem alguma experiência com o desempenho e/ou eficiências relativas dessas escolhas e talvez forneça algumas percepções do lado bom e ruim de cada uma?

Para contexto adicional...

• Cada conjunto de resultados não teria mais de 30 colunas, com a maioria em torno de 10
• Os dados da coluna são principalmente números inteiros ( 1 a 8 bytes ) e algumas strings entre 50 e 2.000 caracteres
• Durante o pico de carga, esperamos entre 5 a 9 consultas por segundo para os SPROCs em questão, embora haja um caso de uso que possa ser de 10 por segundo
• Desnormalizar para uma visão mais plana não é realmente uma opção razoável na medida em que podemos ver

Estou configurando um ambiente de teste para desenvolvimento e preciso exportar alguns dados estáticos de tabelas em Produção. Idealmente, o produto exportado tomaria a forma de um script com todas as instruções INSERT necessárias . Ao fazer isso, posso redefinir o ambiente de desenvolvimento rapidamente após cada teste.

Alguém pode dizer como fazer isso usando SQL Server 2008, SQL Management Studio e/ou Visual Studio 2010?

Nota: Nenhuma das tabelas tem chaves estrangeiras, tenho permissões totais no banco de dados de origem e o número de linhas por tabela não é mais do que algumas dezenas.

Eu tenho vários serviços do Windows completos que atualmente pesquisam o banco de dados procurando por registros novos ou alterados em tabelas e/ou exibições específicas . Por razões óbvias, isso limita a escalabilidade e adiciona carga desnecessária aos meus bancos de dados do SQL Server 2008. Eu gostaria de implementar algo semelhante a um padrão de publicação e assinatura em que o banco de dados; através de algum mecanismo; publica mensagens para indicar quando certas mudanças de estado ocorrem.

Isso me leva à minha pergunta... Quais mecanismos residem no SQL Server 2008 nativamente; caso existam; que poderia suportar esse padrão?

Estou aberto a outras ideias, assumindo que posso me livrar das pesquisas cegas. Como um contexto extra, a mensagem precisará conter apenas informações básicas para descrever a natureza da mudança e o quê; por id; mudou.

Observação: considerei o uso de pacotes e gatilhos SSIS, mas não acho apropriado, especialmente durante os períodos em que a taxa de alteração é maior.

Estou definindo um esquema para um novo conjunto de recursos usando o SQL Server 2008... Nesse caso, cada registro ( por exemplo, linha ) precisará armazenar fragmentos XML. De tempos em tempos; embora não com frequência; Vou precisar consultar o XML para encontrar valores de elementos e atributos. Se deixado por conta própria, eu tenderia a usar o tipo de dados XML , embora tenha sido levado a acreditar que isso é forjado com problemas. Então isso me leva às minhas perguntas.

Diante desse cenário, quais fatores devo considerar ao tentar decidir entre armazenar XML em uma coluna XML ou uma coluna varchar(MAX)

Se ajudar... aqui estão alguns detalhes adicionais:

• Nenhuma decisão foi tomada em relação ao uso de esquemas para esses fragmentos ( por exemplo, XSD's )
• Os tamanhos dos fragmentos variam de pequenos a muito grandes
• Todo o XML será bem formado
• Ao longo de um dia, haverá até ~ 10.000 fragmentos coletados com suporte de consulta on-line necessário por ~ 3 meses
• As consultas ao XML acontecerão ao longo do dia, mas devem permanecer leves com poucas consultas simultâneas desse tipo

Sou principalmente um desenvolvedor de aplicativos, mas tenho que fazer todo o trabalho de banco de dados inicial para meu projeto atual ( aliás ... é MS SQL Server 2008 ). Como primeira decisão, estou tentando descobrir se devo dividir meu estado usando bancos de dados separados ou esquemas separados no mesmo banco de dados. Eu fiz uma pequena leitura no esquema do SQL Server e parece uma maneira natural de separar domínios de objeto ( que eu gosto ), mas não tenho certeza se pode haver custos ocultos para esse padrão.

Quais são as coisas mais práticas que devo considerar ao selecionar entre essas duas abordagens? Se eu evitar o dbo.mytablefavor de myschema.mytableestarei criando outros desafios ( ou problemas ) para minha arquitetura?

Como uma observação lateral... Em algum momento, isso será entregue a um DBA real para manter/suportar, então estou tentando ter certeza de não tornar a vida deles mais difícil.