web-dev-qa-db-fra.com

Oracle Convertit les secondes en heures: Minutes: Secondes

J'ai l'obligation d'afficher la durée disponible de l'utilisateur au format Heures: Minutes: Secondes à partir d'un nombre total donné de secondes. Appréciez si vous connaissez une fonction Oracle pour faire la même chose. J'utilise Oracle.

Merci pour votre temps.

sqloracleplsqlplsqldeveloper
13
user1430989

Si vous cherchez simplement à convertir un nombre de secondes donné au format HH: MI: SS, vous devriez le

SELECT 
    TO_CHAR(TRUNC(x/3600),'FM9900') || ':' ||
    TO_CHAR(TRUNC(MOD(x,3600)/60),'FM00') || ':' ||
    TO_CHAR(MOD(x,60),'FM00')
FROM DUAL

où x est le nombre de secondes.

24
Mike

Essayez celui-ci . Très simple et facile à utiliser

select to_char(to_date(10000,'sssss'),'hh24:mi:ss') from dual;
28
vogash

Le code suivant est moins complexe et donne le même résultat. Notez que 'X' est le nombre de secondes à convertir en heures.

En utilisation Oracle:

SELECT TO_CHAR (TRUNC (SYSDATE) + NUMTODSINTERVAL (X, 'second'),
                'hh24:mi:ss'
               ) hr
  FROM DUAL;

Dans SqlServer, utilisez:

SELECT CONVERT(varchar, DATEADD(s, X, 0), 108);
4
user1389591

Malheureusement non ... Cependant, il y a un truc simple si cela va durer moins de 24 heures. 

Oracle suppose qu'un nombre ajouté à une date est exprimé en jours. Convertissez le nombre de secondes en jours. Ajoutez le jour actuel, puis utilisez la fonction to_date pour ne prendre que les parties qui vous intéressent. En supposant que vous ayez x secondes:

select to_char(sysdate + (x / ( 60 * 60 * 24 ) ), 'HH24:MI:SS')
  from dual

Cela ne fonctionnera pas s'il y a plus de 24 heures, mais vous pouvez supprimer les données actuelles et obtenir la différence en jours, heures, minutes et secondes.

Si vous voulez quelque chose comme: 51:10:05, c’est-à-dire 51 heures, 10 minutes et 5 secondes, vous devrez utiliser trunc .

Encore une fois en supposant que vous avez x secondes ...

  • Le nombre d'heures est trunc(x / 60 / 60)
  • Le nombre de minutes est trunc((x - ( trunc(x / 60 / 60) * 60 * 60 )) / 60)
  • Le nombre de secondes est donc le x - hours * 60 * 60 - minutes * 60

Vous laissant avec:

with hrs as (
  select x, trunc(x / 60 / 60) as h
    from dual
         )
 , mins as (
  select x, h, trunc((x - h * 60 * 60) / 60) as m
    from hrs
         )
select h, m, x - (h * 60 * 60) - (m * 60)
  from mins

J'ai mis en place un SQL Fiddle à démontrer.

1
Ben

Ce qui suit est Yet Another Way (tm) - implique toujours un peu de calcul mais fournit un exemple d'utilisation d'EXTRACT pour extraire les champs individuels d'un INTERVAL:

DECLARE 
  SUBTYPE BIG_INTERVAL IS INTERVAL DAY(9) TO SECOND;

  i        BIG_INTERVAL;
  nSeconds NUMBER := 86400000;

  FUNCTION INTERVAL_TO_HMS_STRING(inv IN BIG_INTERVAL)
    RETURN VARCHAR2
  IS
    nHours    NUMBER;
    nMinutes  NUMBER;
    nSeconds  NUMBER;
    strHour_format  VARCHAR2(10) := '09';
    workInv   INTERVAL DAY(9) TO SECOND(9);
  BEGIN
    nHours := EXTRACT(HOUR FROM inv) + (EXTRACT(DAY FROM inv) * 24);
    strHour_format := TRIM(RPAD(' ', LENGTH(TRIM(TO_CHAR(ABS(nHours)))), '0') || '9');

    nMinutes := ABS(EXTRACT(MINUTE FROM inv));
    nSeconds := ABS(EXTRACT(SECOND FROM inv));

    RETURN TRIM(TO_CHAR(nHours, strHour_format)) || ':' ||
           TRIM(TO_CHAR(nMInutes, '09')) || ':' ||
           TRIM(TO_CHAR(nSeconds, '09'));
  END INTERVAL_TO_HMS_STRING;

BEGIN
  i := NUMTODSINTERVAL(nSeconds, 'SECOND');

  DBMS_OUTPUT.PUT_LINE('i (fields) = ' || INTERVAL_TO_HMS_STRING(i));
END;

Le code qui extrait les champs, etc., doit encore contenir un calcul pour convertir le champ DAY en heures équivalentes, et n'est pas le plus joli, mais bien encapsulé dans une procédure, il n'est pas trop mauvais à utiliser.

Partager et profiter.

1
Bob Jarvis

Si vous avez une variable contenant f.e. 1 minute (en secondes), vous pouvez l'ajouter à l'horodatage puis utiliser to_char pour en sélectionner les différentes parties de l'heure.

select to_char(systimestamp+60/(24*60*60), 'yyyy.mm.dd HH24:mi:ss') from dual
1
Bjarni Sævarsson

Conversion des minutes en format heure: min: sec

SELECT 
   TO_CHAR(TRUNC((MINUTES * 60) / 3600), 'FM9900') || ':' ||
   TO_CHAR(TRUNC(MOD((MINUTES * 60), 3600) / 60), 'FM00') || ':' ||
   TO_CHAR(MOD((MINUTES * 60), 60), 'FM00') AS MIN_TO_HOUR FROM DUAL
0
Andrey Hideki Nakano

Ma version. Afficher la disponibilité de la base de données Oracle au format DDd HHh MMm SSs

select to_char(trunc((((86400*x)/60)/60)/24)) || 'd ' ||
   to_char(trunc(((86400*x)/60)/60)-24*(trunc((((86400*x)/60)/60)/24)), 'FM00') || 'h ' ||
   to_char(trunc((86400*x)/60)-60*(trunc(((86400*x)/60)/60)), 'FM00') || 'm ' ||
   to_char(trunc(86400*x)-60*(trunc((86400*x)/60)), 'FM00') || 's' "UPTIME"
 from (select (sysdate - t.startup_time) x from V$INSTANCE t);

idée de Arithmétique Date/Heure avec Oracle 9/10

0
Vlad

En supposant que votre temps s'appelle st.etime ci-dessous et qu'il soit stocké en secondes, voici ce que j'utilise. Ceci gère les heures où les secondes sont supérieures à 86399 secondes (ce qui correspond à 23:59:59).

case quand st.etime> 86399 puis to_char (to_date (st.etime - 86400, 'sssss'), 'HH24: MI: SS') sinon to_char (to_date (st.etime, 'sssss'), 'HH24: MI: SS ') end readable_time 

0
Jonathan Wade
create or replace procedure mili(num in number)
as
yr number;
yrsms number;
mon number;
monsms number;
wk number;
wksms number;
dy number;
dysms number;
hr number;
hrsms number;
mn number;
mnsms number;
sec number;
begin 
yr := FLOOR(num/31556952000);
yrsms := mod(num, 31556952000);
mon := FLOOR(yrsms/2629746000);
monsms := mod(num,2629746000);
wk := FLOOR(monsms/(604800000));
wksms := mod(num,604800000); 
dy := floor(wksms/ (24*60*60*1000));
dysms :=mod(num,24*60*60*1000);
hr := floor((dysms)/(60*60*1000));
hrsms := mod(num,60*60*1000);
mn := floor((hrsms)/(60*1000));
mnsms := mod(num,60*1000);
sec := floor((mnsms)/(1000));
dbms_output.put_line(' Year:'||yr||' Month:'||mon||' Week:'||wk||' Day:'||dy||' Hour:'||hr||' Min:'||mn||' Sec: '||sec);
end;
/


begin 
mili(12345678904234);
end;
0
mayank

Pour le commentaire sur la réponse de vogash, je comprends que vous voulez quelque chose comme un compteur de temps, car vous pouvez avoir plus de 24 heures. Pour cela, vous pouvez faire ce qui suit:

select to_char(trunc(xxx/3600)) || to_char(to_date(mod(xxx, 86400),'sssss'),':mi:ss') as time
from dual;

xxx sont votre nombre de secondes.

La première partie cumule les heures et la seconde calcule les minutes et les secondes restantes. Par exemple, avoir 150023 seconds vous donnera 41:40:23. 

Mais si vous voulez toujours avoir hh24: mi: ss même si vous avez plus que 86000 seconds (1 jour) vous pouvez faire:

select to_char(to_date(mod(xxx, 86400),'sssss'),'hh24:mi:ss') as time 
from dual;

xxx sont votre nombre de secondes.

Par exemple, si vous avez 86402 seconds, l'heure sera remise à 00:00:02.

0
Scott Baxter