oxfist's questions

Basicamente, quero atribuir o resultado de uma consulta a um atributo de tipo personalizado. No entanto, notei que a consulta diretamente do console do PostgreSQL foi de cerca de 0,071 ms e dentro da função foi de 0,400 ms e 0,170 ms após algumas chamadas. explain analyzeainda mostra o uso de índices no primeiro caso, mas não no segundo.

Aqui está o que estou fazendo.

CREATE OR REPLACE FUNCTION fun_isliked(
    par_client client.id%type,
    par_feed feed.id%type
)
RETURNS boolean
AS
$$
BEGIN
    RETURN (
        EXISTS(
            SELECT
                1
            FROM
                feedlike fl
            WHERE
                fl.client = par_client
                AND fl.feed = par_feed
                AND fl.state = 1
        )
    );
END;
$$ LANGUAGE plpgsql STABLE;

Aqui estão as saídas dos explain analyzedois casos descritos acima:

postgres=# explain analyze select exists (select 1 from feedlike where client = 13 and feed = 68 and state = 1);
                                                                  QUERY PLAN                                                                  
----------------------------------------------------------------------------------------------------------------------------------------------
 Result  (cost=8.30..8.31 rows=1 width=0) (actual time=0.037..0.037 rows=1 loops=1)
   InitPlan 1 (returns $0)
     ->  Index Scan using feedlike_client_feed_unique on feedlike  (cost=0.28..8.30 rows=1 width=0) (actual time=0.034..0.034 rows=1 loops=1)
           Index Cond: ((client = 13) AND (feed = 68))
           Filter: (state = 1)
 Total runtime: 0.086 ms

postgres=# explain analyze select * from fun_isliked(13, 68);
                                                QUERY PLAN                                                
----------------------------------------------------------------------------------------------------------
 Function Scan on fun_isliked  (cost=0.25..0.26 rows=1 width=1) (actual time=0.398..0.398 rows=1 loops=1)
 Total runtime: 0.416 ms

Qual é uma possível solução alternativa para obter efetivamente o mesmo tempo de execução dentro da função? É mesmo possível? Além disso, estou executando o PostgreSQL 9.3.

Descobri que essa pergunta no SO tinha o que eu precisava, mas depois de tentar de tudo na resposta selecionada e não ter sucesso em reduzir o tempo de execução, decidi fazer uma nova pergunta.

Estou escrevendo uma função PL/pgSQL que cria um cursor para uma consulta que preciso verificar se ela retorna algo.

O que estou fazendo é isso:

1. Execute a consulta
2. Verifique se ele retorna algo.
3. Caso contrário, duplique um parâmetro e execute a consulta novamente.
4. Caso contrário, retorne todas as linhas da consulta.

Achei que verificar se a consulta retornava algo com um cursor era a melhor escolha, pois é uma consulta muito longa (juntando 5 tabelas e muitas colunas) e SELECT ... INTOnão parecia certo, porque eu teria que criar uma TYPEvez que o consulta tem colunas de uma tabela e uma coluna para um cálculo de distância.

O problema é que atualmente estou usando o cursor apenas para verificar se a consulta retornou algo dentro de um loop onde eu abro e fecho. Depois que a consulta retorna algo, saio do loop e retorno a consulta. Eu posso dizer imediatamente que esta é uma solução feia para o que eu preciso. Talvez alguém possa me ajudar com esta questão.

Aqui está um código que mostra o que estou fazendo atualmente.

CREATE FUNCTION store_distance(
    latitude double precision,
    longitude double precision,
    radius double precision,
    tries integer
)
RETURNS TABLE(
    store_id store.id%type,
    store_name store.name%type,
    distance double precision
)
AS
$$
DECLARE
    cur_stores CURSOR FOR
        SELECT
            store.id,
            store.name,
            get_distance(latitude, longitude, store.latitude, store.longitude) distance
        FROM
            store
        WHERE
            store.latitude BETWEEN (latitude - radius) AND (latitude + radius)
            AND store.longitude BETWEEN (longitude - radius) AND (longitude + radius)
        ORDER BY
            distance ASC;
    count int := 0;
    storerow RECORD;
BEGIN
    LOOP
        IF count = tries THEN
            EXIT;
        END IF;
        OPEN cur_stores;
        FETCH cur_stores INTO storerow;
        IF FOUND THEN
            EXIT;
        END IF;
        radius := radius * 2;
        count := count + 1;
        CLOSE cur_stores;
    END LOOP;
    RETURN QUERY
    SELECT
        store.id,
        store.name,
        get_distance(latitude, longitude, store.latitude, store.longitude) distance
    FROM
        store
    WHERE
        store.latitude BETWEEN (latitude - radius) AND (latitude + radius)
        AND store.longitude BETWEEN (longitude - radius) AND (longitude + radius)
    ORDER BY
        distance ASC;
END;
$$ LANGUAGE PLPGSQL;

Portanto, meu objetivo é fornecer coordenadas, raio e número de tentativas e tentar encontrar lojas nessa caixa de pesquisa. Se nenhuma loja for encontrada, dobro o raio e tento novamente até que algo seja retornado pela consulta ou até que o número de tentativas seja atingido.
A RETURN TABLEparte é basicamente porque quero voltar a distância, então RETURN SETOF storenão adiantou.

Eu sei que \d table_namelista todas as colunas dessa tabela, mas existe uma maneira de listá-las em ordem alfabética?