L'obtention de secondes entre les deux Oracle Horodateurs

Tom Kyte suggère à utiliser EXTRAIT pour obtenir la différence:

extract( day from (x-y) )*24*60*60+
extract( hour from (x-y) )*60*60+
...

Cela semble être plus difficile à lire et plus lent que cela, par exemple:

( CAST( x AS DATE ) - CAST( y AS DATE ) ) * 86400

Alors, quel est le moyen d'obtenir la différence entre les deux Horodateurs en quelques secondes? Merci!

Personnellement, je préfère 24*60*60 à 86400. Même un non-technophile reconnaîtrait 24 heures dans une journée et que les années 60 liées à des minutes et des secondes.
C'est certainement vrai, merci!
Veuillez noter que les résultats ne sont pas identiques (voir mon commentaire ci-dessous)
La méthode avec la fonte peut produire de mauvais résultats en raison de "l'heure d'été" dans des fuseaux horaires différents. L'extrait le gère correctement.

OriginalL'auteur Peter Lang | 2010-10-18

oracle timestamp

15

"Meilleures Pratiques"

Quoi que vous fassiez, l'envelopper dans une fonction, par exemple seconds_between (from_date, to_date) - n'a pas d'importance comment il le fait (choisir la méthode la plus efficace) - ensuite, il sera parfaitement évident que votre code est en train de faire.

Performance

J'ai testé les deux méthodes sur les 11gR1 sur mon ordinateur portable (windows xp) avec le cas de test ci-dessous. Il semble que le CAST option est la plus rapide. (t1 est la base, t2 utilisé le extract méthode, t3 utilisé le cast méthode)
```
t1 (nothing) 3
t2 (extract) 338
t3 (cast)    101

t1 (nothing) 3
t2 (extract) 336
t3 (cast)    100
```
Script de Test
```
declare
 x TIMESTAMP := SYSTIMESTAMP;
 y TIMESTAMP := TRUNC(SYSDATE);
 n PLS_INTEGER;
 lc CONSTANT PLS_INTEGER := 1000000;
 t1 PLS_INTEGER;
 t2 PLS_INTEGER;
 t3 PLS_INTEGER;
begin
 t1 := DBMS_UTILITY.get_time;
 for i in 1..lc loop
  n := i;
 end loop;
 t1 := DBMS_UTILITY.get_time - t1;
 t2 := DBMS_UTILITY.get_time;
 for i in 1..lc loop
  n := extract(day from (x-y))*24*60*60
     + extract(hour from (x-y))*60*60
     + extract(minute from (x-y))*60
     + extract(second from (x-y));
 end loop;
 t2 := DBMS_UTILITY.get_time - t2;
 t3 := DBMS_UTILITY.get_time;
 for i in 1..lc loop
  n := ( CAST( x AS DATE ) - CAST( y AS DATE ) ) * 86400;
 end loop;
 t3 := DBMS_UTILITY.get_time - t3;
 dbms_output.put_line('t1 (nothing) ' || t1);
 dbms_output.put_line('t2 (extract) ' || t2);
 dbms_output.put_line('t3 (cast)    ' || t3);
end;
```
Alors que c'est un point important (+1), je suis actuellement à la recherche pour que la méthode plus efficace que de vous en parler 🙂
Il n'y a pas beaucoup de différence de test (par exemple, exécuter chacun quelques milliers de fois avec diverses entrées) et de voir.
là vous allez 🙂 j'espère que ça aide
Juste noter que le extract méthode comprend une fraction de seconde, alors que la cast méthode tronque.
Merci, j'avais déjà testé ces deux tentatives (ma question, dit que le premier est plus lent). Toujours curieux, si il y a d'autres moyens, ou si il y a une "bonne façon" de faire ça 🙂

OriginalL'auteur Jeffrey Kemp
8

Autres:

J'ai trouvé que cela fonctionne aussi bien pour obtenir la différence en quelques secondes, y compris millisecondes.

C'est même à épargner pour les fuseaux horaires avec "heure d'été", tandis que la méthode d'extraction aurait un problème.
Malheureusement, la différence entre t1 et t2 est limité pour que le résultat soit à droite. Casting les horodatages de format de date n'est pas une option parce que les fractions de secondes sont perdues.
```
select (sysdate + (t2 - t1)*1000 - sysdate) * 86.4 from 
(select  
    to_timestamp('2014-03-30 01:00:10.111','YYYY-MM-DD HH24:MI:SS.FF') at time zone 'MET' t1, 
    to_timestamp('2014-03-30 03:00:10.112','YYYY-MM-DD HH24:MI:SS.FF') at time zone 'MET' t2 
 from dual);
```
C'est un bon truc! Wrap que dans un round(), et vous êtes tous ensemble.

OriginalL'auteur user3820019
3

J'ai toujours utilisé la deuxième méthode c'est à dire de comparer les DATEs (qui vous donne le nombre de jours de différence, avec une partie fractionnaire), et de la multiplier par le facteur que vous voulez pour vous donner le nombre d'heures, de minutes, de secondes, ou quoi que ce soit.

Je pense que c'est bon, et facile à lire.

OriginalL'auteur Adrian Smith
1

Personnellement, je trouve:
```
extract(day from (x-y))*24*60*60 + ... + extract(second from (x-y))
```
plus claire dans le but de...
```
( CAST( x AS DATE ) - CAST( y AS DATE ) ) * 86400
```
pour obtenir la différence en quelques secondes.

Tom méthode prend un peu plus de frappes mais l'intention est claire.

OriginalL'auteur Nick Pierpoint

-3

to_number(to_char(t2, 'yyyymmddhh24missff')) - to_number(to_char(t1, 'yyyymmddhh24missff'))

Il en résultera une différence de 41 secondes entre 00:00:59 et 00:01:00.

OriginalL'auteur imaya

Vous devez vous connecter pour publier un commentaire.