Discussion :

[alex_972]

Bonjour,

Je stocke des dates dans une table en Timestamp(3).

J'aimerais avoir la différence en secondes.

Actuellement, je fais comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
SELECT round(
  extract(day from (max(date) - min(date)))*86400+
  extract(hour from (max(date) - min(date)))*3600+
  extract(minute from (max(date) - min(date)))*60+
  extract(second from (max(date) - min(date)))) "nb seconds"
FROM table;

Y a-t-il un moyen plus simple pour arriver à ce résultat.

Merci d'avance

[pacmann]

Salut !

Tu veux faire très sale ?
Tu peux caster ton timestamp en date, faire la différence, multiplier par 24 * 3600
(mais je pense que t'y gagneras vraiment rien !)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
SQL> SELECT (cast(current_timestamp as date) - cast(current_timestamp - 1.45689752 as date)) * 24 * 3600 from dual;
 
(CAST(CURRENT_TIMESTAMPASDATE)-CAST(CURRENT_TIMESTAMP-1.45689752ASDATE))*24*3600
--------------------------------------------------------------------------------
                                                                          125876

[alex_972]

Non merci

En fait, j'espérai secrètement être passé à coté d'une fonction magique !

Une fonction genre convert timestamp_to_second... snif

[Waldar]

Tu veux faire très sale ?
Tu peux caster ton timestamp en date, faire la différence, multiplier par 24 * 3600

Ce n'est pas si sale que ça, chez moi c'est le plus rapide :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
declare
    v$_time          pls_integer;
    v$_diff          pls_integer;
    v$_tsp1 constant timestamp(3) default timestamp '2011-11-04 11:05:17.456';
    v$_tsp2 constant timestamp(3) default timestamp '2011-10-30 18:32:02.123';
    v$_idts          interval day to second;
    v$_loop constant pls_integer  default 1e6;
 
begin
    v$_time := dbms_utility.get_time();
    for i in 1..v$_loop
    loop
      v$_diff := (cast(v$_tsp1 as date) - cast(v$_tsp2 as date))*24*60*60;
    end loop;
    dbms_output.put_line('Methode Date     : ' || to_char(dbms_utility.get_time() - v$_time));
 
    v$_time := dbms_utility.get_time();
    for i in 1..v$_loop
    loop
      v$_diff := extract(day    from v$_tsp1 - v$_tsp2)*24*60*60
               + extract(hour   from v$_tsp1 - v$_tsp2)*60*60
               + extract(minute from v$_tsp1 - v$_tsp2)*60
               + extract(second from v$_tsp1 - v$_tsp2);
    end loop;
    dbms_output.put_line('Methode Extract1 : ' || to_char(dbms_utility.get_time() - v$_time));
 
    v$_time := dbms_utility.get_time();
    for i in 1..v$_loop
    loop
      v$_idts := v$_tsp1 - v$_tsp2;
      v$_diff := extract(day    from v$_idts)*24*60*60
               + extract(hour   from v$_idts)*60*60
               + extract(minute from v$_idts)*60
               + extract(second from v$_idts);
    end loop;
    dbms_output.put_line('Methode Extract2 : ' || to_char(dbms_utility.get_time() - v$_time));
end;
/
 
 
 
Methode Date     : 134
Methode Extract1 : 347
Methode Extract2 : 287

[pacmann]

Ah ben bonne nouvelle Waldar

Chuis toujours étonné par ton (bon) réflexe de comparer les temps d'exécution.

Cela dit, je parierait qu'Alex cherchait une écriture un peu plus compacte et jolie ?
(A propos, tu peux créer une fonction qui te retourne ça à la limite)

[alex_972]

Exactement pacmann.

Mais c'est bon à savoir Waldar, merci.

[Waldar]

La voilà votre fonction !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
CREATE OR REPLACE FUNCTION timestamp_to_second
  (
    p$_timestamp1 IN TIMESTAMP
  , p$_timestamp2 IN TIMESTAMP
  )
  RETURN INTEGER DETERMINISTIC
  IS 
BEGIN
  RETURN (floor((cast(p$_timestamp1 as date) - cast(p$_timestamp2 as date))*24*60*60));
END;
/
 
select timestamp_to_second(timestamp '2011-11-04 11:05:17.456',
                           timestamp '2011-10-30 18:32:02.123') as tts
  from dual;
 
       TTS
----------
    405195

[pacmann]

ca fait un peu long, mais j'aurais appelé la fonction timestamp_interval_to_second

Sinon, je sais pas si c'est utile le deterministic, à moins que ce ne soit tout le temps les même temps ?
(D'ailleurs, je trouve le fonctionnement moins clairement expliqué que le RESULT_CACHE sous 11g)

Je suppose qu'il doit stocker les associations paramètres / valeurs retournées...

[mnitu]

Après avoir trouvé environ une centaine des centièmes de second d’écart sur un million d’itérations maintenant vous jetez tout à la poubelle pour le plaisir d’appel d’une fonction PL/SQL soit –elle déterministe ?

[laurentschneider]

Y a-t-il un moyen plus simple pour arriver à ce résultat.

Non

[pacmann]

Il faut refaire des tests de perfs pour mesurer l'overhead de l'appel de la fonction à partir du SQL

[Waldar]

C'est un peu moins moins bon évidement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
-- À rajouter dans le bloc
    v$_time := dbms_utility.get_time();
    FOR i IN 1..v$_loop
    loop
      v$_diff := timestamp_to_second(v$_tsp1, v$_tsp2);
    end loop;
    dbms_output.put_line('Methode PL/SQL   : ' || to_char(dbms_utility.get_time() - v$_time));

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Methode Date     : 142
Methode Extract1 : 338
Methode Extract2 : 290
Methode PL/SQL   : 258

[laurentschneider]

bon, tu mesures le temps depuis plsql, alors que si tu devais employer ta fonction depuis sql, il y aurait un context switch.

à mon avis aucun intérêt d'écrire du plsql pour faire un extract

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
create table t as 
select timestamp '2000-01-01 00:00:00.000' + numtodsinterval(dbms_random.normal,'DAY') d 
from dual 
connect by level<100000;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
SQL> SELECT max(d),min(d) FROM t;
 
MAX(D)                          MIN(D)                         
------------------------------- -------------------------------
06-JAN-00 12.58.10.007070511 AM 27-DEC-99 01.45.00.412753923 PM

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
SQL> SELECT 
  extract(day FROM (max(d) - min(d)))*86400+
  extract(hour FROM (max(d) - min(d)))*3600+
  extract(minute FROM (max(d) - min(d)))*60+
  extract(second FROM (max(d) - min(d))) "nb seconds"
FROM T;
nb seconds
----------
817989.594
Elapsed: 00:00:00.04

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
SQL> SELECT timestamp_to_second(max(d),min(d)) "nb seconds" FROM t;
nb seconds
----------
    817989
Elapsed: 00:00:00.04

surtout quand extract fonctionne correctement

[pacmann]

J'aurais trouvé plus drôle de faire le test en enlevant le max pour cumuler les context switches (alors que là il n'y en a qu'un...).

Après, si ce morceau de code est utile, ça peut être sympa quand même la fonction, non ?
(Quand même laid et chiant avec tous ces multiplicateurs )

[alex_972]

Merci à tous pour vos réponses.

Pour le moment, je reste donc avec mes extracts