All perguntas(dba)

Eu precisaria executar esse tipo de lógica de forma serializável:

a tabela de contas possui colunas: 'accountName', 'location', 'worth', ...
Suponha que não exista nenhuma chave exclusiva.

Algumas contas estão logicamente (de acordo com uma aplicação) em um mesmo grupo.

Exemplo:

accountNameOne - grupo1 accountNameTwo - grupo1

contaNewOne - grupo2 contaNewTwo - grupo2

Existem muitos aplicativos clientes tentando inserir um membro da conta de seu grupo simultaneamente. Quero ter a garantia de inserir apenas uma conta por grupo.

BEGIN;

select *
from account 
where accountName in (list of account names inside a group)

-- if result is not empty exit there's already an account of the group
-- otherwise we want to insert it

INSERT INTO account (accountName, column2, column3, ...)
VALUES ('accountInAGroup', value2, value3, ...);

COMMIT;

Pelo que eu sei, o nível de isolamento de leituras repetíveis não pode ajudar nisso, basicamente fico usando SERIALIZABLE, eu acho.

Você pode me ajudar a entender se meu raciocínio aqui está correto? As leituras repetíveis realmente não são suficientes para isso?

Tenho uma pergunta simples, mas não consegui encontrar uma resposta/explicação direta. Desculpe se estiver duplicado

Quero construir uma tabela de pontuação para um pequeno jogo de perguntas e respostas onde os usuários recebem perguntas e podem estar certos ou errados. Então, acho que tenho 2 opções, ou uma tabela com 1 linha = 1 resposta do usuário, assim:

Ou uma tabela com 1 linha = 1 pontuação global do usuário:

Tenho praticamente nenhuma experiência com otimização de banco de dados/sql, então não sei qual é o mais eficiente.

Aqui está meu processo de pensamento:

Primeira opção : Melhor(?)/Mais rápido(?) para adicionar/atualizar uma pontuação porque não me importo com o estado atual da tabela, só preciso inserir uma linha Mas, para obter a pontuação global de um usuário, eu precisaria de um pesado (?) consulta como

SELECT SUM(certo), SUM(errado) WHERE userId = x;

Como eu gostaria de mostrar a pontuação global de um usuário em cada página/solicitação, sinto que essa não é a escolha inteligente. Além disso, como 1 linha = 1 resposta do usuário, a tabela pode ficar muito grande.

Primeira opção : Mais lento(?) para adicionar uma pontuação, pois teria que atualizar uma linha existente. Significa SELECT e depois UPDATE, em cada resposta. Não é particularmente o meu caso, mas esta opção é menos flexível, pois - ao contrário da primeira opção - não poderei armazenar qual pergunta foi respondida correta/incorretamente. Mas, com isso posso obter a pontuação total de um usuário sem uma consulta pesada. Seria melhor se uma consulta UPDATE pudesse retornar a linha resultante, então não preciso UPDATE e depois SELECT para mostrar.

Por último, se você tiver a gentileza de dedicar algum tempo para me responder, poderia explicar brevemente um ou outro é tecnicamente melhor e como posso testá-lo (existe algum tipo de ferramenta/procedimento)

Obrigado

Estamos implementando o SQL Server Always Encrypted em nosso ambiente de 2019. Fizemos vários POCs bem-sucedidos nos últimos meses, mas ao migrar a solução para Prod, eu esperava usar uma CA confiável pública para os certificados. Mas agora, revisando aproximadamente 10 tutoriais de AE ​​na web, incluindo as instruções oficiais da Microsoft, percebi que o uso de uma CA confiável pública nunca é mencionado... nunca... de forma alguma. Há até um artigo aqui perguntando se o uso de um certificado CA confiável adiciona algum benefício, e é sugerido que isso não aconteça.

Estou tentando satisfazer todas as nossas iniciativas de segurança que estão sendo implementadas em toda a empresa, então acho que estou tentando encontrar algum tipo de resposta padrão que possa apontar.

Tenho falado sobre como os certificados autoassinados estão sujeitos a ataques man-in-the-middle, mas acho que estou começando a perceber que isso se aplica apenas às conexões SQL que estão sendo feitas e a quaisquer dados que fluam por meio dessa conexão (porque nas tabelas os dados não são criptografados e o SSL os criptografa). Mas com o AE, os dados no banco de dados já são simplesmente uma string criptografada.

O mesmo acontece com a natureza de uma solução Always Encrypted, se feita onde os certificados autoassinados nunca são feitos ou residem no mesmo servidor que contém os dados, impede quaisquer ataques MIM? O simples uso de certificados autoassinados é a maneira "padrão" aceita de fazer isso? Pensando bem, acredito que a resposta seja sim, mas gostaria apenas de algum tipo de resposta "oficial" haha.

Existem muitos nomes de arquivos que começam com T

(T14_xxxxxxxx.1, T14_xxxxxxxx.2 .. T14_xxxxxxxx.18)

no diretório base postgresql para um banco de dados.

O tamanho deste banco de dados no diretório base é de 500 GB com esses arquivos. Após reiniciar o postgresql, esses arquivos desapareceram e o tamanho do banco de dados no diretório base/diminuiu 200 GB.

Eu li os seguintes sites. Mas não encontrei nada sobre esses arquivos:

https://www.postgresql.org/docs/current/storage-file-layout.html#:~:text=For%20each%20database%20in%20the,system%20catalogs%20are%20stored%20there.>

Também usei pg_relation_filepath ou selecionei a tabela pg_class. Não encontrei nada sobre esses arquivos.

O que são esses arquivos grandes no diretório “base”? Esses são arquivos de cache? como o aplicativo poderia ocorrer esses arquivos?

Devo alterar o parâmetro "idle_in_transaction_session_timeout" no meu postgresql RDS.

Como eu sei com set command("SET idle_in_transaction_session_timeout=5s") irei alterá-lo apenas no nível da sessão. Mas preciso alterá-lo permanentemente em todos os bancos de dados. Não consigo encontrar comando para fazer isso.

O tamanho de uma torrada de mesa vai de 7,5 Go para 9,2 Go em uma hora. A atividade normal do banco de dados parece não ser responsável por isso: não há mais consultas do que o normal. Para ser a causa, seria necessária uma quantidade maior de solicitações adicionais do que as que suportamos.

A partida única é um aspirador automático que funcionou mais cedo.

É possível que o tamanho de uma torrada de mesa aumente depois de um aspirador automático, por algum motivo?

Eu tenho algum procedimento sql (MSSQL 2019), se relevante

Create PROCEDURE [dbo].[test] @tmp varchar(32)  AS
print @tmp

por que quando eu faço

EXEC    @return_value = [dbo].[test]
        @tmp = N'SSL99999999999999999999999999999900000006785999999999999999'

Vejo que usa substring de 32 caracteres em @tmp? SSL99999999999999999999999999999 E não há exceção de que strings ou dados binários seriam truncados como eu esperava?

Posso ativar esse comportamento? eu precisaria disso se possível ;)

Obrigado e cumprimentos!

Não entendo por que essas funções se comportam de maneira diferente. O fato de terem uma aridade diferente não deveria afetar minha capacidade de citá-los.

janus@janus-ux305ca ~ % psql
psql (14.11 (Debian 14.11-1.pgdg110+1))
Type "help" for help.

janus=> select least(1,2);
 least 
-------
     1
(1 row)

janus=> select "least"(1,2);
ERROR:  function least(integer, integer) does not exist
LINE 1: select "least"(1,2);
               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
janus=> select "count"(1);
 count 
-------
     1
(1 row)

Qual é a terminologia correta que explica a diferença de comportamento?

O que é isso

Tenha muitas histórias (com muitas falas em cada uma). Cada um traduzido em vários idiomas. Cada idioma tem muitos sotaques. Eu gostaria de oferecer ao usuário a escolha dos idiomas (pode escolher muitos dos quais abrangem todas as histórias) e depois escolher exatamente um sotaque de todos os sotaques de cada idioma.

Exemplo de dados

Suponha que temos 2 histórias, cada uma traduzida em 3 idiomas e cada idioma tem 5 sotaques (áudio vocal)

Requisito de acesso a dados

Agora pense que o usuário escolheu
o Idioma 2 com acento 1 e o Idioma 3 com acento 4

Agora o áudio será reproduzido como a seguir

1. Story 1 > Line 1 from Language 2 of Accent 1 então Story 1 > Line 1 from Language 3 of Accent 4
2. Story 1 > Line 2 from Language 2 of Accent 1 então `História 1> Linha 2 do Idioma 3 do Sotaque 4
3. // continua até o final da história e então começa uma nova história e joga assim

Possíveis entidades/tabelas

1. Histórias
2. Linhas
3. línguas
4. Acentos
5. Áudios

Obviamente eu inventei isso, preciso de ajuda aqui.

Onde a ajuda é necessária

Para cumprir o uso pretendido dos dados, como deveriam ser as tabelas, quais seriam as relações entre elas (como stories hasMany Languagescoisas assim).
E ...
Como posso consultar dados para oferecer ao usuário sobre a 1ª seleção na seção "O que é" no topo.

Sobre mim: tenho experiência em desenvolvimento de software, mas não tanto em design de esquemas complexos. Eu (acho) posso lidar com coisas de banco de dados bastante complexas, mas obviamente não isso.

Info: estou fazendo em MySQL (MariaDB)

Estou tentando forçar os arquivos WAL a serem descarregados no disco para que eu possa copiá-los em outro lugar. Acredito CHECKPOINTque seja o comando no qual estou interessado, mas parece não funcionar.

Eu tenho um contêiner docker do Postgres em execução e uso o adminer para adicionar novos registros a uma tabela que criei. Tentei liberar os arquivos WAL manualmente:

$ docker exec db psql pgtest -U postgres -c "CHECKPOINT;"
CHECKPOINT

Acredito que deveria liberar os dados e veria um novo arquivo WAL criado, porém não há arquivos novos - vejo apenas os arquivos WAL antigos. Quando eu reinicio o contêiner:

$ docker restart db
db

Então vejo um novo arquivo WAL.

Esta é a aparência do meu postgresql.conf:

#------------------------------------------------------------------------------
# WRITE AHEAD LOG
#------------------------------------------------------------------------------

# - Settings -

wal_level = logical                   # minimal, replica, or logical
                                      # (change requires restart)
fsync = on                            # flush data to disk for crash safety
                                      # (turning this off can cause
                                      # unrecoverable data corruption)
synchronous_commit = local            # synchronization level;
                                      # off, local, remote_write, remote_apply, or on
wal_sync_method = fsync               # the default is the first option
                                      # supported by the operating system:
                                      #   open_datasync
                                      #   fdatasync (default on Linux)
                                      #   fsync
                                      #   fsync_writethrough
                                      #   open_sync
#full_page_writes = on                # recover from partial page writes
#wal_compression = off                # enable compression of full-page writes
#wal_log_hints = off                  # also do full page writes of non-critical updates
                                      # (change requires restart)
#wal_buffers = -1                     # min 32kB, -1 sets based on shared_buffers
                                      # (change requires restart)
#wal_writer_delay = 200ms             # 1-10000 milliseconds
wal_writer_flush_after = 1MB          # measured in pages, 0 disables

#commit_delay = 0                     # range 0-100000, in microseconds
#commit_siblings = 5                  # range 1-1000

# - Checkpoints -

#checkpoint_timeout = 1min            # range 30s-1d
#max_wal_size = 1GB
#min_wal_size = 4MB
#checkpoint_completion_target = 0.5   # checkpoint target duration, 0.0 - 1.0
#checkpoint_flush_after = 256kB       # measured in pages, 0 disables
#checkpoint_warning = 30s             # 0 disables

# - Archiving -

archive_mode = on                     # enables archiving; off, on, or always
                                      # (change requires restart)
archive_command = 'test ! -f /var/lib/postgresql/data/wal/%f && cp %p /var/lib/postgresql/data/wal/%f'
                                      # placeholders: %p = path of file to archive
                                      #               %f = file name only
                                      # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
#archive_timeout = 0                  # force a logfile segment switch after this
                                      # number of seconds; 0 disables