Oracle Convertit les Secondes en Heures: Minutes: Secondes

J'ai une obligation d'affichage de l'utilisateur, la durée en Heures:Minutes:Secondes format à partir d'un nombre total de secondes de la valeur. Apprécier si vous connaissez un ORACLE de la fonction de faire de même. Je suis à l'aide d'Oracle.

Je vous remercie pour votre temps.

source d'informationauteur user1430989

Si vous êtes simplement à la recherche pour convertir un nombre donné de secondes en HH:MI:SS, cela devrait le faire

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.

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

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

Le code suivant est moins complexe et donne le même résultat. Notez que " X " est le nombre de secondes pour être convertis en heures.

Dans Oracle utilisation:

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

Dans SqlServer utilisation:

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

1

Si vous avez une variable contenant f.e. 1 minute(en secondes), vous pouvez l'ajouter à la systimestamp ensuite utiliser to_char pour sélectionner les différents éléments d'heure.
```
select to_char(systimestamp+60/(24*60*60), 'yyyy.mm.dd HH24:mi:ss') from dual
```
1

Malheureusement pas... Cependant, il y a un truc simple si il va être de moins en moins de 24 heures.

Oracle suppose qu'un numéro est ajouté à une date qui est dans jours. Convertir le nombre de secondes en jours. Ajoutez le courant de la journée, puis utilisez le to_date fonction de prendre seulement les pièces de votre intérêt. En supposant que vous avez x secondes:
```
select to_char(sysdate + (x / ( 60 * 60 * 24 ) ), 'HH24:MI:SS')
  from dual
```
Cela ne fonctionnera pas si il y a plus de 24 heures, même si vous pouvez supprimer les données actuelles de nouveau et d'obtenir la différence en jours, heures, minutes et secondes.

Si vous voulez quelque chose comme: 51:10:05soit 51 heures, 10 minutes et 5 secondes, puis vous allez avoir à utiliser trunc.

Une fois de plus, 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 Violon à démontrer.

La suite est Encore un Autre Moyen (tm) - c'est toujours de faire un peu de calcul, mais fournit un exemple d'utilisation de l'EXTRAIT de tirer les champs individuels d'un INTERVALLE:

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 contenir un calcul pour convertir les JOURS sur le terrain, à l'équivalent des heures, et n'est pas la plus jolie, mais enveloppé soigneusement dans une procédure, il n'est pas trop mal de l'utiliser.

De partager et de profiter.

0

En supposant que votre temps est appelé saint.etime ci-dessous et stockés dans des secondes, voici ce que j'utilise. Cela gère les temps où les secondes sont plus que 86399 secondes (ce qui est de 11:59:59 pm)

cas lors de la st.etime > 86399 puis to_char(to_date(st.etime - 86400,'marques'),'HH24:MI:SS') else to_char(to_date(st.etime,'marques'),'HH24:MI:SS') fin readable_time
0

Pour le commentaire sur la réponse par vogash, je comprends que vous voulez quelque chose comme un compteur de temps, c'est parce que vous pouvez avoir plus de 24 heures. Pour cela, vous pouvez effectuer les opérations suivantes:
```
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 d'accumuler les heures et la deuxième partie calcule le reste des minutes et des secondes. Par exemple, après avoir 150023 seconds il vous donnera 41:40:23.

Mais si vous voulez toujours avoir hh24:mi:ss, même si vous avez plus de 86000 seconds (1 jour), vous pouvez le 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, avoir 86402 seconds il réinitialise le temps de 00:00:02.

Ma version. Montrer Oracle DB disponibilité en 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 Date /Heure de l'Arithmétique avec Oracle 9/10

Convertir des minutes en heure:min:sec format

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

Pendant plus de 24 heures, vous pouvez inclure les jours de la requête suivante. Le retour de format est days:hh24:mi:ss

Requête:

select trunc(trunc(sysdate) + numtodsinterval(9999999, 'second')) - trunc(sysdate) || ':' || to_char(trunc(sysdate) + numtodsinterval(9999999, 'second'), 'hh24:mi:ss') from dual;

De sortie:

115:17:46:39

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;

-1

create or replace function `seconds_hh_mi_ss` (seconds in number)     
return varchar2
is
hours_var number;    
minutes_var number;    
seconds_var number;    
remeinder_var number;    
output_var varchar2(32);    
begin    
select seconds - mod(seconds,3600) into hours_var from dual;    
select seconds - hours_var into remeinder_var from dual;    
select (remeinder_var - mod(remeinder_var,60)) into minutes_var from dual;    
select seconds - (hours_var+minutes_var) into seconds_var from dual;    
output_var := hours_var/3600||':'||minutes_var/60||':'||seconds_var;    
return(output_var);    
end;
/

-2

Vous devriez vérifier ce site. Le TO_TIMESTAMP section pourrait être utile pour vous!

Syntaxe:

TO_TIMESTAMP ( string , [ format_mask ] [ 'nlsparam' ] )

Vous devez vous connecter pour publier un commentaire.