All perguntas(dba)

Tenho uma função definida pelo usuário que modifica dados sql. Ela insere em uma tabela e retorna o ID da linha retornada. Tentando usá-la assim

UPDATE table_X SET REV = REVISION(:timestamp, :user) WHERE ...conditions;

O DB2 me dá o erro:Routine "REDACTED.REVISION" (specific name "REDACTED") is defined with the MODIFIES SQL DATA option, which is not valid in the context where the routine is invoked.

A documentação da IBM para esse erro diz especificamente que é assim que uma função MODIFIES SQL DATAdeve ser usada.

Isso é apenas um bug no DB2 ou estou esquecendo de alguma coisa?

Assumindo o SQL Server 2022 Standard Edition no Windows, eu simplesmente não consigo ver nenhum benefício em usar Basic Availability Groups em vez do Database Mirroring. Existe algo oferecido pelo Basic Availability Groups, mas não pelo Database Mirroring?

Em ambos os casos:

• Você só pode ter 1 primário e 1 secundário
• O secundário não é legível
• Os bancos de dados não podem ser agrupados de nenhuma forma, permitindo que eles falhem juntos
• A replicação pode ser sincronizada ou assíncrona
• O reparo automático de páginas está habilitado.

As únicas diferenças que encontrei entre os dois recursos são que os Grupos de Disponibilidade Básica não podem ser atualizados para a Edição Enterprise e que o Espelhamento de Banco de Dados está oficialmente obsoleto.

Entendo que os Grupos de Disponibilidade Básica são mais difíceis de configurar do que os espelhos, mas estou perguntando apenas sobre os benefícios dos Grupos de Disponibilidade Básica em relação ao Espelhamento de Banco de Dados.

Com a configuração do banco de dados

CREATE TYPE dbo.TableType AS TABLE (
prop1 int, 
prop2 datetime2, 
prop3 varchar(1000)
);


GO

CREATE OR ALTER PROC dbo.TestTableTypePerf
@Data dbo.TableType READONLY
AS
SELECT COUNT(*)
FROM @Data;

O código a seguir passa os valores de TVP de forma streaming. O enumerável não é avaliado até depois da ExecuteScalarAsyncchamada e não há necessidade de que todos os 5.000.000 elementos sejam materializados em uma coleção no cliente.

Está se tornando cada vez mais popular evitar TVPs em favor de strings JSON. Algo semelhante pode ser feito para JSON?

using System.Data;
using Microsoft.Data.SqlClient;
using Microsoft.Data.SqlClient.Server;

const string connectionString =
    @"...";

await TvpTest();

return;

static async Task TvpTest()
{
    await using var conn = new SqlConnection(connectionString);
    await conn.OpenAsync();
    await using var cmd = new SqlCommand("dbo.TestTableTypePerf", conn);
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add(new SqlParameter
    {
        ParameterName = "@Data",
        SqlDbType = SqlDbType.Structured,
        TypeName = "dbo.TableType",
        Value = GetEnumerableOfRandomSqlDataRecords(5_000_000)
    });

    Console.WriteLine($"calling ExecuteScalarAsync at {DateTime.Now:O}");
    var result = await cmd.ExecuteScalarAsync();

    Console.WriteLine($"writing result at {DateTime.Now:O}");
    Console.WriteLine(result);
}

static IEnumerable<SqlDataRecord> GetEnumerableOfRandomSqlDataRecords(uint length)
{
    SqlMetaData[] metaData =
    [
        new SqlMetaData("prop1", SqlDbType.Int),
        new SqlMetaData("prop2", SqlDbType.DateTime2),
        new SqlMetaData("prop3", SqlDbType.VarChar, 1000)
    ];

    foreach (var dto in GetEnumerableOfRandomDto(length))
    {
        var record = new SqlDataRecord(metaData);
        record.SetInt32(0, dto.Prop1);
        record.SetDateTime(1, dto.Prop2);
        record.SetString(2, dto.Prop3);

        yield return record;
    }
}


static IEnumerable<Dto> GetEnumerableOfRandomDto(uint length)
{
    var rnd = new Random();

    for (var i = 0; i < length; i++)
    {
        yield return new Dto(rnd.Next(1, int.MaxValue), 
                             DateTime.Now.AddMinutes(rnd.Next(1, 10000)),
                             Guid.NewGuid().ToString()
                             );

        if ((i + 1) % 100_000 == 0)
            Console.WriteLine($"Generated enumerable {i + 1} at {DateTime.Now:O}");
    }
}


internal record Dto(int Prop1, DateTime Prop2, string Prop3);

Descobri que usar TVPs para passar vários valores para um procedimento armazenado é muito mais fácil e rápido, especialmente ao lidar com algumas colunas e algumas centenas de linhas, pois elimina a necessidade de análise de dados adicional. Por que alguém escolheria XML ou JSON em vez de TVPs? Em quais casos de uso eles oferecem melhor desempenho ou vantagens? Se tivesse uma chance, o que você escolheria entre os três? Obrigado!

Estou executando o MariaDB 11.4.4 com um site movimentado (Debian12+nginx+php-fpm).

Uma vez a cada poucos dias, os threads do MariaDB parecem congelados até que a conexão máxima seja atingida. Mesmo matando a consulta, o thread não é liberado. O MariaDB não pode ser desligado por systemctl stop mariadbFinalmente, preciso killall -9 mariadbdretomar as operações. Não há nada inesperado em mysql/error.log ou slow_query.log

Aqui está SHOW FULL PROCESSLIST, SHOW GLOBAL STATUS e SHOW ENGINE INNODB STATUS tirados logo antes do bloqueio total do MariaDB:

https://pastejustit.com/mariadb-debug-info

MOSTRAR VARIÁVEIS está aqui:

https://pastebin.com/xeVjpT4A

Houve relatos semelhantes no passado, porém eles estavam relacionados a uma versão mais antiga do MariaDB, sem solução clara e provavelmente foram corrigidos no MariaDB 10.6.*

• Bloqueio de threads do Mariadb aleatoriamente
• Congelamentos de consultas no MariaDB

Alguma ideia de como evitar esse problema?

ADD : fully_pingdefinição de tabela

CREATE TABLE `fully_ping` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `devid` varchar(255) NOT NULL,
  `appid` int(11) NOT NULL DEFAULT 1,
  `firstping_time` datetime DEFAULT NULL COMMENT 'UTC',
  `lastping_time` datetime NOT NULL COMMENT 'UTC',
  `message` mediumtext NOT NULL,
  `pass` varchar(255) DEFAULT NULL,
  `ip` varchar(255) DEFAULT NULL,
  `serial` varchar(255) DEFAULT NULL,
  `counter` int(11) NOT NULL DEFAULT 0,
  `version` int(11) DEFAULT NULL,
  `tls_version` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `devid` (`devid`(191)),
  KEY `appid` (`appid`),
  KEY `lastping_time` (`lastping_time`),
  KEY `counter` (`counter`),
  KEY `serial` (`serial`),
  CONSTRAINT `fully_ping_ibfk_1` FOREIGN KEY (`appid`) REFERENCES `fully_apps` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=180169 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_520_ci

Preciso de alguns conselhos. Atualizei meu cluster Cassandra que tinha 7 nós no Ubuntu 22.04 de 4.0.5 para 4.1.7. Como fiz isso:

• parou Cassandra, passos: nodetool drain, nodetool stopdaemon
• editado /etc/apt/sources.list.d/cassandra.sources.list, substituído deb http://www.apache.org/dist/cassandra/debian 40x main para deb https://debian.cassandra.apache.org 41x main
• atualização: apt-get install --only-upgrade Cassandra
• reiniciado systemctl restart Cassandra

Continuei para cada nó. E depois disso recebi o aviso:

WARN  08:50:08,758 [dynamic_snitch_reset_interval_in_ms, tracetype_query_ttl, request_timeout_in_ms, row_cache_size_in_mb, counter_write_request_timeout_in_ms, column_index_size_in_kb, trickle_fsync_interval_in_kb, cas_contention_timeout_in_ms, key_cache_size_in_mb, range_request_timeout_in_ms, enable_transient_replication, dynamic_snitch_update_interval_in_ms, column_index_cache_size_in_kb, write_request_timeout_in_ms, index_summary_resize_interval_in_minutes, permissions_validity_in_ms, max_hint_window_in_ms, enable_user_defined_functions, enable_sasi_indexes, read_request_timeout_in_ms, enable_drop_compact_storage, enable_legacy_ssl_storage_port, credentials_validity_in_ms, batch_size_warn_threshold_in_kb, index_summary_capacity_in_mb, commitlog_sync_period_in_ms, batchlog_replay_throttle_in_kb, windows_timer_interval, enable_scripted_user_defined_functions, commitlog_segment_size_in_mb, sstable_preemptive_open_interval_in_mb, tracetype_repair_ttl, roles_validity_in_ms, enable_materialized_views, prepared_statements_cache_size_mb, hinted_handoff_throttle_in_kb, compaction_large_partition_warning_threshold_mb, truncate_request_timeout_in_ms, slow_query_log_timeout_in_ms, hints_flush_period_in_ms, counter_cache_size_in_mb, max_hints_file_size_in_mb, compaction_throughput_mb_per_sec, batch_size_fail_threshold_in_kb] parameters have been deprecated. They have new names and/or value format; For more information, please refer to NEWS.txt

Como posso ver na documentação https://cassandra.apache.org/doc/4.1/cassandra/configuration/cass_yaml_file.html, devo comentar esses parâmetros em cassandra.yaml:

• intervalo_de_reinicialização_do_informador_dinâmico_em_ms
• tracetype_query_ttl
• tempo_limite_de_solicitação_em_ms
• tamanho_do_cache_de_linha_em_mb
• tempo_limite_de_solicitação_de_contra_escrita_em_ms
• tamanho_do_índice_da_coluna_em_kb
• intervalo_de_fsync_gotejamento_em_kb
• tempo_limite_de_contenção_cas_em_ms
• tamanho_do_cache_de_chaves_em_mb
• intervalo_tempo_limite_de_solicitação_em_ms
• habilitar_replicação_transitória
• intervalo_de_atualização_do_informador_dinâmico_em_ms
• tamanho_do_cache_do_índice_da_coluna_em_kb
• tempo_limite_de_solicitação_de_gravação_em_ms
• intervalo_de_redimensionamento_do_índice_resumo_em_minutos
• permissões_validade_em_ms
• max_hint_janela_em_ms
• habilitar_funções_definidas_pelo_usuário
• habilitar_índices_sasi
• tempo_limite_de_solicitação_de_leitura_em_ms
• enable_drop_compact_storage
• enable_legacy_ssl_storage_port
• validade_de_credenciais_em_ms
• limite_de_aviso_de_tamanho_de_lote_em_kb
• índice_resumo_capacidade_em_mb
• período_de_sincronização_de_log_de_commit_em_ms
• batchlog_replay_acelerador_em_kb
• intervalo_do_temporizador_do_windows
• habilitar_funções_definidas_pelo_usuário_com_script
• tamanho_do_segmento_do_commitlog_em_mb
• tracetype_repair_ttl
• validade_de_papéis_em_ms
• habilitar_visualizações_materializadas
• tamanho_do_cache_de_instruções_preparadas_mb
• hinted_handoff_throttle_in_kb
• compactação_partição_grande_aviso_limite_mb
• truncar_tempo_limite_de_solicitação_em_ms
• tempo_limite_do_log_de_consulta_lenta_em_ms
• dicas_período_de_descarga_em_ms
• tamanho_do_cache_do_contador_em_mb
• max_hints_tamanho_do_arquivo_em_mb
• compactação_rendimento_mb_por_seg
• limite_de_falha_de_tamanho_de_lote_em_kb

E sstable_preemptive_open_interval_in_mbmudar parasstable_preemptive_open_interval

Está certo?

Tenho uma tabela Produtos, 2 opções:

1. Deixe o usuário digitar o PK porque alguns usuários podem inserir códigos de barras ou não (nesse caso, o aplicativo deixará o usuário livre para inserir qualquer coisa, por exemplo, suas próprias convenções de código, como Oreo Icecream IC-O). Obviamente, preciso adicionar algumas validações para evitar PK com milhares de caracteres e muito mais.

2. Use o PK de incremento automático e crie outro campo para um "SecondaryCode", mas para o usuário esta será a chave primária, algumas validações para SecondaryCode aqui também e isso parece estranho usar um SecondaryCode como um PK.

Existe alguma razão muito ruim para não escolher a primeira opção? Teoricamente é bom e mais fácil de gerenciar, mas não me sinto confortável em expor algo importante como uma chave primária. Talvez eu esteja esquecendo de algo óbvio.

Onde posso obter o software Oracle Grid para executar ASM no Oracle 23c? Eu fiz isso para 19 e outros, mas não consigo encontrar o Grid para 23ai.

Este é o esquema com o qual estou trabalhando:

Aqui está o DBML para recriar em https://dbdiagram.io/d :

Table University {
  ID integer [primary key]
}

Table Professor {
  ID integer [primary key]
  UniversityID integer [primary key, ref: > University.ID]
}

Table Class {
  ID integer [primary key]
  UniversityID integer [primary key, ref: > University.ID]
  ProfessorID integer [null]
}

Ref: Class.(ProfessorID, UniversityID) - Professor.(ID, UniversityID)

Meu objetivo:

• Uma universidade pode ter várias turmas e professores.
• Uma classe pode ter um ou nenhum professor.
• A exclusão de uma universidade exclui todos os seus professores e turmas
• Excluir um Professor define Class.ProfessorID como NULL

O último objetivo está nos causando problemas. O SQL Server impede a adição de outra restrição de chave estrangeira em cascata devido a múltiplos caminhos em cascata, e um gatilho não pode funcionar porque:

1. a consulta de exclusão é rejeitada devido à restrição de chave estrangeira no Professor, portanto, um gatilho FOR DELETE nunca será executado
2. O SQL não pode criar um INSTEAD OF DELETE devido ao relacionamento em cascata com a Universidade

Como posso conseguir isso?

No livro que estou lendo atualmente, esta tabela é mencionada como um exemplo do que podemos fazer se uma tabela atende ao BCNF, mas ainda tem redundâncias. Em seguida, menciona que uma solução são matrizes. Mas essa tabela está mesmo no BCNF? Não há dependências funcionais de Language -> PersNr e de Programming -> PersNr. Ambos os atributos não são superchaves, pois não identificam as linhas de forma única. Então, eles quebram o BCNF na minha visão. Ou estou entendendo errado alguma coisa?