All perguntas(dba)

Gostaria de particionar uma tabela com mais de 1 milhão de linhas por intervalo de datas. Como isso é feito normalmente sem exigir muito tempo de inatividade ou correr o risco de perder dados? Aqui estão as estratégias que estou considerando, mas aberto a sugestões:

1. A tabela existente é o mestre e os filhos herdam dela. Com o tempo, mova os dados do mestre para o filho, mas haverá um período de tempo em que alguns dos dados estarão na tabela mestra e outros nos filhos.

2. Crie uma nova tabela mestre e filhas. Crie uma cópia dos dados na tabela existente nas tabelas filhas (para que os dados residam em dois locais). Depois que as tabelas filhas tiverem os dados mais recentes, altere todas as inserções para apontar para a nova tabela mestre e exclua a tabela existente.

Estou usando o SQL SERVER 2008 R2

Acabei de encontrar o APPLY no SQL e adorei como ele resolve problemas de consulta para tantos casos,

Muitas das tabelas que eu estava usando 2 left join para obter o resultado, consegui entrar em 1 outer apply.

Eu tenho uma pequena quantidade de dados em minhas tabelas de banco de dados locais e, após a implantação, o código deve ser executado em dados pelo menos 20 vezes grandes.

Estou preocupado que a aplicação externa possa demorar mais do que as 2 condições de junção esquerda para grande quantidade de dados,

Alguém pode dizer como exatamente o apply funciona e como isso afetará o desempenho em dados muito grandes, se possível algumas relações proporcionais com o tamanho de cada tabela como proporcional a n1^1 ou n1^2 ... onde n1 é o número de linhas na tabela 1.

Aqui está a consulta com 2 joins à esquerda

select EC.*,DPD.* from Table1 eC left join
  (
   select member_id,parent_gid,child_gid,LOB,group_gid,MAX(table2_sid) mdsid from Table2
   group by member_id,parent_gid,child_gid,LOB,group_gid

  ) DPD2 on DPD2.parent_gid = Ec.parent_gid
        AND DPD2.child_gid = EC.child_gid
        AND DPD2.member_id = EC.member_id
        AND DPD2.LOB = EC.default_lob
        AND DPD2.group_gid = EC.group_gid
  left join
  Table2 dpd on dpd.parent_gid = dpd2.parent_gid 
            and dpd.child_gid = dpd2.child_gid
            and dpd.member_id = dpd2.member_id 
            and dpd.group_gid = dpd2.group_gid 
            and dpd.LOB = dpd2.LOB
            and dpd.table2_sid = dpd2.mdsid

Aqui está a consulta com aplicação externa

select * from Table1 ec   
OUTER APPLY (
      select top 1 grace_begin_date,retroactive_begin_date,Isretroactive
                    from Table2 DPD 
                    where DPD.parent_gid = Ec.parent_gid
                    AND DPD.child_gid = EC.child_gid
                    AND DPD.member_id = EC.member_id
                    AND DPD.LOB = EC.default_lob
                    AND DPD.group_gid = EC.group_gid
                    order by DPD.table2_sid desc
     ) DPD 

No Postgres, as consultas preparadas e as funções definidas pelo usuário são equivalentes a um mecanismo de proteção contra injeção de SQL ?
Existem vantagens particulares em uma abordagem sobre a outra?

Eu tenho uma VM com endereço IP 192.168.0.192 executando postgreSQL.

se eu especificar

listen_addresses = '*'

então posso me conectar de outra VM em 192.168.0.191 e de localhost.

Mas não consigo usar uma lista para dizer ao postgreSQL para usar esses dois endereços. Se eu alterar listen_addresses para uma lista:

listen_addresses = '192.168.0.191, localhost'

então não consigo mais conectar de 192.168.0.191.

Percebo que quase todos os exemplos no stackexchange definem listen_addresses como '*'. Isso ocorre porque o formulário de lista não funciona?

Qual é a diferença entre lote SQL, instrução T-SQL e chamada de procedimento remoto?
Como posso saber se parte do código T-SQL é um lote ou instrução?

Portanto, tivemos um processo de longa duração causando problemas esta manhã (30 segundos + tempo de execução). Decidimos verificar se a detecção de parâmetros era a culpada. Portanto, reescrevemos o proc e definimos os parâmetros de entrada para variáveis ​​para impedir a detecção de parâmetros. Uma abordagem testada/verdadeira. Bam, o tempo de consulta melhorou (menos de 1 segundo). Ao olhar para o plano de consulta, as melhorias foram encontradas em um índice que o original não estava usando.

Apenas para verificar se não obtivemos um falso positivo, fizemos um dbcc freeproccache no proc original e rodamos novamente para ver se os resultados aprimorados seriam os mesmos. Mas, para nossa surpresa, o proc original ainda rodava devagar. Tentamos novamente com um WITH RECOMPILE, ainda lento (tentamos uma recompilação na chamada para o proc e dentro do próprio proc). Até reiniciamos o servidor (caixa de desenvolvimento obviamente).

Então, minha pergunta é esta... como o sniffing de parâmetro pode ser o culpado quando obtemos a mesma consulta lenta em um cache de plano vazio... não deveria haver nenhum parâmetro para snif???

Em vez disso, estamos sendo afetados pelas estatísticas da tabela não relacionadas ao cache do plano. E se assim for, por que definir os parâmetros de entrada para variáveis ​​ajudaria?

Em testes adicionais, também descobrimos que a inserção de OPTION (OPTIMIZE FOR UNKNOWN) nas partes internas do proc DID obteve o plano aprimorado esperado.

Então, alguns de vocês mais espertos do que eu, podem dar algumas pistas sobre o que está acontecendo nos bastidores para produzir esse tipo de resultado?

Em outra observação, o plano lento também é abortado antecipadamente com razão GoodEnoughPlanFound, enquanto o plano rápido não tem motivo de interrupção antecipada no plano real.

Resumindo

• Criando variáveis ​​a partir de parâmetros de entrada (1 seg)
• com recompilação (30+ seg)
• dbcc freeproccache (mais de 30 segundos)
• OPÇÃO (OPTIMIZE FOR UKNOWN) (1 seg)

ATUALIZAR:

Veja o plano de execução lenta aqui: https://www.dropbox.com/s/cmx2lrsea8q8mr6/plan_slow.xml

Veja o plano de execução rápida aqui: https://www.dropbox.com/s/b28x6a01w7dxsed/plan_fast.xml

Nota: tabela, esquema, nomes de objetos alterados por motivos de segurança.

Estou usando o PostgreSQL 9.1 e tenho uma tabela de usuários com uma logincoluna.

nomes de login diferenciam maiúsculas de minúsculas, por exemplo, Bob, Mike, john. Eu gostaria de transformar todos esses registros em minúsculas. Como eu posso fazer isso?

Eu gostaria de usar a segurança integrada com meu aplicativo interno que está todo em um domínio. Infelizmente, nunca consegui fazer isso funcionar bem. Gostaria de atribuir a um grupo inteiro do Exchange (Active Directory) uma função no SQL Server para acesso de leitura/gravação a determinadas tabelas. Dessa forma eu não precisaria criar um operador sempre que alguém fosse contratado ou deletar um operador sempre que alguém fosse demitido. Isso é possível? Que passos eu tomaria para fazer isso?

Estou começando a aprender os planos de execução e estou confuso sobre como exatamente uma correspondência de hash funciona e por que ela seria usada em uma junção simples:

select Posts.Title, Users.DisplayName
From Posts JOIN Users on
Posts.OwnerUserId = Users.Id
OPTION (MAXDOP 1)

Pelo que entendi, os resultados da verificação de índice superior tornam-se capazes de hash e cada linha na verificação clusterizada de índice inferior é pesquisada. Eu entendo como as tabelas de hash funcionam pelo menos até certo ponto, mas estou confuso sobre quais valores são exatamente hash em um exemplo como este.

O que faria sentido para mim é que o campo comum entre eles, o id, seja hash - mas se for esse o caso, por que hash um número?

No MySQL, é melhor sempre permitir nulos, a menos que você saiba que um campo é obrigatório, ou sempre usar Not Null, a menos que saiba que um campo conterá nulos? Ou não importa?

Eu sei que em alguns DBMSs eles dizem para usar Not Nullo máximo possível porque permitir nulos requer um bit extra (ou byte?) Por registro para armazenar o status Nulo.