datagod's questions

Usamos os serviços CDC da Attunity para mover dados do Oracle para o SQL Server.

Usando a ferramenta de snap-in Oracle CDC Designer, posso ver o status atual do serviço e uma mensagem de erro se ocorrer um problema. Posso clicar em 'Coletar diagnóstico' na ferramenta para coletar mensagens para um intervalo de datas e gravar em um arquivo.

Quero descobrir onde as informações de diagnóstico estão armazenadas para que eu possa lê-las diretamente por meio do powershell de um servidor de monitoramento.

Examinei os logs de eventos e posso ver algumas mensagens de status, mas o relatório de diagnóstico tem muito mais dados.

Implanto vários trabalhos do SQL Server em uma frota de servidores usando um script do PowerShell. Eu posso criar as etapas do trabalho, ação de falha de sucesso e até mesmo o arquivo de saída. Isso tudo funciona em vários servidores. O que não posso determinar é como especificar que o arquivo de saída deve ser anexado em vez de substituído.

O seguinte é a seção do meu script principal. $Jobé preenchido em uma etapa anterior.

$JobStep = new-object ('Microsoft.SqlServer.Management.Smo.Agent.JobStep') ($Job, 'MyJobStepName')
$JobStep.ID = 1
$JobStep.SubSystem = 'PowerShell'
$Command = 'dir d:\'
$JobStep.Command   = $Command
$JobStep.OnSuccessAction = 'GotoNextStep'
$JobStep.OnFailAction    = 'GotoNextStep'
$JobStep.OutputFileName  = 'D:\MyJobFile.txt'
$JobStep.Create()

Eu tenho usado esta página do MSDN como referência.

Modifiquei uma das etapas usando o SQL Server Management Studio e rastreei o resultado. Isso parece promissor. Posso emitir um comando SQL depois de criar as etapas de trabalho.

EXEC msdb.dbo.sp_update_jobstep @job_id=N'12156dcb-c8cd-4267-901a-55175dd44960', @step_id=1 ,
        @flags=2

Tenho vários scripts do Powershell que precisam gravar dados em um banco de dados Oracle. Não quero codificar as credenciais de login.

Ao conectar-me ao SQL Server, confio na autenticação do Windows e no Active Directory, mas isso não é uma opção aqui porque o banco de dados Oracle está em uma rede separada (Unix). Os scripts serão executados em um SQL Server via SQL Server Agent.

Espero encontrar uma estratégia que seja segura e minimize o trabalho envolvido na hora de alterar a senha.

Acho que estou gastando muito tempo ultimamente examinando listas de índices propostos que foram gerados por um consultor de ajuste de índice ou algum outro processo automatizado.

Naquela época (por volta de 2005), achei as sugestões bastante horríveis, pois pareciam voltadas para uma consulta específica e, na maioria das vezes, eram apenas um índice de cobertura que tinha todas as colunas da tabela, independentemente de essas colunas já serem ou não índices .

Com o passar do tempo, sinto que os consultores de ajuste de índice melhoraram drasticamente, mas ainda tenho uma desconfiança interna e ainda quero gastar tempo revisando cada um deles.

Estou tentando não ser pessimista, mas é difícil quando um fornecedor (Microsoft) sugere adicionar vários índices de cobertura sobrepostos para melhorar o desempenho, especialmente quando estamos pagando pelo espaço de armazenamento. Eu também não quero gastar meu próprio tempo desnecessariamente. Eu preferiria corrigir consultas mal escritas.

Existe uma abordagem comum para criptografar dados no nível do banco de dados? O aplicativo no qual estou trabalhando armazenará dados confidenciais que apenas os próprios usuários do sistema poderão visualizar.

Estou procurando uma maneira de descobrir quando o Windows Server foi iniciado pela última vez usando apenas comandos t-sql.

Estou tentando ficar dentro das configurações de segurança padrão (ou seja, não quero habilitar xp_cmdshell)

Existe uma maneira de visualizar os logs de erros do SQL Server no RDS da Amazon? Eu costumo usar sp_ReadErrorlog, mas no RDS precisamos ser um membro da função securityadmin.

Estou criando uma série de novas tabelas que terão a compactação em nível de página habilitada.

Isso também afetará os índices ou terei que especificar também a compactação ao criar os índices?

create table Message
(
  pk_Message   int identity  NOT NULL constraint PK_Message primary key,
  [Message]    varchar(900)  NOT NULL constraint UK_Message__Message unique,
  DateCreated  datetime      NOT NULL default getdate()
) with (data_compression = page)
go  

Como você pode ver no meu exemplo, pretendo criar uma restrição exclusiva em um tipo de dados bastante grande e quero aproveitar a compactação.

Em preparação para migrar um farm de servidores para a nuvem, estou tentando enumerar todos os servidores vinculados que foram definidos ao longo dos anos. Também preciso encontrar (e corrigir) o código que faz referência a esses servidores vinculados.

Aqui está algo que juntei para ajudar a identificar nomes de objetos que se referem ao servidor vinculado, mas isso só funciona em procs armazenados, visualizações, funções e gatilhos:

declare @sql varchar(2000)
select  @SQL = 'use ?;
print ''?'';
print replicate(''-'',len(''?''));
print '' ''; 

select object_name(sc.id)
  from syscomments sc
  where text like ''%TheLinkedServer%''
'

exec sp_msforeachdb @sql

Eu sei que terei que abrir os pacotes DTS/SSIS... Estou apenas tentando terminar o máximo possível o mais rápido possível.

Sei que esta é uma tecnologia antiga, mas às vezes a atualização nem sempre é uma opção.

Alguém agora como listar as palavras de ruído reais que estão atualmente em uso em um índice de texto completo do SQL 2000?

Temos um problema recorrente em um sistema SQL 2000 muito antigo. É um cluster de 3 vias do Windows 2003. De vez em quando, o cluster faz failover para um novo nó e, quando esse nó fica online, parece estar usando uma lista de palavras de ruído diferente da que queremos.

Parece que vários service packs para SQL 2000 deixam arquivos de palavras de ruído e, quando ocorre o failover, o primeiro arquivo de palavras de ruído encontrado (em qualquer diretório) é o que é carregado.

Estou em uma situação difícil e procurando conselhos sobre como proceder. Tenho que importar alguns dados de um ambiente para outro. 80% dos registros foram modificados, então o plano é simplesmente excluir todos os registros existentes e importar os novos.

Infelizmente esta é uma tabela base. Várias outras tabelas possuem FK's definidos, apontando para esta tabela. Para excluir os dados, preciso descartar os FK's e recriá-los quando terminar a importação ou desabilitar as restrições e reativá-las.

Nenhum registro foi deletado. Uma cópia do prod foi feita e os desenvolvedores ajustaram os dados e adicionaram novos registros.

Qual abordagem você adotaria?

Um desenvolvedor disse que eu deveria simplesmente agrupar todos os meus scripts de atualização de banco de dados em uma transação. Se falhar, basta reverter todas as alterações. Todos os meus instintos me dizem que isso é errado, especialmente quando se trata de lidar com grandes volumes de dados e/ou procedimentos e funções.

Eu normalmente mantenho o processo de atualização em bancos de dados de instância única da seguinte maneira:

• Negociar uma janela de manutenção
• Preparar scripts de atualização
• Colocar banco de dados em modo de usuário restrito
• Desabilita trabalhos/processos agendados que normalmente atingiriam o banco de dados durante esta janela
• Faça um backup completo
• Aplicar os scripts de atualização
• Faça com que o desenvolvedor ou a equipe de teste confirme se o aplicativo funciona conforme o esperado
• Coloque o banco de dados de volta no modo multiusuário
• Liberar o banco de dados para uso normal

No entanto, quando se trata de implementar alterações em várias centenas de instâncias, alterei meu processo da seguinte maneira:

• Torno os scripts de atualização muito mais robustos: eles podem ser executados várias vezes no mesmo servidor sem danos, os números da versão do banco de dados são respeitados, os scripts serão encerrados se forem executados na versão de execução, etc.

• gerar um processo para cada servidor (usando powershell, osql, etc)

• execute o script de atualização apropriado
• relatar sucesso ou falha

Estou tentando determinar a melhor maneira de distribuir scripts SQL para centenas de servidores distribuídos. Eu tenho um pacote SSIS lento e um processo OSQL/BATCH muito rápido.

Estou em um projeto em que temos várias centenas de servidores de banco de dados implantados no campo. Preciso ser capaz de consultar rotineiramente os servidores e/ou aplicar scripts de atualização de banco de dados.

Quando tínhamos apenas 20 servidores, criei um pacote SSIS para obter uma lista de servidores e processá-los um por vez. O pacote SSIS funciona muito bem, tem toneladas de tratamento e registro de erros, etc. Ele é capaz de capturar conjuntos de resultados de cada servidor e armazená-los em um local central para análise posterior. Devido à maneira como o construí, no entanto, ele processa cada servidor em série. 20 servidores leva cerca de 10 minutos para processar. Estou em um ponto em que esse método é simplesmente muito lento.

Antes de investir mais tempo reescrevendo este pacote para gerar outros pacotes (um para cada servidor), esperava obter alguns conselhos de outras pessoas que enfrentaram uma situação semelhante.

Você usaria o SSIS dessa maneira ou mudaria para powershell ou até mesmo OSQL?

Quase como uma brincadeira, vasculhei meus arquivos e retirei um processo em lote que escrevi há 12 anos para aplicar scripts em servidores remotos. Fiz alguns ajustes (mudei para OSQL) e ele roda incrivelmente rápido. Posso processar 100 servidores em menos de 20 segundos. Eu o inicio de uma máquina com Windows 7, que não engasga com tantas janelas de comando sendo abertas.

A desvantagem da solução OSQL/BATCH é que o arquivo em lote é codificado com nomes de servidor e senhas. Mas é tão rápido que continuarei a usá-lo até encontrar uma solução melhor.

Pacote SSIS - O pacote SSIS atual faz o seguinte: - conecta-se a um servidor central - recupera uma lista de servidores que precisam ser consultados - usando um contêiner forloop, conecta-se a cada servidor (em série) e executa a consulta - se a consulta retorna um conjunto de resultados, esta informação é capturada e armazenada no servidor central - o servidor central é atualizado para refletir o sucesso/falha de cada servidor - todos os erros são registrados no servidor central

Eu tenho um pacote SSIS que executa consultas simples em uma lista de servidores. Estou tendo um problema com uma consulta simples específica: se existir uma tabela, obtenha o número de linhas. Caso contrário informe "não existe".

O código SQL funciona no Management Studio se eu me conectar diretamente, mas quando me conecto com o SSIS usando uma tarefa de fluxo de dados ADO NET para executar o código, recebo um erro de validação. Parece-me que o SSIS está examinando todos os objetos no código para ver se eles existem antes de executar. Ele falha antes mesmo de tentar executar.

Se eu comentar "selecionar contagem(*) da Tabela1", tudo funcionará sem problemas.

Os servidores distribuídos estão todos usando o SQL Server 2008R2 Express Edition.

declare @Result varchar(1000),
        @Table1Count int

select  @Result = '',
        @Table1Count = 0

-- If tables exist, get the counts
IF EXISTS(select 1 from information_schema.Tables where Table_Name = 'Table1')
BEGIN
  select @Table1Count = count(*) from Table1
  select @Result = 'Table1: ' + convert(varchar(12),@Table1Count) 
END
ELSE
  select @Result = 'Tables do not exist'

Alguma ideia?

Eu tenho um banco de dados que rastreia pessoas com base em tags RFID embutidas em seus sapatos. Esses dados chegam em uma VARCHAR(MAX)coluna com outros dados misturados, sem nenhuma ordem específica. Até agora, todos os valores RFID são formatados da seguinte forma:

AnnnnnnnnAnnAAAA  (where A = 0-9  and n = A-Z)

Estou escrevendo um relatório para extrair os RFIDs dessas mensagens e armazená-los em uma tabela própria. Desde que os RFIDs sigam esse mesmo padrão, posso encontrá-los. Se o formato RFID mudar, meu processo de extração falhará.

Existe um formato padrão para tags RFID? Que tipo de dados seria mais adequado para armazenar tags RFID?

Eu estou indo VARCHAR(20)por agora.

Tenho um relatório que mostra a contagem de eventos nas últimas 12 horas, agrupados por hora. Parece fácil, mas estou lutando para incluir registros que cubram as lacunas.

Aqui está uma tabela de exemplo:

Event
(
  EventTime datetime,
  EventType int
)

Os dados ficam assim:

  '2012-03-08 08:00:04', 1
  '2012-03-08 09:10:00', 2
  '2012-03-08 09:11:04', 2
  '2012-03-08 09:10:09', 1
  '2012-03-08 10:00:17', 4
  '2012-03-08 11:00:04', 1

Preciso criar um conjunto de resultados que tenha um registro para cada hora das últimas 12 horas, independentemente de haver eventos durante essa hora ou não.

Supondo que a hora atual seja '2012-03-08 11:00:00', o relatório mostraria (aproximadamente):

Hour  EventCount
----  ----------
23    0
0     0
1     0
2     0
3     0
4     0
5     0
6     0
7     0
8     1
9     3
10    1

Eu criei uma solução que usa uma tabela que possui um registro para cada hora do dia. Consegui obter os resultados que procurava usando um UNION e alguma lógica de caso complicada na cláusula where, mas esperava que alguém tivesse uma solução mais elegante.

Tenho uma tabela com mais de 400.000.000 de registros e estou procurando conselhos sobre como analisá-la rapidamente.

TheNameTable
(
  NameID  int primary key,
  TheName varchar(500)
)

Os nomes são armazenados assim: "FirstName, LastName" (não é minha tabela, apenas o que tenho para trabalhar)

Preciso extrair uma lista exclusiva de sobrenomes. Minha ideia inicial é processar a tabela em uma série de lotes (digamos, 50.000 registros por vez), usando o NameID para controlar os intervalos do lote. Eu usaria as funções de string incorporadas do SQL para quebrar a string no "," e manter a metade direita da string.

right(TheName,charindex('.',reverse(TheName))-1)

Tenho a sensação de que isso ainda levará MUITO tempo.

Alguém aí tem alguma outra ideia?

Valeria a pena simplesmente exportar os dados e processar o arquivo fora do banco de dados?

A solução com a qual fui:

Conforme sugerido, criei duas colunas computadas. Um para o primeiro nome, outro para o sobrenome. Eles não são persistidos, pois tenho espaço limitado.

alter table TheNameTable 
add LastName as substring(TheName, charindex(',',TheName)+1,1000)

alter table TheNameTable 
add FirstName as left(TheName,charindex(',',TheName)-1)

Pedi aos administradores um aumento temporário na RAM, eles aumentaram a VM para 32 GB.

Criei uma nova tabela, com colunas para FirstName e LastName. Coloquei um índice composto exclusivo nas colunas, mas especifiquei IGNORE_DUP_KEY = ON.

Acabei de inserir os primeiros 1.000.000 de registros. Ele filtrou 125.000 duplicatas. A instrução inteira levou 9 segundos para ser executada.

Essa é a velocidade que eu estava procurando!

É possível criar um alias ou sinônimo de banco de dados? O que eu espero poder fazer é ter NewDatabaseName alias como OldDatabaseName para evitar ter que reescrever uma tonelada de código.

Histórico: Fui abordado por um cliente com um problema auto-induzido ridículo. Eles têm um aplicativo de terceiros que possui um back-end do servidor SQL. Os usuários escreveram relatórios personalizados nesse banco de dados usando o Visual Basic, com todas as informações de conexão do banco de dados codificadas em seus programas.

Recentemente, o software de terceiros renomeou seu banco de dados. Agora todos os EXEs de relatório estão falhando.

Ah, eles também não têm muito código-fonte.

Segurei o riso e disse que veria o que poderia fazer.

Preciso executar algumas consultas ad-hoc em várias centenas de servidores que não fazem parte de um domínio. Cada servidor tem uma conta de usuário SQL de baixo privilégio que tem acesso somente leitura a algumas tabelas de interesse.

Minha ideia era ter os nomes desses servidores armazenados em uma tabela e usar essa tabela para conduzir um comando OPENDATASOURCE ou OPENROWSET.

Os servidores estão em domínios diferentes, domínios não confiáveis, grupos de trabalho, etc. Uma grande bagunça.

Não consigo encontrar um exemplo de como configurar esses comandos para usar uma combinação de conta/senha do SQL Server.

Nota: Isso acontece em um sandbox, não é para o mundo real. É simplesmente uma prova de conceito, portanto, a segurança não é uma grande preocupação. Esses servidores são acionados por um processo que simula um crescimento real de uma rede.

Para constar, consegui fazer o OPENROWSET funcionar:

SELECT *
FROM OPENROWSET('SQLNCLI',
   'DRIVER={SQL Server};SERVER=MyServer;UID=MyUserID;PWD=MyCleverPassword',
   'select @@ServerName')         

Eu tenho um relatório que atualiza automaticamente a cada 30 segundos. Geralmente isso acontece rápido o suficiente para que você nem perceba. Às vezes, porém, a carga demora um pouco mais. Quando isso acontece, os dados existentes ficam um pouco "acinzentados" e uma caixa animada que diz "Carregando" aparece.

Existe alguma maneira de evitar que os dados fiquem "acinzentados"? Acho muito perturbador.

O relatório faz parte de uma ferramenta de monitoramento. Nós temos isso em um jumbo-tron. Em certas condições, muda de cor, o que chama a atenção das pessoas. O "acinzentado" também chama a atenção das pessoas, mas pelo motivo errado.