Eu sei que esse numericé um tipo de dado "exato", que representa números com a maior precisão possível para que não haja erros de ponto flutuante, como nos tipos de dados floatou real.
Mas e quanto a numeric(p,s)? Ele deve aproximar um número por causa da escala fixa, mas ele tem imprecisões de ponto flutuante ou é “seguro”? Não consegui encontrar nenhuma informação sobre ele. Talvez seja óbvio, mas eu gostaria de entender melhor esse aspecto.
Me deparei com uma situação estranha que me deu uma grande dor de cabeça e depois de resolver também gostaria de entender o PORQUÊ.
Basicamente, um usuário tinha todos os privilégios necessários para executar um "gatilho" (na verdade era uma restrição de chave estrangeira com um ON DELETE CASCADE associado) e todos os privilégios em todos os objetos que foram tocados pelo próprio gatilho, MAS quando ele executou o gatilho, ele realmente usou os privilégios de proprietário do objeto e não os seus. O proprietário tinha menos privilégios do que o usuário e por isso ocorreu um erro realmente misterioso.
Entendo que é complicado entender o que quero dizer, então criei um exemplo prático que espero esclarecer. O esquema que criei é um exemplo de brinquedo do tipo spotify, onde existem usuários e artistas, e os usuários têm listas de artistas que seguem.
Execute todas as operações a seguir com um superusuário (apenas para simplificar)
-- ALL DATA
create schema website;
create table public.artists (
id_artist serial primary key,
name text not null unique
);
insert into public.artists (name)
values ('Heilung'), ('Rammstain'), ('Iron Maiden');
create table website.users (
id_user serial primary key,
email text not null unique
);
insert into website.users (email)
values ('[email protected]'), ('[email protected]');
create table website.users_list (
id_user int not null,
id_artist int not null,
CONSTRAINT user_fk FOREIGN KEY (id_user) REFERENCES website.users (id_user),
CONSTRAINT artist_fk FOREIGN KEY (id_artist) REFERENCES public.artists (id_artist) ON DELETE CASCADE);
insert into website.users_list (id_user,id_artist)
values (1,1), (1,2), (1,3), (2,1), (2,3);
-- USERS AND PRIVILEGES
create user jenny with password '123';
create user tommy with password '123';
-- tommy is owner but has zero privileges
alter table website.users_list owner to tommy;
-- jenny is not owner but has all privileges
grant usage, create on schema website to jenny;
grant all on all tables in schema website,public to jenny;
grant usage on all sequences in schema website to jenny;
Em seguida, execute essas consultas usando o usuário Jenny, uma por uma.
--1)
select *
from website.users_list ul;
--2)
select *
from artists a;
--3)
delete from artists
where id_artist = 3;
A primeira e a segunda consulta funcionam normalmente, pois Jenny pode fazer SELECT em website.users_list e public.artists. Ela obviamente tem privilégio de uso no site do esquema. Mas o terceiro ela não pode fazer. Dá esse erro aparentemente sem sentido.
ERROR: permission denied for schema website
Quando ela faz um DELETE em public.artists, ela na verdade aciona a restrição de chave estrangeira de website.users_list, portanto, todas as linhas relacionadas ao artista com id_artist = 3 devem ser eliminadas de website.users_list. MAS naquele momento ela está usando os privilégios do tommy (dono do site.users_list) que como vimos acima NÃO tem o privilégio de USAGE no esquema do site, dando o erro estranho.
Alguém pode me explicar por que isso acontece? O que o proprietário da tabela tem a ver com a execução de um gatilho onde o usuário tinha todos os privilégios necessários? Acho isso tão confuso e francamente um pesadelo para depurar (infelizmente falo por experiência própria).
Digamos que eu tenha essas duas tabelas
CREATE TABLE users (
id_user serial primary key,
name text NOT NULL
);
CREATE TABLE useless_table (
id serial primary key,
id_user int4 NOT NULL,
CONSTRAINT useless_table_id_user_fk FOREIGN KEY (id_user) REFERENCES users(id_user)
);
usersé a tabela mais congestionada em todo o banco de dados, com consultas ininterruptas, mesmo as longas e importantes, então simplesmente não consigo matar todas elas. Quero descartar useless_tableisso, como você pode ver, tem uma referência de chave estrangeira userse toda vez que eu lanço o DROPcomando, ele bloqueia mesmo com o mais simples SELECTativado users(não há nenhuma consulta em andamento useless_table). Eu até tentei soltar a chave estrangeira, useless_tablemas ela fica com os mesmos bloqueios da queda da tabela.
Talvez eu seja um sonhador, mas tem como não travar com tudo e simplesmente cair useless_table?
Estou pensando em NOT VALIDchaves estrangeiras, desabilitando gatilhos, restrições adiáveis ou coisas desse tipo, mas não sou muito experiente sobre eles e não quero fazer bagunça usando-os.
Alguma sugestão?
Eu li a resposta do @Mike para Como saber se o ajuste do banco de dados é frutífero (PostgreSQL) , e esse é o tipo de abordagem em que estou pensando para monitorar o desempenho do meu banco de dados (de um aplicativo da Web, muitas conexões, gravações pesadas e lê o tempo todo, dados muito dinâmicos).
A abordagem resume-se assim: quero saber se meu banco de dados pode acompanhar a carga de trabalho, se tem a mesma prontidão ao longo do tempo e, finalmente, se meu ajuste e limpeza são úteis. Portanto, para um indicador geral de bem-estar, monitorar o tempo de consulta (para consultas representativas usadas pelo aplicativo da Web e fluxos de dados) parece sensato e compacto para mim (o tempo de consulta aumenta sem alterações substanciais => o desempenho é degradante). Mas minha pergunta é, será? Além da pergunta vinculada, não encontrei outra fonte para tal abordagem, e ainda tenho alguns buracos sobre como implementar tudo isso, portanto, saber mais de outros exemplos/experiências ou manuais seria muito útil. Mesmo sabendo que essa abordagem não vale a pena, seria interessante.
E para sua informação, eu li sobre pgbench, mas parece tão asséptico para mim, quero dizer, certamente fornece um ponto de referência, mas o que diz sobre minhas tabelas , meus índices , sobre o ambiente vivo que é meu banco de dados ? (Espero que faça sentido para você o que quero dizer com isso) Talvez eu esteja olhando pgbenchda maneira errada, mas é exatamente isso que quero descobrir!
Nota: Eu trabalho com o Postgres, então uma resposta específica do Postgres seria incrível... mas não é necessária!
Eu tenho um sistema de muitos scripts de nós que lêem e/ou escrevem automaticamente em um banco de dados Postgres o tempo todo. Um desses scripts aleatoriamente obtém um deadlock. Eu gostaria de depurar isso, mas o problema é que não sei qual outra consulta causa o deadlock. (eu uso pg )
Então minha pergunta é:
Se eu pegar um erro como este
{ error: deadlock detected
at Connection.parseE (/data/jenkins/workspace/03-10-Lotti-watcher-lotti-mod/import/node_modules/pg/lib/connection.js:604:13)
at Connection.parseMessage (/data/jenkins/workspace/03-10-Lotti-watcher-lotti-mod/import/node_modules/pg/lib/connection.js:403:19)
at Socket.<anonymous> (/data/jenkins/workspace/03-10-Lotti-watcher-lotti-mod/import/node_modules/pg/lib/connection.js:123:22)
at Socket.emit (events.js:197:13)
at addChunk (_stream_readable.js:288:12)
at readableAddChunk (_stream_readable.js:269:11)
at Socket.Readable.push (_stream_readable.js:224:10)
at TCP.onStreamRead [as onread] (internal/stream_base_commons.js:150:17)
name: 'error',
length: 336,
severity: 'ERROR',
code: '40P01',
detail:
'Process 2376 waits for ShareLock on transaction 55837412; blocked by process 22585.\nProcess 22585 waits for ShareLock on transaction 55837411; blocked by process 2376.',
hint: 'See server log for query details.',
position: undefined,
internalPosition: undefined,
internalQuery: undefined,
where: 'while locking tuple (226684,50) in relation "lotti"',
schema: undefined,
table: undefined,
column: undefined,
dataType: undefined,
constraint: undefined,
file: 'deadlock.c',
line: '1146',
routine: 'DeadLockReport' }
posso obter a consulta e/ou usuário do outro processo para isolar e identificar o problema? Ou qualquer coisa assim, se fizer sentido.
Eu vi essa pergunta Colunas Bit vs. Booleanas .
Estou me perguntando o mesmo para o Postgres: uma coluna inteira de um dígito ocupa o mesmo espaço em disco de uma booleana? Em tabelas grandes (~ 50 colunas x ~ 50 milhões de linhas), qual delas tem melhor desempenho? Como posso descobrir isso?