All perguntas(dba)

Temos 8 processos, cada um processando um conjunto separado de dados de uma tabela via cursor, para que várias CPUs possam ser usadas para iterar pelos dados. Isso é usado para migração de dados, portanto, neste ponto, a máquina do servidor não está sendo usada para mais nada.

Ocasionalmente, esse processo trava com o SQL voltando para efetivamente 0 uso da CPU. Cada um desses processos fica preso no estado WAITFOR, subindo até 30 segundos e voltando para 0 novamente. Não temos o comando WAITFOR em nosso SQL ou no lado do código, e o SQL não me diz o que está esperando no Activity Monitor ou nos DMVs. Parece acontecer mais em máquinas com recursos de menor especificação, mas sinto que o SQL deve eventualmente parar de esperar pela CPU quando o uso da CPU diminuir.

Estou faltando alguma coisa aqui, existe alguma maneira de desbloquear esses processos?

Minha pergunta está relacionada a um incidente de produção em que foi necessário substituir um Postgres de baixo desempenho VIEWsob carga. Tentamos inúmeras vezes redefinir o VIEWusing CREATE OR REPLACE; isso não foi bem-sucedido porque a consulta DDL foi bloqueada por muitas outras SELECTconsultas. Então, pouco antes de mudarmos o banco de dados de produção para uma réplica (movimento desesperado), tentamos DROP e pareceu ter sucesso quase imediatamente. Pudemos então criar a visualização. Este incidente tornou-se um tanto controverso porque não conseguimos encontrar nenhuma documentação que diferencie o comportamento de bloqueio de CREATE OR REPLACE de DROP e depois CREATE. Alguns estão se perguntando: isso realmente aconteceu? Na esperança de obter alguns insights daqueles familiarizados com os componentes internos do Postgres.

Estou tentando entender isso.

Os lotes cassandra são sempre atômicos e, se o lote modificar apenas uma única partição de uma única tabela, esse lote também será isolado.

mas e os lotes de várias tabelas particionados pela mesma chave? assuma estas tabelas:

orders (
    order_id pk,
    created_at,
    user_id
)

order_items (
    order_id,
    product_id,
    quantity,
    primary key (order_id, product_id)
)

ambas as tabelas são particionadas pela mesma chave. se eu quiser criar um pedido atomicamente, digamos order_id = 123, assim:

begin batch 
  insert into orders ... (123) 
  insert into order_items .... where order_id = 123
  insert into order_items .... where order_id = 123
apply batch 

este lote é atômico e isolado? desde que a partição da tabela de pedidos para 123 e a partição da tabela order_items para 123 residam no mesmo nó.

Emitir

Os desenvolvedores da mesma equipe são membros de um Windows_Group. Esses desenvolvedores criam empregos que cada um possui. Somente o proprietário pode editar o trabalho, portanto não podem trabalhar juntos no mesmo trabalho. Por causa disso, acabamos com muitas versões do mesmo trabalho.

Ideia

Posso mapear [Domain\Windows_Group]para [Domain\Windows_User]que os trabalhos precisem ser executados e pertencentes à conta [Domínio\Windows_User]?

Código de amostra

O que eu estaria perdendo ou arriscando?

USE [master]
GO
CREATE LOGIN [DOMAIN\Windows_Group] FROM WINDOWS WITH DEFAULT_DATABASE=[master]
GO
USE [msdb]
GO
CREATE USER [Domain\Windows_User] FOR LOGIN [DOMAIN\Windows_Group]
ALTER ROLE [SQLAgentUserRole] ADD MEMBER [Domain\Windows_User]
GO

Eu só faria isso em nosso ambiente de desenvolvimento. Os desenvolvedores não têm db_owner nem acesso a nenhuma função de segurança.

Teste

Isso será usado em um novo servidor e é apenas uma teoria no momento, então ainda não tenho desenvolvedores para testar.

Procurando por novos olhos sobre isso, estou executando o comando no sqlite3 interativo e não consigo ver o problema. Aqui está o código:

CREATE TABLE Personas(
    PersonID INTEGER NOT NULL PRIMARY KEY,
    FirstNameAtBirth    TEXT,
    LastNameAtBirth     TEXT,
    MidNameAtBirth      TEXT,
    discordID           TEXT,
    githubID            TEXT
);

^ Executa com sucesso,

CREATE TABLE Conversations(
    ConvoID INTEGER NOT NULL PRIMARY KEY,
    FOREIGN KEY(PersonID) REFERENCES Personas(PersonID),
    BodyText            TEXT,
    Timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    Reactions           TEXT
);

^ falha com Error: in prepare, unknown column "PersonID" in foreign key definition (1)
estou em um banco de dados ativo, configurei PRAGMA foreign_keys=ON;antes de qualquer transação, alguma ideia de onde está o problema?

Estou tentando adicionar uma sessão de Eventos Estendidos para rastrear eventos de conclusão de backup .

Estou fazendo isso como um precursor da atuação RESTORE HEADERONLY ... LOADHISTORYno nó secundário de um Grupo de Disponibilidade com a intenção de que ambos os nós AG tenham detalhes precisos nas msdb.dbo.backupsettabelas relacionadas. Grupos de Disponibilidade Contidos não são uma opção, pois estamos usando o SQL Server 2019. Também estamos usando Grupos de Disponibilidade Distribuídos, o que exclui AGs Contidos, portanto, mesmo que pudéssemos atualizar para o SQL Server 2022, os AGs Contidos ainda não ajudariam.

A definição do Evento Estendido é:

CREATE EVENT SESSION [backup_finished]
ON SERVER 
ADD EVENT [D5149520-6282-11DE-8A39-0800200C9A66].[sqlserver].[backup_restore_progress_trace]
(
    ACTION
    (
          [sqlserver].[client_app_name]
        , [sqlserver].[client_hostname]
        , [sqlserver].[database_name]
        , [sqlserver].[nt_username]
        , [sqlserver].[server_principal_name]
        , [sqlserver].[session_id]
        , [sqlserver].[sql_text]
    )
    WHERE 
    (
        /* this is the database name where the BACKUP operation took place, not the database being backed up. */
            [CE79811F-1A80-40E1-8F5D-7445A3F375E7].[sqlserver].[database_name] = N'maintenance' 
        /* this is the name of the database that was backed up */
        AND [database_name] = N'<database_of_interest>'
        /* 'Backup' or 'Restore' */
        AND [operation_type] = N'Backup'
        /* 
            0 -> Information of major steps in the operation
            1 -> Verbose I/O related information 
        */
        AND [trace_level] = 0 
        AND 
        (
            /* the trace_message contains one or more characters at the end */
               [trace_message] LIKE N'BACKUP DATABASE finished%'
            OR [trace_message] LIKE N'BACKUP LOG finished%'
        )
    )
)
WITH
(
      MAX_MEMORY = 4096 KB
    , EVENT_RETENTION_MODE = ALLOW_SINGLE_EVENT_LOSS
    , MAX_DISPATCH_LATENCY = 30 SECONDS
    , MAX_EVENT_SIZE = 0 KB
    , MEMORY_PARTITION_MODE = NONE
    , TRACK_CAUSALITY = OFF
    , STARTUP_STATE = OFF
);
GO

[D5149520-6282-11DE-8A39-0800200C9A66]é o GUID do módulo para sqlmin.dll, que contém o código do [backup_restore_progress_trace]Evento Estendido.

[CE79811F-1A80-40E1-8F5D-7445A3F375E7]é o GUID do módulo para sqllang.dll, que contém a maior parte do [sqlserver]código do Evento Estendido.

Na cláusula where, tenho dois predicados para [database_name]; o primeiro [CE79811F-1A80-40E1-8F5D-7445A3F375E7].[sqlserver].[database_name] = N'maintenance' limita os eventos capturados a instruções que foram executadas no contexto do maintenancebanco de dados. Esse predicado é totalmente qualificado com o GUID do módulo para diferenciá-lo do [database_name]nome do campo de evento com nome idêntico.

Os predicados [database_name], [operation_type], [trace_level]e [trace_message]não são totalmente qualificados porque não consigo determinar como qualificá-los totalmente.

Tentei qualificar os predicados não qualificados com todos os GUIDs de módulo que encontrei, mas nenhum deles resolveu, retornando este erro quando tento criar o Evento Estendido:

Msg 25706, Nível 16, Estado 8, Linha 62
O atributo do evento ou origem do predicado, "6D503F55-3041-4A62-BB8C-57C3CF081B7B.sqlserver.database_name", não foi encontrado.
Msg 15151, Nível 16, Estado 22, Linha 105
Não é possível alterar a sessão do evento 'backup_finished' porque ela não existe ou você não tem permissão.

A lista de módulos e seus guias estão listados nesta consulta:

SELECT 
      [module_guid] = QUOTENAME([dxp].module_guid)
    , [package_name] = QUOTENAME([dxp].[name])
    , [module_file_name] = RIGHT([dolm].[name], CHARINDEX(N'\', REVERSE([dolm].[name])) - 1)
FROM 
    [sys].[dm_xe_packages] [dxp]
    INNER JOIN [sys].[dm_os_loaded_modules] [dolm] ON [dxp].[module_address] = [dolm].[base_address]
ORDER BY 
    [dxp].[name];

Resultados do meu servidor:

Alguém sabe o que devo usar para qualificar totalmente os predicados não qualificados?

Temos uma tabela no banco de dados principal que está sendo replicada logicamente para outro banco de dados chamado SOR. Precisamos renomear esta tabela e adicionar várias tabelas à publicação no banco de dados principal. Eu tentei esse procedimento

1. desabilitar o assinante no SOR DB
2. renomear a tabela (de recebimento) no banco de dados SOR
3. renomeie a tabela no banco de dados principal, adicione também as tabelas à publicação
4. reativar o assinante no SOR DB
5. atualizar a assinaturaALTER SUBSCRIPTION my_subscription REFRESH PUBLICATION WITH (copy_data=false);

Esperei que o slot de replicação no banco de dados principal fosse liberado e, em seguida, verifiquei a contagem de registros. O banco de dados SOR perdeu alguns dados nesta janela de tempo. Existe uma maneira perfeita de renomear uma tabela na replicação lógica sem perder dados do lado do assinante? Ajudaria (copy_data=true)?

Obrigado !

mais alguns detalhes:

1. usamos PG 14 no AWS RDS
2. O motivo dessa mudança é que estamos migrando uma tabela pai-filho para uma tabela particionada
3. A referida tabela (a ser renomeada) tem cerca de 6 TB, e o banco de dados é nosso banco de dados de produção ativo, portanto, gostaríamos de evitar copiar esta tabela do zero.

Suponha que temos a seguinte tabela:

CREATE TABLE names(
id SERIAL NOT NULL,
CONSTRAINT names__pk PRIMARY KEY(id),
name TEXT NOT NULL,
CONSTRAINT names__name__unq UNIQUE(name)
);

INSERT INTO names(name) 
VALUES('apple')
ON CONFLICT(name) DO NOTHING
RETURNING id;

Quando uma linha não existe, RETURNINGa cláusula funciona, mas se já existir uma linha, a consulta não retorna nada. Existe uma maneira de modificar a consulta para que ela sempre retorne o campo id?

Começou a receber mensagens de erro após a desinstalação PSe instalação do novo módulo SqlServerao avaliar políticas em servidores remotos usando Servidores Registrados e Invoke-PolicyEvaluationcmdlet. Anteriormente, funcionava bem com o PSmódulo antigo, mas o novo módulo substituto requer TrustServerCertificate=Trueum parâmetro que está faltando na sintaxe de Invoke-PolicyEvaluation . A mensagem de erro é:

Uma conexão foi estabelecida com sucesso com o servidor, mas ocorreu um erro durante o processo de login. (provedor: Provedor SSL, erro: 0 - A cadeia de certificados foi emitida por uma autoridade que não é confiável

Como posso fazer funcionar novamente?
Obrigado

Tenho um banco de dados Oracle 19c (19.0.0.0.0) e duas tabelas com muitas colunas, mencionarei apenas as relevantes:

tabela 1:

• data de criação
• caractere contact_key (96 bytes)

mesa 2:

• caractere contact_key (96 bytes)
• csi_tfid varchar2(300 bytes)

table1 tem 210 milhões de linhas e é particionada anualmente. table2 possui 6,8 milhões de registros e não é particionada.

A consulta a seguir é executada muito rapidamente, em torno de 0,05 a 0,1 segundo:

select * from table1 m, table2 c
where
c.contact_key = m.contact_key
and c.csi_tfid = '1234567';

Mas assim que adiciono uma condição where para obter apenas os últimos registros (o que é relevante para a aplicação), a velocidade de execução cai para 1 minuto, ou até mais lenta:

select * from table1 m, table2 c
where
c.contact_key = m.contact_key
and c.csi_tfid = '1234567'
and m.createtime >= (sysdate-30);

Tentei colocar uma data codificada lá como to_date('2024-04-09', 'YYYY-MM-DD'), mesmo resultado.

Tenho índices individuais em todas as colunas desta consulta:

tabela 1:

• ik_table1_contact_k não exclusivo
• ik_table1_createtime não exclusivo

mesa 2:

• ik_table2_contact_key único
• ik_table2_csi_tfid não exclusivo

Tentei adicionar índice composto a ambas as tabelas, para incluir contact_key e createtime (para tabela1) e contact_key e csi_tfid (para tabela2), aparentemente sem efeito.

Para a consulta rápida, a Oracle gera este plano:

Plan hash value: 323565418
 
-----------------------------------------------------------------------------------------------------------------------------------
| Id  | Operation                                   | Name                | Rows  | Bytes | Cost (%CPU)| Time     | Pstart| Pstop |
-----------------------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                            |                     |     3 |  1857 |   118   (0)| 00:00:01 |       |       |
|   1 |  NESTED LOOPS                               |                     |     3 |  1857 |   118   (0)| 00:00:01 |       |       |
|   2 |   TABLE ACCESS BY INDEX ROWID BATCHED       | TABLE2              |     3 |   966 |     7   (0)| 00:00:01 |       |       |
|*  3 |    INDEX RANGE SCAN                         | IK_TABLE2_CSI_TFID  |     3 |       |     3   (0)| 00:00:01 |       |       |
|   4 |   PARTITION RANGE ALL                       |                     |     1 |   297 |    37   (0)| 00:00:01 |     1 |    12 |
|   5 |    TABLE ACCESS BY LOCAL INDEX ROWID BATCHED| TABLE1              |     1 |   297 |    37   (0)| 00:00:01 |     1 |    12 |
|*  6 |     INDEX RANGE SCAN                        | IK_TABLE1_CONTACT_K |     1 |       |    36   (0)| 00:00:01 |     1 |    12 |
-----------------------------------------------------------------------------------------------------------------------------------
 
Predicate Information (identified by operation id):
---------------------------------------------------
 
   3 - access("C"."CSI_TFID"='1234567')
   6 - access("C"."CONTACT_KEY"="M"."CONTACT_KEY")

Para a consulta lenta, com a condição createtime, é bem diferente:

Plan hash value: 1504517877
 
-------------------------------------------------------------------------------------------------------------------------------------
| Id  | Operation                                   | Name                  | Rows  | Bytes | Cost (%CPU)| Time     | Pstart| Pstop |
-------------------------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                            |                       |     2 |  1238 |    10   (0)| 00:00:01 |       |       |
|   1 |  NESTED LOOPS                               |                       |     2 |  1238 |    10   (0)| 00:00:01 |       |       |
|   2 |   PARTITION RANGE ITERATOR                  |                       |     3 |   891 |     6   (0)| 00:00:01 |   KEY |    12 |
|   3 |    TABLE ACCESS BY LOCAL INDEX ROWID BATCHED| TABLE1                |     3 |   891 |     6   (0)| 00:00:01 |   KEY |    12 |
|*  4 |     INDEX RANGE SCAN                        | IK_TABLE1_CREATETIME  |     3 |       |     3   (0)| 00:00:01 |   KEY |    12 |
|*  5 |   TABLE ACCESS BY INDEX ROWID               | TABLE2                |     1 |   322 |     2   (0)| 00:00:01 |       |       |
|*  6 |    INDEX UNIQUE SCAN                        | IK_TABLE2_CONTACT_KEY |     1 |       |     1   (0)| 00:00:01 |       |       |
-------------------------------------------------------------------------------------------------------------------------------------
 
Predicate Information (identified by operation id):
---------------------------------------------------
 
   4 - access("M"."CREATETIME">=SYSDATE@!-30)
   5 - filter("C"."CSI_TFID"='1234567')
   6 - access("C"."CONTACT_KEY"="M"."CONTACT_KEY")
 
Note
-----
   - this is an adaptive plan

Mostra o custo muito baixo para ambas as consultas, por isso é estranho para mim como essa única condição pode adicionar tanta complexidade.

Na tabela1, contact_key será basicamente único, não há restrição exclusiva, mas a lógica do aplicativo garante que seja único, então acho que a consulta rápida usa esta coluna para pesquisa, que será rápida. Mas a consulta lenta usa a coluna createtime para pesquisar nesta tabela, que será mais lenta, pois haverá muitos registros onde creatime é > sysdate - 30.

Tentei contornar desta forma, esperando poder fazer a consulta rápida como subconsulta e depois filtrar apenas os resultados disso:

select sq.* from (
  select * from table1 m, table2 c
  where
  c.contact_key = m.contact_key
  and c.csi_tfid = '1234567'
) sq
where sq.createtime >= (sysdate-30);

Mas recebi a mesma consulta lenta, com o mesmo plano de execução. O que mais posso tentar? O aplicativo atualmente não possui lógica para filtrar os resultados, ele depende da instrução SELECT.

-- ATUALIZAÇÃO do DBA

O DBA verificou algumas estatísticas e histórico, e parece que esta consulta começou a "comportar-se mal" por volta de 1º de maio. Antes usava outro índice, semelhante ao sugerido pelo @Andy DB Analyst (outro índice, não mencionei acima). Verifiquei todos os índices, as estatísticas, a data da última análise, etc., são quase idênticas.