Obtenez de l'intervalle en millisecondes

J'ai une procédure qui contient le code comme ceci:

processStart := current_timestamp;
-- run statement(s)
processEnd := current_timestamp;
elapsed := processEnd - processStart;
raise notice 'My Statement, elapsed time: %', elapsed;

L'idée est, je veux obtenir la quantité de temps nécessaire pour qu'une déclaration ou d'une collection d'instructions à exécuter.

Le problème est, il renvoie 00:00:00 pour subsecond des temps écoulés. J'ai vraiment envie de voir les millisecondes. Comment puis-je faire cela?

Il y a des questions et des réponses sur l'utilisation de EXTRACT et EPOCH, mais ce qui semble être à la "deuxième niveau", et qui n'est pas granulaire suffisant pour mes besoins.

Mise à JOUR

À l'aide de @twn08 réponse, j'ai finalement arrivés à la solution suivante:

J'ai déclaré les variables suivantes:

declare
    processStart timestamp;
    elapsed numeric(18,3);
    processFinish timestamp;

alors, avant de commencer le processus:

processStart := clock_timestamp();

après le processus est terminé, j'ai couru ce:

processFinish := clock_timestamp();
elapsed := cast(extract(epoch from (processFinish - processStart)) as numeric(18,3));
raise notice 'My Statement, elapsed time: % ms', elapsed;

cela a fonctionné à merveille.

Vous pouvez extraire millisecondes: SELECT EXTRACT(MILLISECONDS FROM Now());

OriginalL'auteur Jeremy Holovacs | 2013-05-30

  1. 16
    with t as
 (select
    Now() as tend, 
    Now() - interval '10 seconds 552 milliseconds' as tstart
 )

select
  extract('epoch' from tend)  - extract('epoch' from tstart) 
from 
  t

    Remarque:

    Pour la version 9.0+ que vous pouvez lire dans la documentation l'exemple suivant:

    SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2001-02-16 20:38:40.12-08');
Result: 982384720.12

    Avant 9.0 il est:

    SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2001-02-16 20:38:40-08');
Result: 982384720

    Sur cette base, il n'est pas clair que mon exemple de travail antérieures à la version 9.0

    Bien que cette réponse n'était pas très clair, ça m'a aidé à comprendre ce que je devais faire. Voir mon édité question pour le résultat final.
    FYI: EXTRACT(EPOCH FROM t) travaille certainement en 8.4.

    OriginalL'auteur Tomas Greif

  2. 3

    Voici un one-liner pour calculer le temps écoulé en millisecondes à partir d'un passé TIMESTAMP():

    SELECT ROUND((EXTRACT (EPOCH FROM now()) - EXTRACT (EPOCH FROM pg_last_xact_replay_timestamp())) * 1000) AS "replication_lag (ms)";

    L'exemple ci-dessus calcule le retard de réplication entre un principal et de veille serveur PostgreSQL, donc il suffit de remplacer pg_last_xact_replay_timestamp() avec votre TIMESTAMP.

    Pour voir ce qu'il fait un peu plus clairement:

    SELECT
    ROUND ((
        EXTRACT (EPOCH FROM now()) -
        EXTRACT (EPOCH FROM pg_last_xact_replay_timestamp())
    ) * 1000)
AS "replication_lag (ms)";

    De sortie:

     replication_lag (ms) 
----------------------
                  562
(1 row)

    OriginalL'auteur liquidki

  3. 2

    @TomasGreif réponse, j'ai fait une petite fonction datediff dans le cas où vous avez besoin de faire de la milliseconde datediffs souvent:

    create function datediff_ms(timestamptz, timestamptz) returns INTEGER as
$$
    begin
        return (EXTRACT('epoch' from $2) - EXTRACT('epoch' from $1)) * 1000;
    end;
$$ LANGUAGE plpgsql;

    Utilisation:

    select datediff_ms(time1, time2)
from sometables;

    OriginalL'auteur Shaul Behr