Sam's questions

Eu tenho uma tabela chamada visitsque está estruturada assim:

+----+--------------+-------------+
| id | name         | visitor_id  |
|----+--------------+-------------+
| 1  | event1       | 1           |
| 2  | event2       | 2           |
+----+--------------+-------------+

Eu tenho uma tabela chamada paramsque está estruturada assim:

+----+--------------+---------------+---------------+
| id | a_key        | a_value       | visit_id      |
|----+--------------+---------------+---------------+
| 1  | key1         | value1        | 1             |
| 2  | key2         | value2        | 1             |
| 3  | key3         | value3        | 1             |
| 4  | key1         | value1        | 2             |
| 5  | key2         | value2        | 2             |
+----+--------------+---------------+---------------+

Esta consulta procura visitas com parâmetros que são 'key1' e 'value1'.

select *
from visits
right join params as p on p.visit_id = visits.id
where a_key = 'key1' and a_value = 'value1'

Eu preciso escrever uma consulta que me dará todas as visitas que possuem parâmetros 'key1', 'value1' e também 'key3', 'value3'. Neste caso retornaria apenas a visita 1.

Qual é a maneira mais eficiente de conseguir isso?

Pensei em juntar os parâmetros novamente, mas não me parece a melhor solução.

Aqui está em um violino:

http://sqlfiddle.com/#!15/06773/5

Eu tenho uma seleção simples distinta em alguns dados de séries temporais:

SELECT DISTINCT user_id
FROM events
WHERE project_id = 6
AND time > '2015-01-11 8:00:00'
AND time < '2015-02-10 8:00:00';

E leva 112 segundos. Aqui está o plano de consulta:

http://explain.depesz.com/s/NTyA

Meu aplicativo tem que realizar muitas operações distintas e contagens como esta. Existe uma maneira mais rápida de obter esse tipo de dados?

Eu tenho uma tabela (t0), no meu banco de dados Postgres, com dados mais ou menos assim:

t1_id  t2_id
1      1      
2      1
2      1
4      null
4      null
5      null

E eu tenho uma consulta para retornar meus resultados desejados de:

t1_id  t2_id
1      1
4      null
5      null

Minha consulta é mais ou menos assim:

(
  SELECT DISTINCT ON (t2_id) t1_id, t2_id
  FROM t0
  WHERE t2_id IS NOT NULL
)
UNION ALL
(
  SELECT DISTINCT ON (t1_id) t1_id, t2_id
  FROM t0
  WHERE t2_id IS NULL
)

Existe uma maneira mais rápida de fazer uma operação como essa? Não é tão ruim, mas estou fazendo isso em vários lugares (com junções) e todas essas consultas repetidas parecem desacelerar um pouco as coisas. Parece que deve haver uma maneira melhor.

Aqui está a consulta em forma de violino: http://sqlfiddle.com/#!15/d41d8/3603