Question3CPO's questions

No momento, estou construindo um processo no Powershellqual podemos copiar SQL Server Agenttrabalhos de um servidor para outro apenas inserindo os nomes dos servidores. O script usa a biblioteca SMO para obter acesso a ambos os servidores de trabalho, faz o script dos trabalhos que não existem no "outro" servidor e, em seguida, executa esses scripts (sob um SqlConnection e SqlCommand). A questão é como verificar se existe um trabalho em ServerOnecomparação com ServerTwo.

Eu tentei quatro abordagens diferentes: construir uma matriz com as tarefas do ServerTwo (o servidor de comparação) e ver se essa matriz containsé uma tarefa do ServerOne; Também tentei o operador like com a mesma lógica; e, usando arrays, usei Compare-Objectdepois de carregar dois arrays com nomes de jobs de ambos os servidores e medir quais jobs não existem no outro (produz tudo também). Finalmente, percorri cada trabalho no ServerTwo e percorri cada trabalho no ServerOne para ver se eles são iguais (que é o código abaixo). Isso produzirá tudo porque cada trabalho não é igual a cada trabalho:

$ServerName = "S1\I"
$ComServer = "S2\I"
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
$srv = New-Object "Microsoft.SqlServer.Management.Smo.Server" $ServerName
$com = New-Object "Microsoft.SqlServer.Management.Smo.Server" $ComServer


foreach ($a in $com.JobServer.Jobs)
{
    $a = $a.Name.ToString() 
    foreach ($j in $srv.JobServer.Jobs) 
    { 
        $j = $j.Name.ToString()

        if ($a -like $j)
        {
            Write-Host $j
        }
    }   
}

Existe outra abordagem para isso onde eu possa verificar se existe um trabalho em um servidor versus outro (como uma observação, eu já sei como fazer o script do trabalho, executá-lo e assim por diante; a parte de garantir que o trabalho não já existe é o problema aqui)?

Consulte esta pergunta no SO porque é semelhante.

Estou trabalhando em uma maneira de excluir um intervalo de datas de todas as tabelas com valores de data em um banco de dados (finalidade para criar mini-devs). Eu construí um script que permite ao usuário passar os valores de início, fim e banco de dados, mas estou tendo problemas com o sql dinâmico. Por exemplo, ao remover registros entre determinadas datas, recebo um conflito de operandos. O exemplo abaixo mostra um exemplo simplificado disso:

DECLARE @b DATE, @e DATE, @cmd NVARCHAR(MAX)
SET @b = '2012-07-01'
SET @e = '2014-01-25'


SET @cmd = 'DELETE FROM DateTable
WHERE ValueDate BETWEEN ' + CONVERT(VARCHAR,@b,121) + ' AND ' + CONVERT(VARCHAR,@E,121)

EXEC sp_executesql @cmd

O erro é Operand type clash: date is incompatible with int. Tentei fazer um inner CASTdentro do sql dinâmico pois o erro indica que o ValueDatetorna-se e INT:

-- Only the WHERE clause changed:
WHERE ValueDate BETWEEN CAST(' + CONVERT(VARCHAR,@b,121) + ' AS DATE) AND CAST(' + CONVERT(VARCHAR,@E,121) + ' AS DATE)'

O erro desta vez é Explicit conversion from data type int to date is not allowed. Finalmente tentei jogar com alguns outros formatos ( do MSDN ). Em poucas palavras, quero fazer exatamente o que o usuário do SO estava tentando realizar, mas ser capaz de fazê-lo em várias tabelas ( até procurei um script , pois duvido que seja a primeira pessoa a querer isso).

Nossa equipe de DBA não verifica os backups usando o seguinte TSQL(o que pode ser feito facilmente após o backup e quase não leva tempo, então não entendo por que não):

RESTORE VERIFYONLY
FROM DISK = 'D:\Backups\LOCATION'

Eles tiveram problemas no passado, então, embora pensássemos que eles aprenderiam com isso, eles não aprenderam. Criei um script Powershell para fazer isso porque temos mais de 100 servidores e só quero executar esse script em todos os backups apenas para garantir que sejam válidos. O script abaixo é executado corretamente (na medida em que não quebra ou lança erros), estou curioso para saber se há uma maneira de obter a mensagem impressa de volta no Powershell que normalmente receberíamos no SSMS, onde afirma O backup definido no arquivo 1 é válido como verificação.

$SqlCon = New-Object System.Data.SqlClient.SqlConnection
$SqlCon.ConnectionString = "SERVER=SERV\INST;Integrated Security=true;DATABASE=master"

$baks = Get-ChildItem "D:\Backups\" -Filter *.BAK

foreach ($bak in $baks)
{
    $SqlCon.Open()
    $cd = New-Object System.Data.SqlClient.SqlCommand
    $cd.Connection = $SqlCon

    $cd.CommandText = "RESTORE VERIFYONLY FROM DISK = @f"
    $cd.Parameters.Add("@f", $bak.FullName)
    $cd.ExecuteNonQuery()
    $SqlCon.Close()
}

Estou importando mais de 200 arquivos de rastreamento (que são enormes) e minha abordagem atual é executar um loop e inserir os dados de rastreamento (consulte o script abaixo). Eu olhei em volta para ver se havia uma maneira mais rápida de fazer isso, seja por SSIS ou C # e parece que eles ainda chamam a função abaixo, semelhante ao script abaixo.

Alguém tem outros métodos que eles usam para importar vários rastreamentos? Não me interpretem mal, o código abaixo funciona, mas estou curioso para saber se há algo mais rápido que não estou considerando.

DECLARE @start INT = 1, @stop INT = 223, @sql NVARCHAR(MAX), @path VARCHAR(1000)


WHILE @start <= @stop
BEGIN

       SET @path = 'N:\Traces\TraceFile_' + CAST(@start AS VARCHAR(5)) + '.trc'

       SET @sql = 'INSERT INTO SavedTraces
                   SELECT *
                   FROM ::fn_trace_gettable(''' + @path + ''', default)
                    '

       EXECUTE sp_executesql @sql

       SET @start = @start + 1
       SET @path = ''
       SET @sql = ''

END

Notas de dados: 490 MB (~.5G), que contém mais de 11.700.000 linhas, requer 13:11 minutos para importar.

No próximo ano, estou ajudando em um esforço para limpar vários ambientes do SQL Server.

Temos cerca de 10.000 procedimentos armazenados e estimamos que apenas cerca de 1.000 deles são usados ​​regularmente, e outros 200 ou mais são usados ​​em raras ocasiões, o que significa que temos muito trabalho a fazer.

Como temos vários departamentos e equipes que podem acessar esses bancos de dados e procedimentos, nem sempre somos nós que chamamos os procedimentos, o que significa que devemos determinar quais procedimentos estão sendo chamados. Além disso, queremos determinar isso em alguns meses, não em alguns dias (o que elimina algumas possibilidades).

Uma abordagem para isso é usar o SQL Server Profilere rastrear quais procedimentos estão sendo chamados e compará-los com a lista de quais procedimentos temos, enquanto marcamos se os procedimentos são usados ​​ou não. A partir daí, poderíamos mover os procedimentos para um esquema diferente, caso um departamento viesse gritar.

Está usando a Profilerabordagem mais eficaz aqui? E/ou algum de vocês fez algo semelhante e encontrou outra maneira/melhor maneira de fazer isso?