Tiago Stapenhorst Martins's questions

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)

A integridade referencial de FOREIGN KEYs no PostgreSQL pode ser desabilitada executando:

ALTER TABLE schema.my_table 
DISABLE TRIGGER ALL;

Mas infelizmente o comando também desabilitará todos os outros triggers presentes na tabela.

Tentei localizar o nome da chave estrangeira à pg_constraintvista, mas usá-lo no seguinte comando retorna um erro:

ALTER TABLE schema.my_table 
DISABLE TRIGGER id_fkey;

-- Returns
-- SQL Error [42704]: ERROR: trigger "id_fkey" for table "my_table" does not exist

Como a integridade referencial pode ser desabilitada no PostgreSQL sem desabilitar outros gatilhos?

Acabei de descobrir que alguns padrões específicos quando usados ​​com o operador de texto LIKE usam índices BTREE para acelerar as consultas, como:

• 'abc123' (texto sem curinga)
• 'abc%' (texto com apenas um curinga no final)

Qual é o equivalente do operador de texto LIKE usando um padrão com apenas um curinga '%'presente no final do padrão (como "a_column" LIKE 'abc%') usando apenas operadores maiores/menores/iguais?

Meu interesse é conseguir isso no PostgreSQL, mas essa pode ser uma pergunta padrão do SQL.

Como o PostgreSQL pode retornar uma lista dos valores de carimbo de data/hora mais antigos em uma tabela de medições de identificação do sensor?

Deixe-me explicar a situação com uma tabela de exemplo:

CREATE TABLE sensor_data(
sensor_id INTEGER,
time TIMESTAMPTZ,
value NUMERIC,
PRIMARY KEY (sensor_id, time)
)

Exemplo de tabela preenchida:

+-----------+------------------+-------+
| sensor_id |       time       | value |
+-----------+------------------+-------+
|         1 | 2018-01-01 00:00 |     1 |
|         1 | 2018-01-01 01:00 |     2 |
|         3 | 2018-01-01 03:00 |     4 |
|         3 | 2018-01-01 04:00 |     3 |
|         4 | 2018-01-01 03:00 |     5 |
|         4 | 2018-01-01 04:00 |     6 |
+-----------+------------------+-------+

Ao usar algo como sensor_id (1,3) dentro da consulta, quero que ele retorne algo assim:

+-----------+------------------+-------+
| sensor_id |       time       | value |
+-----------+------------------+-------+
|         1 | 2018-01-01 01:00 |     2 |
|         3 | 2018-01-01 04:00 |     3 |
+-----------+------------------+-------+

Como posso fazer isso em uma consulta usando o PRIMARY KEYíndice para acelerá-la?

Recentemente (2019-04-25) o governo brasileiro encerrou o uso do horário de verão em todo o país.

Em meu projeto atual, confio no PostgreSQL para fazer conversões e análises de fuso horário com base no horário de diferentes fusos horários e datas.

No que me diz respeito, o PostgreSQL implementa o horário de verão e os fusos horários através do banco de dados Olson.

1) O PostgreSQL (versão 11, por exemplo) está atualizado com a nova regra de horário de verão no Brasil?

2) Se não estiver atualizado, como posso corrigi-lo? Existe algum calendário/programação de patch padrão do PostgreSQL nesse sentido?

Tenho a seguinte tabela:

╔════╦═══════════╦═════════════════════╦═══════╗
║ id ║ sensor_id ║        time         ║ value ║
╠════╬═══════════╬═════════════════════╬═══════╣
║  1 ║         1 ║ 2018-01-01 00:00:01 ║     1 ║
║  2 ║         1 ║ 2018-01-01 00:00:02 ║     2 ║
║  3 ║         1 ║ 2018-01-01 00:00:03 ║     3 ║
║  4 ║         1 ║ 2018-01-01 00:00:03 ║     4 ║
║  5 ║         1 ║ 2018-01-01 00:00:04 ║     3 ║
║  6 ║         2 ║ 2018-01-01 00:00:01 ║     1 ║
║  7 ║         2 ║ 2018-01-01 00:00:01 ║     2 ║
║  8 ║         2 ║ 2018-01-01 00:00:02 ║     3 ║
║  9 ║         2 ║ 2018-01-01 00:00:03 ║     4 ║
║ 10 ║         2 ║ 2018-01-01 00:00:04 ║     5 ║
╚════╩═══════════╩═════════════════════╩═══════╝

CREATE TABLE sensor_time_series
(
    id SERIAL PRIMARY KEY,
    "time" TIMESTAMP NOT NULL,
    sensor_id INTEGER NOT NULL,
    value NUMERIC NOT NULL,
);

É uma tabela de séries temporais que representa o valor de um sensor em um momento específico . Sim, eu sei que é estranho que "time" não seja único dentro de cada "sensor_id", isso é um erro do dataset.

O que eu quero é fazer uma nova tabela/view com uma estrutura de gráfico, conectando cada amostra "sensor_id" ao seu sucessor em "time". A tabela deve ficar mais ou menos assim:

╔════════════╦══════════════╗
║ current_id ║ successor_id ║
╠════════════╬══════════════╣
║          1 ║           2  ║
║          2 ║           3  ║
║          2 ║           4  ║
║          3 ║           5  ║
║          4 ║           5  ║
║          6 ║           8  ║
║          7 ║           8  ║
║          8 ║           9  ║
║          9 ║          10  ║
╚════════════╩══════════════╝

CREATE TABLE sensor_time_series_graph
(
    current_id INTEGER,
    successor_id INTEGER,
    FOREIGN KEY (current_id) REFERENCES sensor_time_series(id),
    FOREIGN KEY (successor_id) REFERENCES sensor_time_series(id)
);

Ambas as colunas (current_id e successor_id) ID da FOREIGN KEY da primeira tabela Como posso criar algo assim no PostgreSQL 10?

Eu estava pesquisando as funções da janela do PostgreSQL e acho que elas podem me ajudar, mas ainda não percebi como.

Estou trabalhando no PostgreSQL e tenho uma tabela como esta chamada words_table:

Eu preciso de todas as palavras equivalentes (como software_design e software-design) para ter seu valor de mapa = para id_word equivalente de sua palavra. Em outras palavras, quero que todas as palavras softwaredesign, software_design, software.design... e assim por diante tenham o mesmo número na coluna do mapa (neste caso específico, um número de 1 a 10). O mesmo se aplica à engenharia_civil e ao Desenho Industrial.

Eu sei que isso envolve algumas expressões regulares e comparações que não diferenciam maiúsculas de minúsculas, mas estou preso na lógica SQL. Eu sei que essas expressões podem ser úteis:

regexp_replace(word, '(\.|:|,|&|-)','','g')

Para lidar com os separadores

lower(something)

Para lidar com a correspondência de maiúsculas e minúsculas ou

UPDATE words_table SET a.map = b.id_word WHERE word ILIKE something

... WHERE word ~* something

para correspondência insensível a maiúsculas e minúsculas.

Devo criar novas colunas com palavras regexp_replaced e fazer o mapeamento depois disso com algumas junções? Ou talvez algo com CamelCase e correspondência de sublinhado? Talvez funções? Qual é a solução ótima?