All perguntas(dba)

Nosso cliente está procurando JDKs ou JREs desatualizados e os encontrou em arquivos de instância de banco de dados Oracle, arquivos instalados.

É seguro para o Oracle DB remover JDK, JRE?

Name="Java(TM) SE Runtime Environment" Version="1.8.0_371"
Value="/opt/oracle/product/19.20.0.0.230718/jdk/bin"

Name="Java(TM) SE Runtime Environment" Version="1.8.0_371"
Value="/opt/oracle/product/19.20.0.0.230718/jdk/jre/bin"

Name="Java(TM) SE Runtime Environment" Version="1.8.0_381"
Value="/opt/oracle/product/19.20.0.0.230718/OPatch/jre/bin"

Acabei de restaurar meu banco de dados usando o script abaixo,

USE [master]
GO
RESTORE DATABASE [MyDB] 
FROM  DISK = N'C:\Program Files\Microsoft SQL Server\MSSQL14.SQLSTANDARD\MSSQL\Backup\mydb.bak' WITH  FILE = 1, 
NOUNLOAD,  REPLACE,  STATS = 5, KEEP_CDC
GO


USE MyDB
GO
EXECUTE sys.sp_cdc_add_job 'capture';
GO
EXECUTE sys.sp_cdc_add_job 'cleanup';
GO

Então verifiquei o CDC,

select is_tracked_by_cdc,name from sys.tables order by is_tracked_by_cdc desc
select is_cdc_enabled,name from sys.databases order by is_cdc_enabled desc

CDC habilitado para minhas tabelas. Então executei o script UPDATE,

UPDATE MyTable SET Name='SomeName' where id=1

Mas não encontrei nenhum registro na tabela cdc,

SELECT * FROM [cdc].[dbo_MyTable_CT]

Instalei a atualização cumulativa mais recente (CU31).

Como ignorar todos os tipos de modificações (INSERT, UPDATE, DELETE)na tabela FOR EACH STATEMENT TRIGGERsem lançar/aumentar e EXCEPTIONcancelar toda a transação?

Eu sei que isso pode ser conseguido em BEFORE FOR EACH ROWgatilhos retornando NULLno final do TRIGGER FUNCTION, mas isso não funciona com FOR EACH STATEMENTschamadas de função, pois elas sempre retornam NULLe as modificações ainda são aplicadas.

(minha motivação nisso é a melhoria de desempenho, já que os gatilhos FOR EACH STATEMENT são mais leves que FOR EACH ROW)

Digamos que eu tenha essas duas tabelas: autor(id, nome, país) e publicação(id, nome, ano, autor_id).

O que eu quero chegar no final é:

autor_id | nome_autor | autor_país | autor_publicações

Onde autor_publicações é uma matriz JSON com todas as publicações do autor correspondente.

SELECT author.id AS author_id,
       author.name AS author_name,
       author.country as author_country,
       JSONB_AGG(JSONB_BUILD_OBJECT(
                         'id',
                         publication.id,
                         'name',
                         publication.name,
                         'year',
                         publication.year
                     )) AS author_publications

FROM author
JOIN publication
ON author.id = publication.author_id
GROUP BY author.id

Esta consulta retorna exatamente o que eu quero. Dito isto, o desempenho fica muito ruim quando a instância do banco de dados está ocupada. A agregação JSON torna a consulta 5 a 6 vezes mais lenta.

Existe um índice da chave estrangeira (author_id) na tabela de publicação.

Existe uma maneira melhor de obter o resultado que desejo?

+-----------------------------------------------------------------------------------------------------------------------------------------------+
|QUERY PLAN                                                                                                                                     |
+-----------------------------------------------------------------------------------------------------------------------------------------------+
|HashAggregate  (cost=107.31..108.35 rows=83 width=116) (actual time=25.764..38.070 rows=83 loops=1)                                            |
|  Group Key: author.id                                                                                                                      |
|  Batches: 5  Memory Usage: 4400kB  Disk Usage: 240kB                                                                                          |
|  ->  Hash Join  (cost=4.87..88.64 rows=2490 width=197) (actual time=0.077..2.250 rows=2448 loops=1)                                           |
|        Hash Cond: (publication.author_id = author.id)                                                                                     |
|        ->  Seq Scan on publication  (cost=0.00..76.90 rows=2490 width=113) (actual time=0.008..1.115 rows=2448 loops=1)|
|        ->  Hash  (cost=3.83..3.83 rows=83 width=84) (actual time=0.062..0.063 rows=83 loops=1)                                                |
|              Buckets: 1024  Batches: 1  Memory Usage: 18kB                                                                                    |
|              ->  Seq Scan on author  (cost=0.00..3.83 rows=83 width=84) (actual time=0.006..0.040 rows=83 loops=1)  |
|Planning Time: 0.287 ms                                                                                                                        |
|Execution Time: 38.494 ms                                                                                                                      |
+-----------------------------------------------------------------------------------------------------------------------------------------------+

Desculpe pelo título longo, não tinha certeza de como diferenciá-lo dos resultados da pesquisa automática.

Eu tenho um arquivo de despejo grande (~ 44 GB) e estou tentando importá-lo para o MySQL em um servidor diferente.

Ambos os servidores estão rodando 5.7, embora um seja 5.7.20 (fonte) e o outro seja 5.7.42 (destino), no Ubuntu 22.04 LTS. Eu, como uma salva de palmas, instalei o servidor MySQL 8 mais recente para o sistema operacional como o servidor de banco de dados de destino, que produziu os mesmos resultados.

Toda tentativa de restaurar o banco de dados resulta em um erro de sintaxe, mas nem sempre no mesmo lugar, e às vezes antes ou depois de onde a execução anterior chegou.

Por exemplo; na execução 1 pode ocorrer um erro na linha 26880, depois na execução 2 ocorrerá um erro na linha 14230 (antes da execução 1) e na execução 3 talvez na linha 390290 (mais tarde que ambas). Os números das linhas aqui são arbitrários, mas sobem e descem e geralmente nunca ficam no mesmo lugar duas vezes.

• max_allowed_packettem no máximo 1 GB
• innodb_buffer_pool_sizeestá definido para 128 GB (que é aproximadamente 65% da RAM disponível)

Todo o resto é padrão. Não há erros listados no log de erros.

Tentei outros backups, que produziram o mesmo resultado.

O backup não está compactado.

O que eu fiz errado?

Estou construindo um banco de dados que é usado para derivar relações hierárquicas para as quais escolhi um CTE recursivo PostgreSQL.

minha estrutura de tabela é

table_name             |column_name           |data_type               |
-----------------------+----------------------+------------------------+
source_relationship_dev|relationship_id       |character varying       |
source_relationship_dev|subject               |character varying       |
source_relationship_dev|predicate             |character varying       |
source_relationship_dev|object                |character varying       |
source_relationship_dev|rel_date              |character varying       |
source_relationship_dev|provided_by           |character varying       |
source_relationship_dev|harvested_date        |character varying       |
source_relationship_dev|rel_status            |character varying       |
source_relationship_dev|subject_status        |character varying       |
source_relationship_dev|object_status         |character varying       |
source_relationship_dev|source_relationship_id|integer                 |
source_relationship_dev|correction_id         |character varying       |
source_relationship_dev|harvested_date        |character varying       |
source_relationship_dev|obj_status            |character varying       |
source_relationship_dev|obj                   |character varying       |
source_relationship_dev|predicate             |character varying       |
source_relationship_dev|provided_by           |character varying       |
source_relationship_dev|rel_status            |character varying       |
source_relationship_dev|start_date            |character varying       |
source_relationship_dev|sub_status            |character varying       |
source_relationship_dev|subject               |character varying       |
source_relationship_dev|audit_created_date    |timestamp with time zone|
source_relationship_dev|audit_created_by      |character varying       |
source_relationship_dev|audit_modified_date   |timestamp with time zone|
source_relationship_dev|audit_modified_by     |character varying       |

Índice:

table_name             |column_name           |data_type               |
-----------------------+----------------------+------------------------+
source_relationship_dev|relationship_id       |character varying       |
source_relationship_dev|subject               |character varying       |
source_relationship_dev|predicate             |character varying       |
source_relationship_dev|object                |character varying       |
source_relationship_dev|rel_date              |character varying       |
source_relationship_dev|provided_by           |character varying       |
source_relationship_dev|harvested_date        |character varying       |
source_relationship_dev|rel_status            |character varying       |
source_relationship_dev|subject_status        |character varying       |
source_relationship_dev|object_status         |character varying       |
source_relationship_dev|source_relationship_id|integer                 |
source_relationship_dev|correction_id         |character varying       |
source_relationship_dev|harvested_date        |character varying       |
source_relationship_dev|obj_status            |character varying       |
source_relationship_dev|obj                   |character varying       |
source_relationship_dev|predicate             |character varying       |
source_relationship_dev|provided_by           |character varying       |
source_relationship_dev|rel_status            |character varying       |
source_relationship_dev|start_date            |character varying       |
source_relationship_dev|sub_status            |character varying       |
source_relationship_dev|subject               |character varying       |
source_relationship_dev|audit_created_date    |timestamp with time zone|
source_relationship_dev|audit_created_by      |character varying       |
source_relationship_dev|audit_modified_date   |timestamp with time zone|
source_relationship_dev|audit_modified_by     |character varying       |

Minha consulta:

select 
    correction_id as id,
    subject,
    obj,
    predicate,
    start_date
    from
(
with recursive cte as (
        select
            correction_id,
            subject ,
            predicate ,
            obj ,
            start_date,
            provided_by,
            harvested_date
        from
            source_relationship_dev
        where
            obj_status != 'DELETE'
            and rel_status != 'DELETE'
            and sub_status != 'DELETE'
    union all
        select
            c.correction_id,
            c.subject ,
            c.predicate ,
            c.obj ,
            c.start_date,
            c.provided_by,
            c.harvested_date
        from
            source_relationship_dev c
        join cte e on
            c.subject = e.predicate
        where
            c.obj_status != 'DELETE'
            and c.rel_status != 'DELETE'
            and c.sub_status != 'DELETE'
 )
        select 
            correction_id,
            subject,
            predicate,
            obj,
            harvested_date,
            provided_by,
            start_date,
            subject || '-' || predicate || '-' || obj as stored_relationship
        from
            cte
        join relation_inferences on
            relationship = predicate
    union all
        select
            correction_id,
            obj,
            relationship,
            subject,
            harvested_date,
            provided_by,
            start_date,
            subject || '-' || predicate || '-' || obj as stored_relationship
        from
            cte
        join relation_inferences on
            inverse_relationship = predicate
    union all
        select
            correction_id||'_inverse' as relationship_id,
            obj,
            inverse_relationship,
            subject,
            harvested_date,
            provided_by,
            start_date,
            subject || '-' || predicate || '-' || obj as stored_relationship
        from
            cte
        join relation_inferences on
            relationship = predicate
    union all
        select
            correction_id||'_inverse' as relationship_id,
            subject,
            inverse_relationship,
            obj,
            harvested_date,
            provided_by,
            start_date,
            subject || '-' || predicate || '-' || obj as stored_relationship
        from
            cte
        join relation_inferences on
            inverse_relationship = predicate) as chk
            where  provided_by = (select provided_by from source_relationship_dev 
                                where subject=chk.subject
                                or obj=chk.subject
                                order by harvested_Date desc fetch first row only);

Meu plano Explicar é

Subquery Scan on chk  (cost=313222.30..107250816.83 rows=866 width=1154) (actual time=0.043..52208.024 rows=28960 loops=1)
  Filter: ((chk.provided_by)::text = ((SubPlan 1))::text)
  ->  Append  (cost=313222.30..483994.99 rows=173152 width=1522) (actual time=0.030..103.675 rows=28960 loops=1)
        CTE cte
          ->  Recursive Union  (cost=0.00..313221.19 rows=1731501 width=284) (actual time=0.009..28.418 rows=14481 loops=1)
                ->  Seq Scan on source_relationship_dev source_relationship_dev_1  (cost=0.00..833.42 rows=14481 width=284) (actual time=0.007..7.088 rows=14481 loops=1)
                      Filter: (((obj_status)::text <> 'DELETE'::text) AND ((rel_status)::text <> 'DELETE'::text) AND ((sub_status)::text <> 'DELETE'::text))
                ->  Hash Join  (cost=1566.43..27775.77 rows=171702 width=284) (actual time=16.391..16.393 rows=0 loops=1)
                      Hash Cond: ((e.predicate)::text = (c.subject)::text)
                      ->  WorkTable Scan on cte e  (cost=0.00..2896.20 rows=144810 width=516) (actual time=0.005..1.590 rows=14481 loops=1)
                      ->  Hash  (cost=833.42..833.42 rows=14481 width=284) (actual time=10.504..10.505 rows=14481 loops=1)
                            Buckets: 16384  Batches: 2  Memory Usage: 1973kB
                            ->  Seq Scan on source_relationship_dev c  (cost=0.00..833.42 rows=14481 width=284) (actual time=0.008..4.008 rows=14481 loops=1)
                                  Filter: (((obj_status)::text <> 'DELETE'::text) AND ((rel_status)::text <> 'DELETE'::text) AND ((sub_status)::text <> 'DELETE'::text))
        ->  Hash Join  (cost=1.11..41990.02 rows=43288 width=2490) (actual time=0.029..49.124 rows=7239 loops=1)
              Hash Cond: ((cte.predicate)::text = (relation_inferences.relationship)::text)
              ->  CTE Scan on cte  (cost=0.00..34630.02 rows=1731501 width=2458) (actual time=0.010..38.674 rows=14481 loops=1)
              ->  Hash  (cost=1.05..1.05 rows=5 width=218) (actual time=0.006..0.007 rows=5 loops=1)
                    Buckets: 1024  Batches: 1  Memory Usage: 9kB
                    ->  Seq Scan on relation_inferences  (cost=0.00..1.05 rows=5 width=218) (actual time=0.002..0.004 rows=5 loops=1)
        ->  Hash Join  (cost=1.11..41990.02 rows=43288 width=2192) (actual time=0.033..15.323 rows=7241 loops=1)
              Hash Cond: ((cte_1.predicate)::text = (relation_inferences_1.inverse_relationship)::text)
              ->  CTE Scan on cte cte_1  (cost=0.00..34630.02 rows=1731501 width=2458) (actual time=0.001..4.770 rows=14481 loops=1)
              ->  Hash  (cost=1.05..1.05 rows=5 width=436) (actual time=0.016..0.016 rows=5 loops=1)
                    Buckets: 1024  Batches: 1  Memory Usage: 9kB
                    ->  Seq Scan on relation_inferences relation_inferences_1  (cost=0.00..1.05 rows=5 width=436) (actual time=0.010..0.012 rows=5 loops=1)
        ->  Subquery Scan on "*SELECT* 3"  (cost=1.11..42531.12 rows=43288 width=1708) (actual time=0.038..17.136 rows=7239 loops=1)
              ->  Hash Join  (cost=1.11..42098.24 rows=43288 width=1708) (actual time=0.037..15.375 rows=7239 loops=1)
                    Hash Cond: ((cte_2.predicate)::text = (relation_inferences_2.relationship)::text)
                    ->  CTE Scan on cte cte_2  (cost=0.00..34630.02 rows=1731501 width=2458) (actual time=0.001..4.601 rows=14481 loops=1)
                    ->  Hash  (cost=1.05..1.05 rows=5 width=436) (actual time=0.014..0.015 rows=5 loops=1)
                          Buckets: 1024  Batches: 1  Memory Usage: 9kB
                          ->  Seq Scan on relation_inferences relation_inferences_2  (cost=0.00..1.05 rows=5 width=436) (actual time=0.010..0.011 rows=5 loops=1)
        ->  Subquery Scan on "*SELECT* 4"  (cost=1.11..42531.12 rows=43288 width=1708) (actual time=0.042..16.969 rows=7241 loops=1)
              ->  Hash Join  (cost=1.11..42098.24 rows=43288 width=1708) (actual time=0.041..15.283 rows=7241 loops=1)
                    Hash Cond: ((cte_3.predicate)::text = (relation_inferences_3.inverse_relationship)::text)
                    ->  CTE Scan on cte cte_3  (cost=0.00..34630.02 rows=1731501 width=2458) (actual time=0.001..4.816 rows=14481 loops=1)
                    ->  Hash  (cost=1.05..1.05 rows=5 width=218) (actual time=0.014..0.015 rows=5 loops=1)
                          Buckets: 1024  Batches: 1  Memory Usage: 9kB
                          ->  Seq Scan on relation_inferences relation_inferences_3  (cost=0.00..1.05 rows=5 width=218) (actual time=0.008..0.010 rows=5 loops=1)
  SubPlan 1
    ->  Limit  (cost=0.29..616.59 rows=1 width=33) (actual time=1.798..1.798 rows=1 loops=28960)
          ->  Index Scan using source_hrvst_idx on source_relationship_dev  (cost=0.29..1232.90 rows=2 width=33) (actual time=1.797..1.797 rows=1 loops=28960)
                Filter: (((subject)::text = (chk.subject)::text) OR ((obj)::text = (chk.subject)::text))
                Rows Removed by Filter: 6783
Planning Time: 0.765 ms
Execution Time: 52211.281 ms

Esses 52.211,281 ms são para 14.441 registros.

Posso melhorar o desempenho da consulta tal como está, em vez de mexer na minha lógica?

Estou tentando classificar dados com campo anulável e também tentando obter paginação usando limite e deslocamento

Aqui está a consulta para a primeira página

SELECT table_name.* FROM table_name ORDER BY table_name.date_field DESC LIMIT 2;

e recebo o seguinte resultado.

enquanto a consulta seguinte está sendo usada para a segunda página

SELECT table_name.* FROM table_name ORDER BY table_name.date_field DESC LIMIT 2 OFFSET 2;

e recebo o seguinte resultado.

se você comparar as duas tabelas, notará aquele registro com id=2 fornecido duas vezes (em uma primeira consulta e em uma segunda consulta), o que está errado.

Esta é uma consulta simples, sem junção e sem condição de onde.

Alguém tem solução? desde já, obrigado.

Estou usando a versão mysql: 8.0.34 - MySQL Community Server - GPL

Estou tentando selecionar 10 clientes com número mínimo de registros(compras). Minhas tabelas são: produtos, clientes, compras(id, customer_id, product_id). O que eu acho é selecionar clientes, agrupá-los e então escrever uma consulta aninhada e obter a contagem mínima, assim:

            SELECT last_name, name, COUNT(pur.id) FROM customers AS c 
            INNER JOIN purchases AS pur ON c.id=pur.customer_id 
            INNER JOIN products AS pr ON pr.id=pur.product_id 
            GROUP BY last_name, name 
            HAVING count(pur.id) =  (SELECT min(pur.id) FROM 
               (SELECT count(pur.id) FROM customers AS c
               INNER JOIN purchases AS pur ON c.id=pur.customer_id
               INNER JOIN products AS pr ON pr.id=pur.product_id
               GROUP BY last_name, name))

Mas não tenho certeza de como fazer isso?

Eu tenho um cenário onde tenho duas tabelas person_naturale person_legal.

Caso 1:

Tenho funcionários, agricultores, clientes e fornecedores. Devo ter um enum em cada tabela ( person_naturalou person_legal) indicando o tipo de pessoa (por exemplo, em person_naturaleu teria uma coluna chamada typepara dizer se é funcionário, agricultor ou cliente) ou devo criar uma tabela para cada tipo de pessoa? pessoa e vinculá-la à tabela principal usando um FK?

Pergunto isso porque funcionários e clientes possuem colunas adicionais, por exemplo, funcionário tem salário e cliente tem limite de crédito. Se eu colocar essas colunas na tabela principal, a coluna sempre será NULL para determinado tipo de pessoa.

Exemplo:

person_natural
employee -> FK person_natural
farmer -> FK person_natural
customer -> FK person_natural

ou

person_natural -> type_person (employee, farmer, customer)

Caso 2:

Tenho uma tabela para anexos e uma tabela para endereços. Se eu tiver as tabelas person_naturale person_legal, normalmente teria que criar uma tabela de junção para cada uma:

person_natural
person_natural_attachment
person_natural_address

person_legal
person_legal_attachment
person_legal_address

Nesse caso, é correto (especialmente após a normalização do banco de dados) criar uma tabela chamada persone deixar o FK ativado person_naturale person_legalsomente para não ter que criar tabelas de junção adicionais?

person
person_natural -> FK person
person_legal -> FK person
person_attachment
person_address

Nesse caso, se eu tivesse um person_natural, poderia acessar facilmente os anexos juntando o persone depois as person_attachmenttabelas.

Quais são as práticas recomendadas para esses dois cenários? Estou aberto a quaisquer sugestões ou recomendações. Obrigado pelo seu tempo.

Estamos usando o DBeaver Community Edition (v23.2.0.202309041200) como um cliente conectado ao Microsoft SQL Server 2016 (v13.0.5101.9).

O problema ocorre ao executar as instruções SQL abaixo no DBeaver como um script.

declare @option as int = 2;

select @option;

A ação "Executar script SQL", ou pela tecla de atalho do DBeaver Alt+X, sempre falha na instrução de seleção, com mensagem de erro dizendo SQL Error [137] [S0002]: Must declare the scalar variable "@option"..

O erro não acontece se destacarmos as duas instruções SQL e seguirmos com a ação "Executar consulta SQL", ou pela tecla de atalho do DBeaver Ctrl+Enter.

O erro também não ocorre se usarmos o Microsoft SQL Server Management Studio, portanto, não acreditamos que o problema esteja relacionado ao SQL Server.

Nossa pergunta:

Existe alguma maneira de usar variáveis ​​declaradas no DBeaver ao executar um script SQL no MSSQL (Microsoft SQL Server)?

Agradecemos muito quaisquer dicas e sugestões.