All perguntas(dba)

Esta é uma pergunta simples para a qual não consigo encontrar a resposta.

Em termos de desempenho, se eu tiver uma WHEREcláusula como a=0 and b=0 and ... z=0, eu obteria algum desempenho se substituísse essa condição por a+b+...+z=0?

Em outras palavras, há algum ganho de desempenho substituindo o seguinte

Select * 
From MyTable 
Where A=0 and B=0 and C=0 and D=0...

Com

Select * 
From MyTable 
Where A+B+C+D=0...

Sei que pode depender de índices, mas, para esse fim, digamos que não existam índices. O operador aritmético (+) funciona melhor que um operador lógico "OU" ou "E"?

Tenho a impressão de que a adição funciona melhor do que várias condições com ANDs ou ORs.

Resultado dos testes

Em uma tabela de 4,2 milhões de linhas

Retornando linhas Onde A=0 B=0 e C=0 -> 351748 Linhas

A adição (A+B+C=0) levou 5 segundos, enquanto as condições lógicas A=0 e B=0 e C=0 levaram 11 segundos.

Por outro lado

Retornando linhas Onde A<>0 B<>0 ou C<>0 -> 3829750 Linhas 58 segundos

Retornando linhas Onde F65+ F67+f64<>0 -> 3829750 Linhas 57 segundos

Para o OR, parece que não há diferença significativa.

Concordo com gbn:

Se A é -1 e B é 1, A+B=0 mas A=0 e B= 0 é falso

e com AMtwo:

ABS(A)+ABS(B)+ABS(C)+ABS(D)... Mesmo que você espere apenas valores positivos, se a coluna aceitar valores negativos, você deve presumir que poderá encontrar um

Os resultados são muito impressionantes, como pensei, parece que a adição é muito mais rápida que os operadores lógicos.

A = Float, B = Dinheiro e C = Float. A consulta utilizada é a mostrada. No meu caso, todos são números positivos. Sem índices. É lógico em minha mente que a adição seja mais rápida do que as condições lógicas!

Qual é o uso de log_bin_trust_function_creators? Além disso, o valor do parâmetro é dinâmico? Isso mudará se eu reiniciar meu serviço MySQL?

Eu tenho duas mesas. Uma é uma tabela de log; outro contém, essencialmente, códigos de cupom que só podem ser usados ​​uma vez.

O usuário precisa poder resgatar um cupom, que inserirá uma linha na tabela de log e marcará o cupom como usado (atualizando a usedcoluna para true).

Naturalmente, há um problema óbvio de condição/segurança de corrida aqui.

Eu fiz coisas semelhantes no passado no mundo do mySQL. Nesse mundo, eu bloquearia ambas as tabelas globalmente, faria a lógica com segurança sabendo que isso só poderia acontecer uma vez por vez e, em seguida, desbloquearia as tabelas assim que terminasse.

Existe uma maneira melhor no Postgres de fazer isso? Em particular, estou preocupado que o bloqueio seja global, mas não precisa ser - eu realmente só preciso ter certeza de que ninguém mais está tentando inserir esse código específico, então talvez algum bloqueio em nível de linha funcione?

Eu queria experimentar o recurso de usuários de banco de dados independente no Banco de Dados SQL do Azure V12, mas estou tendo um problema de autenticação que me parece estranho.

Criei um banco de dados chamado Classifier. Adicionei meu IP às regras de firewall para poder me conectar ao servidor db do Azure do SSMS na minha estação de trabalho. Assim que consegui me conectar via SSMS para administração, tentei adicionar um usuário com uma senha ao banco de dados, assim:

CREATE USER classifier WITH PASSWORD='thepassword'

Também adicionei este usuário às funções de gravador de dados e leitor:

exec sp_addrolemember 'db_datawriter', 'classifier'
exec sp_addrolemember 'db_datareader', 'classifier'

Depois disso, consigo me conectar ao banco de dados com essas credenciais do SSMS:

Mas é aí que as coisas dão errado: eu tentei vários encantamentos de string de conexão diferentes e não consigo me conectar em um aplicativo da Web em que estou trabalhando. Não funcionou no ambiente do Azure, então estou executando em localhost com uma cadeia de conexão para o banco de dados do Azure e ele simplesmente não se conecta. Aqui está a string de conexão que estou usando no momento:

<add name="Classifier" connectionString="Data Source=xxxxxxx.database.secure.windows.net;Initial Catalog=Classifier;User ID=classifier;Password=xxxxxxxxxxxxx;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;" providerName="System.Data.SqlClient"/>

Já tentei redefinir a senha (via SSMS) do usuário e atualizar a string de conexão; Também verifiquei a senha copiando-a diretamente dessa cadeia de conexão e na caixa de diálogo de conexão no SSMS para garantir que não houvesse algum tipo de erro de digitação.

Habilitei a auditoria no servidor de banco de dados do Azure na esperança de obter alguns detalhes sobre o motivo da falha, mas tudo o que recebo é isso:

E é aqui que estou preso. A maior parte do que consegui encontrar por meio de documentação ou blogs indica que a coisa a fazer é examinar os logs do SQL Server para ver qual é o estado real do erro, o que indicaria mais precisamente a natureza da falha, mas como estou lidando com o Azure, não há como fazer isso (até onde eu sei).

O que pode fazer com que o aplicativo falhe onde o SSMS (e o LinqPad e o Visual Studio Server Explorer, incidentalmente) for bem-sucedido?

Isso pode se enquadrar na categoria de opinião, mas estou curioso para saber se as pessoas estão usando o sinalizador de rastreamento 4199 como um parâmetro de inicialização para o SQL Server. Para aqueles que o usaram, em que circunstâncias você experimentou regressão de consulta?

Certamente parece um benefício de desempenho potencial em geral, estou pensando em habilitá-lo globalmente em nosso ambiente de não produção e deixá-lo descansar por alguns meses para descobrir quaisquer problemas.

As correções em 4199 são lançadas no otimizador por padrão em 2014 (ou 2016)? Embora eu entenda o caso de não introduzir alterações inesperadas no plano, parece estranho manter todas essas correções ocultas entre as versões.

Estamos usando 2008, 2008R2 e principalmente 2012.

Eu simplesmente não entendo. Veja esta consulta SQL:

select nchar(65217) -- ﻁ
select nchar(65218) -- ﻂ
select nchar(65219) -- ﻃ
select nchar(65220) -- ﻄ
if nchar(65217) = nchar(65218)
    print 'equal'
if nchar(65217) = nchar(65219)
    print 'equal'
if nchar(65217) = nchar(65220)
    print 'equal'

Com base na relação transitiva , significa que o SQL Server considera todos eles como o mesmo caractere.

No entanto, em outros ambientes, digamos, por exemplo, C#, eles não são os mesmos.

O que estou confuso é:

1. Como funciona a comparação de strings no SQL Server
2. Por que a comparação não se comporta da mesma forma em uma máquina e em uma plataforma, mas em ambientes diferentes
3. Esses 4 caracteres representam um personagem compreensível para humanos. Por que eles são tão abundantes no mapa de caracteres Unicode?

É claro que isso resulta em problemas tremendos, porque estou trabalhando em um aplicativo de processamento de texto e os dados vêm de quase todos os lugares e preciso normalizar o texto antes de processá-lo.

Se eu souber o motivo da diferença, posso encontrar uma solução para lidar com isso. Obrigada.

Sim, estou ciente de que a normalização dos dados deve ser minha prioridade (como está).

1. Tenho uma tabela com 65 colunas armazenando dados de veículos com colunas: used_vehicle, color, doors, mileage, pricee assim por diante, totalizando 65.
2. Agora, posso dividir isso e ter uma Vehicletabela, VehicleInterior, VehicleExterior, VehicleTechnical, VehicleExtra(todos um-para-um com a Vehicletabela principal).

Vamos supor que terei cerca de 5 milhões de linhas (veículos).

On SELECTcom uma WHEREcláusula: O desempenho será melhor pesquisando (ambos os casos indexados pelo menos em IDs):

1. Vehicletabela com 65 colunas ou
2. Vehicletabela com JOINSoutras quatro tabelas (todas com 5 milhões de linhas) para retornar todos os dados relacionados a Vehicle?

(De acordo com o mecanismo de banco de dados, considere PostgreSQL e/ou MySQL).

Aprecia verdadeiramente quaisquer insights detalhados que você possa ter de sua experiência anterior?

As atualizações serão raras, se houver, e as seleções serão principalmente para todas as colunas (página de detalhes do veículo) e informações principais (algumas colunas) para a lista de resultados de pesquisa e, de fato, talvez a melhor solução seja duas tabelas: uma com informações principais (algumas colunas) e a outra tabela com o restante das colunas.

Se eu quiser criar um banco de dados de 5 GB com

CREATE DATABASE [test]
 CONTAINMENT = NONE
 ON  PRIMARY 
( NAME = N'test', FILENAME = N'E:\2012\test.mdf' , SIZE = 5529600KB , FILEGROWTH = 1024KB )
 LOG ON 
( NAME = N'test_log', FILENAME = N'E:\2012\test_log.ldf' , SIZE = 1024KB , FILEGROWTH = 10%)

leva 1 minuto no meu SSD.

Mas quando eu adiciono o usuário do SQL Server aoPerform volume maintenance tasks

leva apenas 1-2 segundos .

Por que é que? Alguém pode me explicar quais são as razões para isso?

Estou tentando migrar uma consulta do Oracle para o SQL Server 2014.

Aqui está minha consulta que funciona muito bem no Oracle:

select
count(distinct A) over (partition by B) / count(*) over() as A_B
from MyTable 

Aqui está o erro que recebi depois de tentar executar esta consulta no SQL Server 2014.

Use of DISTINCT is not allowed with the OVER clause

Alguém sabe qual é o problema? Esse tipo de consulta é possível no SQL Server? Por favor informar.

Este é um tipo de tarefa trivial em meu mundo natal C #, mas ainda não o faço em SQL e prefiro resolvê-lo com base em conjuntos (sem cursores). Um conjunto de resultados deve vir de uma consulta como esta.

SELECT SomeId, MyDate, 
    dbo.udfLastHitRecursive(param1, param2, MyDate) as 'Qualifying'
FROM T

Como deve funcionar

Envio esses três parâmetros para um UDF.
A UDF usa internamente parâmetros para buscar linhas relacionadas <= 90 dias anteriores, de uma exibição.
O UDF percorre 'MyDate' e retorna 1 se for incluído em um cálculo total.
Caso contrário, retornará 0. Nomeado aqui como "qualificação".

o que a udf vai fazer

Liste as linhas em ordem de data. Calcule os dias entre as linhas. O padrão da primeira linha no conjunto de resultados é Hit = 1. Se a diferença for de até 90, então passe para a próxima linha até que a soma das lacunas seja de 90 dias (o 90º dia deve passar) Quando atingido, defina Hit como 1 e redefina a lacuna como 0 Também funcionaria omitir a linha do resultado.

                                          |(column by udf, which not work yet)
Date              Calc_date     MaxDiff   | Qualifying
2014-01-01 11:00  2014-01-01    0         | 1
2014-01-03 10:00  2014-01-01    2         | 0
2014-01-04 09:30  2014-01-03    1         | 0
2014-04-01 10:00  2014-01-04    87        | 0
2014-05-01 11:00  2014-04-01    30        | 1

Na tabela acima, a coluna MaxDiff é a diferença da data na linha anterior. O problema com minhas tentativas até agora é que não posso ignorar a penúltima linha no exemplo acima.

[EDIT]
De acordo com o comentário, adiciono uma tag e também colo o udf que compilei agora. No entanto, é apenas um espaço reservado e não fornecerá resultados úteis.

;WITH cte (someid, otherkey, mydate, cost) AS
(
    SELECT someid, otherkey, mydate, cost
    FROM dbo.vGetVisits
    WHERE someid = @someid AND VisitCode = 3 AND otherkey = @otherkey 
    AND CONVERT(Date,mydate) = @VisitDate

    UNION ALL

    SELECT top 1 e.someid, e.otherkey, e.mydate, e.cost
    FROM dbo.vGetVisits AS E
    WHERE CONVERT(date, e.mydate) 
        BETWEEN DateAdd(dd,-90,CONVERT(Date,@VisitDate)) AND CONVERT(Date,@VisitDate)
        AND e.someid = @someid AND e.VisitCode = 3 AND e.otherkey = @otherkey 
        AND CONVERT(Date,e.mydate) = @VisitDate
        order by e.mydate
)

Tenho outra consulta que defino separadamente que está mais próxima do que preciso, mas bloqueada pelo fato de não poder calcular em colunas com janelas. Eu também tentei um similar que dá mais ou menos a mesma saída apenas com um LAG () sobre MyDate, cercado por um datediff.

SELECT
    t.Mydate, t.VisitCode, t.Cost, t.SomeId, t.otherkey, t.MaxDiff, t.DateDiff
FROM 
(
    SELECT *,
        MaxDiff = LAST_VALUE(Diff.Diff)  OVER (
            ORDER BY Diff.Mydate ASC
                ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
    FROM 
    (
        SELECT *,
            Diff =  ISNULL(DATEDIFF(DAY, LAST_VALUE(r.Mydate) OVER (
                        ORDER BY r.Mydate ASC
                            ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING), 
                                r.Mydate),0),
            DateDiff =  ISNULL(LAST_VALUE(r.Mydate) OVER (
                        ORDER BY r.Mydate ASC
                            ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING), 
                                r.Mydate)
        FROM dbo.vGetVisits AS r
        WHERE r.VisitCode = 3 AND r.SomeId = @SomeID AND r.otherkey = @otherkey
    ) AS Diff
) AS t
WHERE t.VisitCode = 3 AND t.SomeId = @SomeId AND t.otherkey = @otherkey
    AND t.Diff <= 90
ORDER BY
    t.Mydate ASC;