All perguntas(dba)

Fundo

Aqui está um exemplo próximo do que estou trabalhando:

CREATE TABLE sandboxTesting.TemporalTest (    
    GroupNumber VARCHAR(25) NOT NULL,
    StartEffectiveWhen DATE NOT NULL,
    EndEffectiveWhen DATE NULL,
    ModifiedWhen DATETIME NULL,
    IsReady BIT NOT NULL DEFAULT 0,
    RowValidFrom DATETIME2 GENERATED ALWAYS AS ROW START NOT NULL,
    RowValidTo DATETIME2 GENERATED ALWAYS AS ROW END NOT NULL,
    PERIOD FOR SYSTEM_TIME (RowValidFrom, RowValidTo),
    CONSTRAINT PK_TemporalTest PRIMARY KEY CLUSTERED  
    (
        GroupNumber, StartEffectiveWhen
    )
) WITH (SYSTEM_VERSIONING=ON (HISTORY_TABLE=sandboxTesting.TemporalTestHistory))
GO 

CREATE TRIGGER sandboxTesting.OnModify ON sandboxTesting.TemporalTest AFTER UPDATE AS
BEGIN
    
    UPDATE  temporalTst
    SET     temporalTst.IsReady = 0,
            temporalTst.ModifiedWhen = GETDATE()
    FROM    sandboxTesting.TemporalTest temporalTst
            JOIN deleted del
                ON del.GroupNumber = temporalTst.GroupNumber
                AND del.StartEffectiveWhen = temporalTst.StartEffectiveWhen
    WHERE   -- All business columns go here with OR statements in between them.
            -- The idea is that if anything changes except the IsReady flag, then we 
            -- set the IsReady back to false.  (IsReady has to be set by itself)
            del.EndEffectiveWhen <> temporalTst.EndEffectiveWhen 
            OR (del.EndEffectiveWhen IS NULL AND temporalTst.EndEffectiveWhen IS NOT NULL)
            OR (del.EndEffectiveWhen IS NOT NULL AND temporalTst.EndEffectiveWhen IS NULL)
END
GO

-- Insert new test
INSERT INTO [sandboxTesting].[TemporalTest] ([GroupNumber], [StartEffectiveWhen], [EndEffectiveWhen],  [ModifiedWhen])
VALUES ('12345', '2024-01-1', NULL, NULL)
GO

-- Set is as ready 
UPDATE  sandboxTesting.TemporalTest
SET     IsReady = 1
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
GO 

-- Change the End date
UPDATE  sandboxTesting.TemporalTest
SET     EndEffectiveWhen = '2024-09-02'
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
        
-- Set the new end date as ready for billing.
UPDATE  sandboxTesting.TemporalTest
SET     IsReady = 1
WHERE   GroupNumber = '12345' AND StartEffectiveWhen = '2024-01-1'
GO 


-- Select the Data
SELECT * FROM sandboxTesting.TemporalTest for SYSTEM_TIME ALL 
ORDER BY GroupNumber, StartEffectiveWhen desc, RowValidFrom DESC, RowValidTo DESC, ModifiedWhen desc

-- Select the Raw Data (for comparison)
SELECT * FROM sandboxTesting.TemporalTest
UNION ALL 
SELECT * FROM sandboxTesting.TemporalTestHistory
ORDER BY GroupNumber, StartEffectiveWhen desc, RowValidFrom DESC, RowValidTo DESC, ModifiedWhen desc

Quando executo isso, este é o primeiro resultado:

E o segundo conjunto de saída se parece com isto:

Isso é diferente porque o primeiro resultado da consulta usa a for SYSTEM_TIME ALLcláusula, enquanto o segundo apenas consulta os dados brutos.

A diferença é que, no primeiro conjunto de dados, a segunda e a terceira linhas do segundo conjunto de dados foram filtradas. Elas foram removidas porque a segunda e a terceira linhas têm uma data de início e uma data de término que são as mesmas. (Basicamente dizendo que essas linhas nunca estiveram realmente em vigor.)

Pergunta

O que preciso saber é se posso confiar que essa "diferença de tempo zero" sempre estará presente para dados que foram atualizados por meio de um AFTERgatilho? (Preciso escrever algumas consultas que falharão se esse não for o caso.)

O que quero dizer com isso é o seguinte: se meu servidor estivesse sendo bombardeado por milhares de consultas, todas realizando quantidades absurdas de E/S e cálculos, os valores RowValidFrome RowValidTopara a segunda e terceira linhas do segundo conjunto de dados ainda teriam uma diferença de 0?

Em outras palavras, esses valores são os mesmos por causa da lógica da transação? Ou são os mesmos porque meu servidor é rápido e não está realmente sob nenhuma pressão agora?

(Um exemplo simplificado).

Tenho a Tabela 1 com itens:

+----+-------+
| id | name  |
+----+-------+
| 1  | car   |
| 2  | apple |
| 3  | grass |
| 4  | alien |
+----+-------+

e Tabela2 com as cores que esses itens podem ser:

+----+------+--------+
| id | item | color  |
+----+------+--------+
| 1  | 1    | blue   |
| 2  | 1    | green  |
| 3  | 2    | red    |
| 4  | 2    | green  |
| 5  | 2    | yellow |
| 6  | 3    | green  |
| 7  | 3    | yellow |
| 8  | 4    | yellow |
| 9  | 4    | green  |
+----+------+--------+

Preciso selecionar todos os itens (e idealmente suas cores também) que podem ser verdes ou amarelos, mas não em nenhuma outra cor. Estou preso em WHERE em SELECT Table1.id, Table1.name, Table2.color FROM (Table1 JOIN Table2 ON Table1.id=Table2.item) WHERE…. Você pode me ajudar? Idealmente, o resultado deve ser:

+-----------+-------------+---------------+
| Table1.id | Table1.name | Table2.color  |
+-----------+-------------+---------------+
| 3         | grass       | green         |
| 3         | grass       | yellow        |
| 4         | alien       | yellow        |
| 4         | alien       | green         |
+-----------+-------------+---------------+

(Desculpe se esta for uma pergunta duplicada de uma já respondida, mas não consegui encontrar nenhuma aqui, nem tenho ideia de quais palavras-chave pesquisar 🤷‍♂️)

Digamos que eu tenha uma tabela A que é referenciada pela tabela B. Cada registro na tabela A pode ser referenciado por vários registros da tabela B. Isso seria o clássico "A tem muitos B".

A Tabela B tem uma chave estrangeira para a tabela A que especifica ON DELETE CASCADE, portanto, quando um registro da tabela A é excluído, os registros de referência da tabela B também são excluídos.

O que estou tentando entender é como ele se comportaria ao excluir vários registros do pai A. O banco de dados executaria uma única consulta de exclusão para cada registro órfão na tabela B? Ou executaria uma consulta de exclusão para cada registro excluído da tabela A?

Acho que o que estou perguntando é se eu excluir 100 registros da tabela A, isso resultaria em 2 consultas (1 para a tabela A e outra para a tabela B) ou em 101 consultas (1 para a tabela A e outra para cada registro excluído naquela tabela).

Estou tentando encontrar essas informações na documentação do Postgres e do SQLite, mas não consigo encontrar nada.

Tenho dois bancos de dados Postgres 13 no AWS RDS.

• Um é mestre, o outro é escravo e usa replicação lógica.
• A replicação ficou para trás em cerca de 350 Gb.
• O escravo ficou com a CPU no limite nos últimos quatro dias por causa de alguns trabalhos em andamento, então não tenho certeza de qual replicação lógica conseguiu replicar durante esse tempo.
• Eu matei esses trabalhos e agora a CPU no mestre e no escravo está baixa.
• Olho para o assinante via select * from pg_stat_subscription;e vejo que latest_end_lsnestá avançando, embora muito lentamente.
• O editor diz que os atrasos de gravação/liberação/reprodução estão todos 13 minutos atrasados, mas tem sido assim durante a maior parte do dia.
• Não vejo erros nos logs do publicador ou do assinante, além de alguns erros simples de SQL que os usuários têm cometido.

Há algo que eu possa fazer aqui? Anteriormente, eu defini wal_receiver_timeouto timeout como 0 porque tive problemas de replicação, e isso ajudou. Gostaria de ter alguma visibilidade aqui para ter algum tipo de confiança de que ele vai funcionar, mas além desses lsnvalores e logs do banco de dados, não tenho certeza do que verificar.

Tenho um Microsoft SQL Server com uma tabela. Há um gatilho que dispara se uma linha for inserida na tabela. O sistema está ativo, ou seja, linhas são constantemente inseridas na tabela e o gatilho dispara o tempo todo.

Quero alterar o gatilho. O gatilho é o gargalo do sistema, e há uma chance muito alta de que ele esteja sendo executado/tenha iniciado uma transação ao emitir a consulta para alterá-lo. É seguro alterar o gatilho nessa situação? Qual é a pior coisa que pode acontecer? Presumo que um gatilho em processo terminará com a lógica antiga, e as execuções futuras usarão a nova lógica, mas como o sistema está em produção (sem uma boa maneira de testá-lo), preciso ter certeza.

Seria possível interromper o processo que está inserindo linhas na tabela, mas prefiro não interrompê-lo se não for necessário.

Tenho um aplicativo C# em que preciso validar credenciais para um banco de dados DB2 (V7R3).

Historicamente, a maneira como fazemos isso é anexar as credenciais a uma sequência de conexão e tentar conectar ao banco de dados para ver se a conexão é bem-sucedida ou falha.

Mas existe uma maneira melhor de fazer isso, como uma API para testar credenciais ou algo assim?

há uma configuração de publicador --> distribuidor --> assinante e tudo foi bem configurado neste sistema e alguns testes simples de adição de algumas tabelas e reposicionamento de tabelas parecem funcionar bem.

O problema é que temos mais de 6 mil artigos por banco de dados e muitos bancos de dados em um sistema multilocatário. O sistema está em operação há mais de 20 anos e quase todos os bancos de dados pegaram pilhas e visualizações ou procedimentos armazenados não compiláveis. Não podemos apontar e clicar cada vez que um banco de dados é restaurado e/ou precisa ser republicado/publicado; portanto, o seguinte está sendo testado.

Entendo que isso pode ser programado, mas estamos seguindo este conselho para reposicionar tabelas .

O teste inicial

• Crie a assinatura com 1 artigo tblAccountingBatch.
• Execute o script abaixo para adicionar todas as tabelas com uma PK e todos os artigos compiláveis.
• Execute novamente o agente de snapshot e pegue as novas tabelas.

Os resultados

• A interface do usuário mostra que todos os ~5 mil artigos estão ativos e selecionados na sub.
• O snapshot é executado e gera 1 artigo para a tabela inicial, tblAccountingBatch.
• EXEC sp_helpsubscription mostra apenas uma tabela - tblAccountingBatch.
• Tento criar um script para adicionar outro que esteja marcado na interface do usuário usando sp_addarticle e recebo um erro informando que o artigo já foi adicionado.

Alguém sabe onde a desconexão pode estar. O snapshot não parece ver os artigos adicionados após a criação do sub.

Me deparei com este KB que descreve algo muito semelhante; no entanto, o DBA diz que esses patches foram aplicados nos ambientes de teste.

Script para adicionar todos os artigos válidos após a criação da assinatura

SET NOCOUNT ON

USE VP_UPS_V05
GO

DECLARE @PublicationName NVARCHAR(200) = 'UPS_PUB'

EXEC sp_changepublication @publication = @PublicationName, @property = 'allow_anonymous' , @value = 'false' 
EXEC sp_changepublication @publication = @PublicationName, @property = 'immediate_sync' , @value = 'false' 


IF(CHARINDEX('VP_',DB_NAME()) = 0 OR CHARINDEX('_V05',DB_NAME()) =0 ) BEGIN
    RAISERROR('This script can only be applied against a Client database', 16, 1)
    RETURN
END


DECLARE @Debug BIT = 0

DECLARE @FullName nvarchar(1000);
DECLARE @ShortName nvarchar(300)
DECLARE @ObjectType nvarchar(300)
DECLARE @HasPrimaryKey BIT
DECLARE @Sql nvarchar(1000);
DECLARE @Result int;


DECLARE @Exceptions TABLE(ShortName NVARCHAR(300), FullName NVARCHAR(300),ObjectType NVARCHAR(300), Result INT, ErrorMessage NVARCHAR(MAX))


DECLARE @IgnoredTables TABLE (TableName NVARCHAR(100))
INSERT INTO @IgnoredTables VALUES
    ('tblAccountingBatch')
    

DECLARE ObjectCursor CURSOR FOR
SELECT 
    ShortName,LongName,ObjectType,HasPrimaryKey
FROM
(
    SELECT  
        OBJECT_NAME(o.object_id) ShortName , 
        QUOTENAME(SCHEMA_NAME(o.schema_id)) + '.' + QUOTENAME(OBJECT_NAME(o.object_id)) LongName, 
        CASE WHEN type_desc = 'USER_TABLE' THEN CASE WHEN  OBJECTPROPERTY(o.object_id,'tablehasprimaryKey') = 1 THEN 1 ELSE 0 END ELSE 0 END AS HasPrimaryKey,
        type_desc AS ObjectType,
        CASE 
            WHEN type_desc='USER_TABLE' THEN 0
            WHEN type_desc='VIEW' THEN 1 
            WHEN type_desc='SQL_SCALAR_FUNCTION' THEN 2
            WHEN type_desc='SQL_TABLE_VALUED_FUNCTION' THEN 3
            WHEN type_desc='SQL_INLINE_TABLE_VALUED_FUNCTION' THEN 4
            WHEN type_desc='SQL_TRIGGER' THEN 5
            WHEN type_desc='SQL_STORED_PROCEDURE' THEN 6
            ELSE
                7
        END AS ProcessOrder
    FROM 
        sys.objects o
        LEFT OUTER JOIN @IgnoredTables IgnoredTable ON type_desc = 'USER_TABLE' AND IgnoredTable.TableName = OBJECT_NAME(o.object_id)
    WHERE 
        type_desc IN ('USER_TABLE','SQL_STORED_PROCEDURE','SQL_TRIGGER','SQL_SCALAR_FUNCTION','SQL_TABLE_VALUED_FUNCTION','SQL_INLINE_TABLE_VALUED_FUNCTION','VIEW')    
        AND 
        ISNULL(OBJECTPROPERTY(o.object_id, 'IsSchemaBound'), 0) = 0
        AND
        SCHEMA_NAME(o.schema_id)='dbo'
        AND
        IgnoredTable.TableName IS NULL
        AND
        ((type_desc = 'USER_TABLE' AND OBJECT_NAME(o.object_id) LIKE 'tbl%')OR(type_desc<>'USER_TABLE'))
)AS X 
Order BY ProcessOrder, ShortName;

--RETURN

OPEN ObjectCursor;

DECLARE @TotalObjects INT = @@CURSOR_ROWS
DECLARE @CurrentObject INT = 0

FETCH NEXT FROM ObjectCursor INTO @ShortName, @FullName, @ObjectType, @HasPrimaryKey

DECLARE @IsError BIT = 0
DECLARE @CompileResult BIT = 0
DECLARE @ErrorMessage NVARCHAR(MAX)

DECLARE @InsertCommand NVARCHAR(300)
DECLARE @DeleteCommand NVARCHAR(300)
DECLARE @UpdateCommand NVARCHAR(300)
DECLARE @ArticleType NVARCHAR(300)

WHILE @@FETCH_STATUS = 0
BEGIN
    SET @CurrentObject = @CurrentObject + 1
    PRINT 'Processing Object '+CAST(@CurrentObject AS VARCHAR(10))+'/'+CAST(@TotalObjects AS VARCHAR(10))+' - '+@ObjectType+' '+@ShortName
     
    SET @IsError = 0
    SET @ErrorMessage = ''

    IF(@ObjectType = 'USER_TABLE') BEGIN 
        IF(@HasPrimaryKey = 0 ) BEGIN
            SET @IsError = 1
            SET @ErrorMessage = 'Missing Primary Key'   
        END     
    END ELSE BEGIN      
        SET @Sql = N'EXEC sp_refreshsqlmodule ''' + @FullName + '''';       
        BEGIN TRY
            EXEC @CompileResult = sp_executesql @Sql;
            IF @CompileResult <> 0 RAISERROR('Failed', 16, 1);
        END TRY
        BEGIN CATCH
            SET @IsError = 1
            SET @ErrorMessage = ERROR_MESSAGE()             
        END CATCH
    END

    IF(@IsError = 0 AND @Debug=0) BEGIN
        BEGIN TRY           
            IF(@ObjectType = 'USER_TABLE') BEGIN

                SET @InsertCommand = 'CALL sp_MSins_dbo_'+@ShortName
                SET @DeleteCommand = 'CALL sp_MSdel_dbo_'+@ShortName
                SET @UpdateCommand = 'CALL sp_MSupd_dbo_'+@ShortName

                exec sp_addarticle 
                    @publication = @PublicationName, 
                    @article = @ShortName, 
                    @source_owner = 'dbo', 
                    @source_object = @ShortName, 
                    @type = 'logbased', 
                    @description = null, 
                    @creation_script = null, 
                    @pre_creation_cmd = 'drop', 
                    @schema_option = 0x000000000803509F, 
                    @identityrangemanagementoption = 'manual', 
                    @destination_table = @ShortName, 
                    @destination_owner = 'dbo', 
                    @vertical_partition = 'false', 
                    @ins_cmd = @InsertCommand, 
                    @del_cmd = @DeleteCommand, 
                    @upd_cmd = @UpdateCommand
            END ELSE IF (@ObjectType IN ('SQL_INLINE_TABLE_VALUED_FUNCTION','SQL_SCALAR_FUNCTION','SQL_STORED_PROCEDURE','SQL_TABLE_VALUED_FUNCTION','VIEW')) BEGIN
                IF(@ObjectType='SQL_STORED_PROCEDURE') 
                    SET @ArticleType = 'proc schema only'
                ELSE IF(@ObjectType = 'VIEW')   
                    SET @ArticleType = 'view schema only'
                ELSE
                    SET @ArticleType ='func schema only'
                    
                exec sp_addarticle 
                    @publication =@PublicationName, 
                    @article = @ShortName, 
                    @source_owner = 'dbo', 
                    @source_object = @ShortName, 
                    @type = @ArticleType, 
                    @description = null, 
                    @creation_script = null, 
                    @pre_creation_cmd = N'drop', 
                    @schema_option = 0x0000000008000001, 
                    @destination_table = @ShortName, 
                    @destination_owner = 'dbo'

            END
        END TRY
        BEGIN CATCH
            SET @IsError = 1
            SET @ErrorMessage = 'Could Not Add Article to Replication - '+ERROR_MESSAGE()  
            IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;
        END CATCH
    END 
    
    IF(@IsError = 1)  
        INSERT INTO @Exceptions SELECT  @ShortName, @FullName, @ObjectType, 0, @ErrorMessage
        
    FETCH NEXT FROM ObjectCursor INTO @ShortName, @FullName, @ObjectType, @HasPrimaryKey
END

CLOSE ObjectCursor;
DEALLOCATE ObjectCursor; 

SELECT * FROM @Exceptions

Eu tenho uma tabela assim:

Quero extrair informações do cliente da coluna "Nota" para colocá-las na coluna "Cliente" com apenas uma consulta SQL.

Dei alguns exemplos que representam os milhares de linhas reais que tenho. Primeiro fiz esta consulta:

SELECT
    CASE
        WHEN posclient != 0 THEN SUBSTRING(
            Note,
            posclient + LENGTH('Client: '),
            LOCATE('\n', Note, posclient + LENGTH('Client: ')) - (posclient + LENGTH('Client: '))
        )
        WHEN poscustomer != 0 THEN SUBSTRING(
            Note,
            poscustomer + LENGTH('Customer : '),
            LOCATE('\n', Note, poscustomer + LENGTH('Customer : ')) - (poscustomer + LENGTH('Customer : '))
        )
        WHEN poscontact != 0 THEN SUBSTRING(
            Note,
            poscontact + LENGTH('Contact : '),
            LOCATE('\n', Note, poscontact + LENGTH('Contact : ')) - (poscontact + LENGTH('Contact : '))
        )
        ELSE ''
    END AS client,
    Id
FROM (SELECT Id, Note,
        LOCATE('Customer : ', Note) as poscustomer,
        LOCATE('Client: ', Note) as posclient,
        LOCATE('Contact : ', Note) as poscontact
    FROM myTable) x 
WHERE (poscustomer != 0 OR posclient != 0 OR poscontact != 0)

Como há código duplicado (a WHENparte), é difícil de ler e não fica muito bom se eu tiver outra maneira de adicionar.

E eu tenho: há pelo menos 6 maneiras de escrever o cliente. Quero otimizar esta parte:

WHEN poscontact != 0 THEN SUBSTRING(
   Note,
   poscontact + LENGTH('Contact : '),
   LOCATE('\n', Note, poscontact + LENGTH('Contact : ')) - (poscontact + LENGTH('Contact : '))
)

Para ser "genérico", mas não sei como, pois não estou em linguagem de programação. Em php, isso seria fácil, mas não posso usar linguagem de programação, tenho que usar apenas uma consulta.

Uma coisa que pode ser muito útil: há apenas UMA maneira de escrever o cliente para cada linha. Ele sempre conterá apenas um.

Como posso fazer?

O MySQL mostra duas conexões. Uma não requer senha e é o mesmo banco de dados que criei com o MySQL Workbench.

Tenho duas conexões de banco de dados. Uma é o banco de dados que veio com a instalação do MySQL. A outra eu criei e adicionei algumas tabelas a ela.

Não toquei no banco de dados que veio com a instalação do MySQL, mas ele está atualizando com as mesmas informações do segundo banco de dados. Elas parecem ser as mesmas, pois atualizo as informações no último, no entanto, as cifras SSL são diferentes. O SSL não é usado para o banco de dados inicial, e o TLS_AES_128 é usado no novo banco de dados.

Ambos são protegidos por senha com a mesma senha devido à confusão durante a instalação, e salvei a senha no chaveiro.

Preciso dos dois? Isso causará um problema no futuro?

No prompt de comando mysql> status foi como descobri que as cifras SSL eram diferentes, e inicialmente pensei que estava me conectando ao banco de dados errado. Então comparei com o MySQL Workbench e notei as diferenças. Eu estava esperando um problema mais para frente.

Eu tenho uma mesa com objetos

e outra tabela com informações sobre este objeto habilitado e outro objeto juntos

preciso de uma consulta sql, retornar objeto da primeira tabela objeto, que não tem verdadeiro na segunda tabela

SELECT ft.* 
FROM first_table ft 
  JOIN second_table st on ft.uuid = st.uuid_from_table_upper
WHERE
  not st.enabled;

eu acho que precisava agrupar por ou recursivo com