All perguntas(dba)

Tenho a infraestrutura mostrada no diagrama abaixo.

O Servidor Web 1 está fora do domínio do Windows. O Web Server 2 está dentro do domínio do Windows.

SQL Server 1 e 2 estão dentro do domínio.

Há uma conexão de servidor vinculada do SQL Server 1 ao SQL Server 2.

Ambos os servidores SQL aceitam apenas a autenticação do Windows, não a autenticação SQL.

Ambos os SQL Servers possuem uma configuração Kerberos SPN com delegação irrestrita.

Um usuário de domínio no Web Server 2 tem um login SQL configurado no SQL Server 1 e no SQL Server 2 e pode consultar dados no SQL Server 1 e no SQL Server 2 por meio do servidor vinculado.

Um usuário local no Servidor Web 1 tem um logon local com o mesmo nome e senha configurado no SQL Server 1 e no SQL Server 2 e pode consultar dados no SQL Server 1, mas não no SQL Server 2 por meio do servidor vinculado. O seguinte erro é fornecido no log do SQL Server:

Falha no login do usuário 'NT AUTHORITY\ANONYMOUS LOGON'. Motivo: Não foi possível encontrar um login correspondente ao nome fornecido.

A questão: o Web Server 1, fora do domínio do Windows, pode consultar dados com êxito do SQL Server 2 por meio da conexão do Linked Server no SQL Server 1? Se sim, como?

Estou tentando criar uma configuração de replicação lógica onde tenho um único banco de dados grande com réplicas de leitura menores ramificadas filtradas em um subid.

Por exemplo, se eu quisesse um subconjunto de itens enviados para ler réplicas de um cliente específico, poderia ter uma tabela no nó de replicação definida por:

CREATE TABLE public.item (
       id text PRIMARY KEY, 
       data text, 
       customer_id integer
       );

Posso ou não ter sub_idno nó de assinatura (não é um detalhe do disjuntor). No nó de replicação, posso adicionar dados à tabela como quiser até criar a PUBLICAÇÃO assim:

CREATE PUBLICATION customer_items FOR TABLE public.item (
       id, 
       data
       ) WHERE (customer_id = 3);

Neste ponto, tento algo como

UPDATE public.item SET
    customer_id = 3 WHERE 
    id = 'GLAMDRING';

Recebo o erro SQL state: 42P10, recebo um erro ou ..:

ERROR:  cannot update table "item"
DETAIL:  Column used in the publication WHERE expression is not part of the replica identity.
STATEMENT: UPDATE public.item SET
    customer_id = $1::integer WHERE 
    id = 'GLAMDRING';

A questão aqui parece semelhante . Estou recriando a tabela para remover qualquer instrução ALTER TABLE id, conforme sugerido lá, mas tenho o mesmo resultado.

A maioria dos exemplos que posso encontrar que usam essa função de replicação lógica nunca faz uso da cláusula WHERE. Estou pensando que entendi mal o significado por trás desse recurso ou encontrei um bug/limitação.

Observação: estou ciente de que meu exemplo parece trivial e deve ser resolvido de outra maneira. Esta é uma versão simplificada do meu problema por uma questão de brevidade.

Atualizar

Tentar usar o índice exclusivo, como sugerido, quase me levou até lá.

CREATE UNIQUE INDEX id_customerid_idx ON public.item ((customer_id || id));

Mas quando tento criar uma PUBLICAÇÃO útil..

CREATE PUBLICATION customer_items FOR TABLE public.item (id, data) WHERE (customer_id || id LIKE '3%');

Novo erro:

ERROR:  User-defined or built-in mutable functions are not allowed.invalid publication WHERE expression 

ERROR:  invalid publication WHERE expression
SQL state: 0A000
Detail: User-defined or built-in mutable functions are not allowed.
Character: 377

Talvez meu caso de uso seja um pouco selvagem ou eu precise repensar a lógica do meu aplicativo para trabalhar com essas restrições. Estou sentindo falta de um trabalho óbvio por aqui?

Eu tenho uma mesa plana simples com aprox. 18 milhões de linhas. Agora preciso contar um campo com o operador ILIKE. Esta consulta retorna aproximadamente meio milhão de linhas. Quando o item de pesquisa é "mais estreito" (uma string de pesquisa mais longa), tudo é rápido.

SELECT count(*)::int
FROM "KbaData" AS k
WHERE k."KbaKey" ILIKE '1313%'

mas isso dura 30 anos, muito tempo. O índice neste campo é definido como:

CREATE INDEX IF NOT EXISTS "IX_KbaData_KbaKey"
    ON public."KbaData" USING gin
    ("KbaKey" COLLATE pg_catalog."default" gin_trgm_ops)
    TABLESPACE pg_default;

A análise retorna isto:

"Finalize Aggregate  (cost=3370561.68..3370561.69 rows=1 width=4) (actual time=35821.869..35832.270 rows=1 loops=1)"
"  ->  Gather  (cost=3370561.46..3370561.67 rows=2 width=8) (actual time=35821.690..35832.235 rows=3 loops=1)"
"        Workers Planned: 2"
"        Workers Launched: 2"
"        ->  Partial Aggregate  (cost=3369561.46..3369561.47 rows=1 width=8) (actual time=35787.156..35787.158 rows=1 loops=3)"
"              ->  Parallel Seq Scan on ""KbaData"" k  (cost=0.00..3364441.38 rows=2048033 width=0) (actual time=104.308..35644.469 rows=1498715 loops=3)"
"                    Filter: (""KbaKey"" ~~* '1313%'::text)"
"                    Rows Removed by Filter: 3271997"
"Planning Time: 0.231 ms"
"JIT:"
"  Functions: 14"
"  Options: Inlining true, Optimization true, Expressions true, Deforming true"
"  Timing: Generation 1.512 ms, Inlining 200.964 ms, Optimization 62.820 ms, Emission 48.232 ms, Total 313.528 ms"
"Execution Time: 35832.920 ms"

Como posso fazer isso melhor?

Eu tenho um banco de dados MySQL, por exemplo,

Estou construindo carregamento infinito em ambas as direções.

Digamos que minha recuperação inicial seja SELECT * FROM table ORDER BY Purchase_At DESC LIMIT 3e retorne os ID 1, 3 e 5.

Se eu quiser carregar alguma coisa antes do ID 1, eu faço SELECT * FROM table WHERE Purchase_At < '2023-12-01' ORDER BY Purchase_At DESC LIMIT 3?

E vice-versa, carregando qualquer coisa depois das 5, eu faço SELECT * FROM table WHERE Purchase_At > '2023-12-01' ORDER BY Purchase_At DESC LIMIT 3?

Como você pode ver, há chances de encontrar dados repetidos, pois a ordenação de vários registros com o mesmo valor não é confiável. Eu não posso fazer WHERE ID < 1ou WHERE ID > 5também.

Não posso usar a consulta de pagamento como LIMITou OFFSETporque durante a visualização do usuário, novos registros serão adicionados e isso atrapalhará a paginação.

Purchase_At é algo que o usuário inseriu através de um selecionador de data para a data de recebimento e pronto, não há milissegundo etc... Ano, Mês e Dia é tudo que tenho. No meu caso, poderia haver usuário com 10 recibos no mesmo dia. Se eu paginasse 3 por página, como posso garantir que meu carregamento infinito não produza dados repetidos?

Para facilitar a compreensão da minha pergunta, pense em um sistema de chat do Facebook. Onde o usuário rola para baixo para carregar novas mensagens e rola para cima para carregar mensagens antigas. Como posso conseguir o mesmo sabendo apenas que meu tipo pode ter vários valores Purchase_At com apenas ano, mês e dia.

Eu tenho os seguintes exemplos de predicados XE:

Amostra 1:

Duration>1000000
AND cputime>1000
OR logicalreads>25000

Amostra 2:

Duration>1000000
OR cputime>1000
AND logicalreads>25000

Entendo que ocorre curto-circuito, mas como funciona a lógica sem a presença de colchetes?

Para a amostra 1 é:

(A and B) or C
A and (B or C)

Para a amostra 2 é:

A or (B and C)
(A or B) and C

O Plan Cache e o Query Store não são iguais, mesmo para a mesma consulta . Ao procurar informações de desempenho ou monitorar informações sobre uma consulta específica ou conjunto de consultas relacionadas, quais são as vantagens/desvantagens de cada uma?

A impressão geral que minha pesquisa on-line indica é que o Query Store pode ser consultado mais rapidamente que o Plan Cache (não sei por que) e que suas entradas tendem a durar muito mais tempo (isso é configurável), mas não encontrei nada dito sobre situações em que o Plan Cache é superior ao Query Store.

Suponha que eu não me importe com os recursos introduzidos pelo SQL Server 2017 e 2022 que usam o Query Store para ajuste automático de desempenho. Em vez disso, suponha que estou comparando o Query Store e o Plan Cache para fins de tarefas que ambos podem realizar.

Habilitar o Query Store pode trazer benefícios de desempenho, principalmente a partir do SQL Server 2022, mas e quanto aos custos? A documentação insiste que os custos são pequenos, mas quero provas no meu próprio sistema. Posso consultar os DMVs para descobrir quanto espaço em disco está usando por banco de dados, mas isso não é suficiente. Como posso medir os custos de desempenho da ativação (e utilização) do Query Store? Além disso, de quais outros custos devo estar ciente?

Este artigo é uma boa tentativa, mas foi publicado enquanto o Query Store ainda estava em desenvolvimento. Portanto, está presumivelmente desatualizado. Na verdade, estes dois artigos de Erin Stellato sugerem que melhorias significativas de desempenho foram feitas ao longo do tempo. No entanto, ainda dizem muito pouco sobre quais são realmente os custos.

Claramente, falta uma peça na minha compreensão do OLTP na memória. Suponha que eu tenha uma tabela com otimização de memória configurada para persistir esquema e dados. Dado que essas tabelas sempre residem na RAM, como seus dados sobrevivem à reinicialização do servidor? Examinei a documentação, mas não me lembro de ter visto nenhuma menção sobre como ou quando os dados são movidos para o disco. Na verdade, até onde eu sei, o objetivo do hekaton é que eles não residem no disco.

Simplesmente perdi uma parte da documentação?

Temos uma tabela em um banco de dados SQL do Azure que costumava ter uma coluna nvarchar(max) armazenando arquivos PDF. (As maravilhas dos desenvolvedores externos.) A mesa cresceu para 156 GB. Possui 476.000 linhas. Depois de mudar a lógica, não precisamos mais da coluna pdf. A única maneira razoável de se livrar dos dados contidos nela era descartar a coluna e recriá-la (caso algum processo estranho ainda estivesse fazendo referência a ela).

No entanto, o tamanho da tabela ainda é relatado como 156 GB. A tabela de backup que acabei de criar (SELECT INTO) tem 128 MB, então esse parece ser o tamanho real dos dados.

Deixei uma reconstrução de índice (ONLINE) ser executada durante a noite no índice PK clusterizado. Ele falhou com um erro de TCP entre 8 e 12 horas. O índice ainda está 95% fragmentado, o tamanho ainda é relatado como 156 GB.

Existe uma explicação para que isso seja tão lento? Existe uma maneira melhor? Banco de dados de produção, tabela usada por um site, tem que estar acessível, então não pode fazer isso OFFLINE a menos que demore menos de 10 minutos - o que ninguém pode garantir.

Posso simplesmente construir todos os índices na tabela de backup, eliminar a tabela original e renomear o backup? Isso parece arriscado (pequeno risco de perder um registro criado na hora errada).

Estou tentando fazer o Azure perceber que não é mais usado. Alocado, estou bem com isso. Usado, nem tanto:

A tabela em questão:

Novamente, o problema não é o espaço reservado, mas o espaço usado.

Estou trabalhando em alguma otimização de código PHP e, enquanto procuro, encontro algumas instruções SELECT com as seguintes condições:

WHERE `date_exported` = '0000-00-00 00:00:00' OR `date_exported` IS NULL

Isso me faz pensar se a mesma instrução funcionará da mesma forma com apenas uma condição: a comparação com NULL ou a comparação com um datetime "inválido".

Acrescentarei ainda: usando MySQL Workbench e Datagrip (ou o equivalente de ferramentas como PhpStorm) não consigo ver a coluna com NULLbut 0000-00-00 00:00:00. Não tenho certeza se isso é uma coisa de configuração ou se deveria ser assim.

Este é o MySQL 5.7 e não tenho permissão para verificar itens de configuração ou insights sobre como esta instância está configurada.

Tentei definir um playground aqui , mas não me permite adicionar uma coluna 0000-00-00 00:00:00NULLdatetime

O SQL_MODEé definido da seguinte forma:

NO_ZERO,IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION

Nota: é 0000-00-00 00:00:00inválido?