All perguntas(dba)

Preciso de ajuda com funções de janelas. Eu sei que você pode calcular a soma dentro de uma janela e o total corrente dentro de uma janela. Mas é possível calcular o total em execução anterior, ou seja, o total em execução não incluindo a linha atual?

Eu suponho que você precisaria usar o argumento ROWou . RANGEEu sei que existe uma CURRENT ROWopção, mas eu precisaria CURRENT ROW - 1, que é uma sintaxe inválida. Meu conhecimento dos argumentos ROWe RANGEé limitado, portanto, qualquer ajuda seria recebida com gratidão.

Eu sei que existem muitas soluções para este problema, mas estou procurando entender os argumentos ROWe RANGEsuponho que o problema pode ser resolvido com eles. Eu incluí uma maneira possível de calcular o total anterior, mas gostaria de saber se existe uma maneira melhor:

USE AdventureWorks2012

SELECT s.SalesOrderID
    , s.SalesOrderDetailID
    , s.OrderQty
    , SUM(s.OrderQty) OVER (PARTITION BY  SalesOrderID) AS RunningTotal
    , SUM(s.OrderQty) OVER (PARTITION BY  SalesOrderID 
                         ORDER BY SalesOrderDetailID) - s.OrderQty AS PreviousRunningTotal
    -- Sudo code - I know this does not work
    --, SUM(s.OrderQty) OVER (PARTITION BY  SalesOrderID 
    --                   ORDER BY SalesOrderDetailID
    --                   ROWS BETWEEN UNBOUNDED PRECEDING 
    --                                   AND CURRENT ROW - 1) 
    -- AS  SudoCodePreviousRunningTotal
FROM Sales.SalesOrderDetail s
WHERE SalesOrderID IN (43670, 43669, 43667, 43663)
ORDER BY s.SalesOrderID
    , s.SalesOrderDetailID 
    , s.OrderQty

Estou usando o SQL Server 2008 R2 e tenho esta pseudo consulta (SP):

select ...
from ...
WHERE    @LinkMode IS NULL
     AND (myColumn IN (...very long-running query...))
     ...
     ...

O problema é que a consulta demora muito para ser executada - mesmo que eu execute o SP com @LinkMode=2.

Como você notou, a consulta de execução longa deve ser executada apenas se @LinkMode for nulo, o que não é o caso aqui. No meu caso @LinkMode = 2!

No entanto, se eu mudar para:

 select ...
    from ...
    WHERE    1=2
         AND (myColumn IN (...very long time exeted query...))
     ...
     ...

o SP corre rápido.

Já ouvi falar que às vezes o otimizador pode otimizar a ordem dos critérios.

Então eu pergunto :

• Mesmo que o otimizador escolha uma rota diferente, o que pode ser mais rápido do que verificar se =null? Quero dizer, acho que verificar if a==nullé muito mais rápido do que executar a outra consulta longa ...

• Como posso forçar o SQL Server a executar a consulta conforme a escrevi (na mesma ordem)?

Sou muito novo no SQL Server e gostaria de entender se a selectinstrução a seguir, muito simples, teria algum bloqueio.

Select * from Student;

Por favor, considere o caso em que a instrução não estaria sendo executada dentro de um begin tranbloco.

Estou examinando o cache do plano, procurando por frutos de otimização fáceis e me deparei com este snippet:

Por que muitos dos custos listados acima de 100%? Isso não deveria ser impossível?

Existe uma prática recomendada para saber se uma chave estrangeira entre tabelas deve ser vinculada a uma chave natural ou a uma chave substituta? A única discussão que realmente encontrei (a menos que meu google-fu esteja faltando) é a resposta de Jack Douglas a esta pergunta , e seu raciocínio parece sólido para mim. Estou ciente da discussão além de que as regras mudam, mas isso seria algo que precisaria ser considerado em qualquer situação.

O principal motivo para perguntar é que tenho um aplicativo legado que faz uso de FKs com chaves naturais, mas há um forte impulso dos desenvolvedores para mudar para um OR/M (NHibernate em nosso caso), e um fork já produziu alguns quebrando as alterações, então estou procurando colocá-los de volta nos trilhos usando a chave natural ou mover o aplicativo herdado para usar chaves substitutas para o FK. Meu instinto diz para restaurar o FK original, mas sinceramente não tenho certeza se esse é realmente o caminho certo a seguir.

A maioria de nossas tabelas já possui uma chave substituta e uma chave natural já definidas (por meio de restrição exclusiva e PK), portanto, adicionar colunas extras não é um problema para nós neste caso. Estamos usando o SQL Server 2008, mas espero que seja genérico o suficiente para qualquer banco de dados.

Estou tentando ativar o log lento de consultas em nosso servidor para identificar quaisquer consultas que possam usar otimização. Parece bastante simples, mas meu arquivo não está sendo gravado. Não recebo erros ou algo parecido, simplesmente não parece estar registrando as consultas lentas. Lembrei-me de reiniciar o mysql após minhas alterações de configuração.

Estou usando o MySQL Ver 5.1.61. Aqui está o que eu tenho em my.cnf:

slow-query-log=1
slow-query-log-file=/var/logs/my.slow.log
long_query_time=1

o arquivo /var/logs/my.slow.log tem o mysql como proprietário, também no interesse da depuração, dei leitura/gravação para todos no arquivo de log.

Eu tenho o long_query_time definido como 1 acima, pois só quero ver se está funcionando. Eu tentei defini-lo mais baixo (por exemplo, 0,3), mas ainda não estou obtendo nada registrado. Sei que as consultas que meu aplicativo está executando demoram mais de 1 segundo e também executei consultas de log intencionalmente ( SELECT sleep(10);) no terminal para teste e o log ainda está vazio.

Eu examinei os documentos, pelo que posso ver, isso deve estar funcionando. Alguém tem alguma sugestão sobre o que estou fazendo de errado? Qualquer conselho seria apreciado, muito obrigado!

Editar: conforme solicitado nos comentários, executei a consulta:

 `SELECT variable_value FROM information_schema.global_variables WHERE variable_name IN ('slow_query_log','slow_query_log_file','long_query_time');`

O resultado:

10.0000000
/var/run/mysqld/mysqld-slow.log
OFF

Obviamente, minhas alterações de configuração não estão sendo levadas em consideração, pois acredito que sejam padrões. Estou certo de que o arquivo my.cnf que estou alterando está sendo analisado, pois se eu colocar um valor inválido, o mysql apresentará um erro ao reiniciar. O que poderia estar acontecendo aqui?

Outra edição:

Depois de seguir o conselho de @RolandoMySQLDBA e mover minhas linhas de configuração de consulta lenta para [mysqld]minhas configurações, parece estar salvando. Agora, o resultado da consulta variable_value acima é:

1.0000000
/var/logs/my.slow.log
ON

No entanto, ainda não estou vendo o arquivo my.slow.log sendo gravado. Não acho que seja um problema de permissão, pois o arquivo pertence ao mysql e adicionei todas as permissões para todos os usuários no arquivo. Alguém poderia pensar em uma razão pela qual isso não estaria funcionando?

Editado: Resolvido! O caminho para o log de consulta lenta estava incorreto, deveria ser /var/log/my.slow.log em vez de /var/log* s */my.slow.log . Obrigado a todos pela ajuda, aprendi muito!

Estou tentando criar uma consulta t-sql que pode determinar se um determinado banco de dados possui ou não instantâneos de banco de dados criados a partir dele.

Por exemplo, se eu fosse criar um instantâneo como este:

CREATE DATABASE [DatabaseA_Snapshot] ON 
(NAME=DatabaseA, FileName='<whatever>') 
AS SNAPSHOT OF [DatabaseA]

Existe uma maneira de consultar a existência desse instantâneo novamente mais tarde? Posso ver que ele aparece em sys.databases, mas não consegui encontrar nenhuma informação que me ajudasse a determinar que é um instantâneo de banco de dados criado a partir do DatabaseA.

O Object Explorer do SQL Server Management Studio coloca-o na pasta 'Database Snapshots', então obviamente há alguma maneira de diferenciá-los dos bancos de dados regulares.

Estamos fazendo um processo de ETL. Quando tudo estiver dito e feito, há um monte de tabelas que devem ser idênticas. Qual é a maneira mais rápida de verificar se essas tabelas (em dois servidores diferentes) são de fato idênticas. Estou falando de esquema e dados.

Posso fazer um hash na tabela por conta própria, como eu seria capaz de fazer em um arquivo individual ou grupo de arquivos - para comparar um com o outro. Temos comparação de dados do Red-Gate, mas como as tabelas em questão contêm milhões de linhas cada, gostaria de algo com um pouco mais de desempenho.

Uma abordagem que me intriga é esse uso criativo da declaração de união . Mas, eu gostaria de explorar a ideia de hash um pouco mais, se possível.

POSTAR RESPOSTA ATUALIZADA

Para qualquer visitante futuro... aqui está a abordagem exata que acabei tomando. Funcionou tão bem que estamos fazendo isso em todas as tabelas de cada banco de dados. Obrigado às respostas abaixo por me apontarem na direção certa.

CREATE PROCEDURE [dbo].[usp_DatabaseValidation]
    @TableName varchar(50)

AS
BEGIN

    SET NOCOUNT ON;

    -- parameter = if no table name was passed do them all, otherwise just check the one

    -- create a temp table that lists all tables in target database

    CREATE TABLE #ChkSumTargetTables ([fullname] varchar(250), [name] varchar(50), chksum int);
    INSERT INTO #ChkSumTargetTables ([fullname], [name], [chksum])
        SELECT DISTINCT
            '[MyDatabase].[' + S.name + '].['
            + T.name + ']' AS [fullname],
            T.name AS [name],
            0 AS [chksum]
        FROM MyDatabase.sys.tables T
            INNER JOIN MyDatabase.sys.schemas S ON T.schema_id = S.schema_id
        WHERE 
            T.name like IsNull(@TableName,'%');

    -- create a temp table that lists all tables in source database

    CREATE TABLE #ChkSumSourceTables ([fullname] varchar(250), [name] varchar(50), chksum int)
    INSERT INTO #ChkSumSourceTables ([fullname], [name], [chksum])
        SELECT DISTINCT
            '[MyLinkedServer].[MyDatabase].[' + S.name + '].['
            + T.name + ']' AS [fullname],
            T.name AS [name],
            0 AS [chksum]
        FROM [MyLinkedServer].[MyDatabase].sys.tables T
            INNER JOIN [MyLinkedServer].[MyDatabase].sys.schemas S ON 
            T.schema_id = S.schema_id
        WHERE
            T.name like IsNull(@TableName,'%');;

    -- build a dynamic sql statement to populate temp tables with the checksums of each table

    DECLARE @TargetStmt VARCHAR(MAX)
    SELECT  @TargetStmt = COALESCE(@TargetStmt + ';', '')
            + 'UPDATE #ChkSumTargetTables SET [chksum] = (SELECT CHECKSUM_AGG(BINARY_CHECKSUM(*)) FROM '
            + T.FullName + ') WHERE [name] = ''' + T.Name + ''''
    FROM    #ChkSumTargetTables T

    SELECT  @TargetStmt

    DECLARE @SourceStmt VARCHAR(MAX)
    SELECT  @SourceStmt = COALESCE(@SourceStmt + ';', '')
            + 'UPDATE #ChkSumSourceTables SET [chksum] = (SELECT CHECKSUM_AGG(BINARY_CHECKSUM(*)) FROM '
            + S.FullName + ') WHERE [name] = ''' + S.Name + ''''
    FROM    #ChkSumSourceTables S

    -- execute dynamic statements - populate temp tables with checksums

    EXEC (@TargetStmt);
    EXEC (@SourceStmt);

    --compare the two databases to find any checksums that are different

    SELECT  TT.FullName AS [TABLES WHOSE CHECKSUM DOES NOT MATCH]
    FROM #ChkSumTargetTables TT
    LEFT JOIN #ChkSumSourceTables ST ON TT.Name = ST.Name
    WHERE IsNull(ST.chksum,0) <> IsNull(TT.chksum,0)

    --drop the temp tables from the tempdb

    DROP TABLE #ChkSumTargetTables;
    DROP TABLE #ChkSumSourceTables;

END

Estou carregando um arquivo de 100 GB via LOAD DATA INFILE. Eu tive um bom sucesso com o MyISAM, algumas horas e pronto.

Estou tentando agora usando o InnoDB. A carga começa rapidamente em mais de 10 MB/s (observando o crescimento do arquivo da tabela, file_per_tableestá ativado).

Mas depois de cerca de 5 GB de dados, ele diminui para o intervalo de 2 a 4 MB/s, quando chego a mais de 20 GB, ele diminui cerca de 2 MB/s.

O tamanho dos buffer pools do InnoDB é 8G. E eu fiz o seguinte antes de executar o comando LOAD DATA INFILE:

SET @@session.sql_log_bin=0;
SET autocommit=0;
SET unique_checks=0;
SET foreign_key_checks=0;
alter table item_load disable keys;
//Run LOAD DATA INFILE....

Não consigo ver a razão pela qual está começando bem e diminuindo ao longo do tempo.

Além disso, usando as mesmas configurações, executei o mesmo comando LOAD DATA INFILE com a tabela usando InnoDB e MyISAM e um conjunto de dados de teste de 5 GB, MyISAM foi 20x mais rápido:

InnoDB:

mysql> LOAD DATA CONCURRENT LOCAL INFILE '/tmp/item' REPLACE INTO TABLE item_load;
Query OK, 2630886 rows affected, 6 warnings (21 min 25.38 sec)
Records: 2630886  Deleted: 0  Skipped: 0  Warnings: 6

MeuISAM:

mysql> LOAD DATA CONCURRENT LOCAL INFILE '/tmp/item' REPLACE INTO TABLE item_load;
Query OK, 2630886 rows affected, 6 warnings (1 min 2.52 sec)
Records: 2630886  Deleted: 0  Skipped: 0  Warnings: 6

Qualquer outra coisa que eu deveria considerar tentar? O mecanismo MyISAM é capaz de manter a taxa de carga muito melhor.

Detalhes adicionais:

• Já tentei carregar os arquivos individualmente, sem diferença.

• Aliás, tenho 150 arquivos de 500MB cada, dentro de cada arquivo as chaves são ordenadas.

• Depois de obter 40 GB durante a noite, 12 horas depois, a taxa de carregamento caiu para 0,5 MB/s, o que significa que a operação é praticamente impossível.

• Não encontrei outras respostas para perguntas semelhantes em outros fóruns, parece-me que o InnoDB não suporta o carregamento de grandes quantidades de dados em tabelas com alguns GB de tamanho.

Alguém pode explicar as principais diferenças?

Qualquer ajuda apreciada.