SQLite vs. Oracle-calcul des différences de date - heures

autant que j'ai votre problème, il semble que le changement de jour a été perdu pour SQLite, ou pour être exact, que vous devez spécifier ce changement sur la sauvegarde (comme c'est une chaîne et non un vrai date field / transparent-timestamp).

quand vous générez (? si vous le faites) la date, faites-le plein UTC avec fuseau horaire explicite et non local implicite:

SQLite Date / Time

Les Formats

2 à 10 peuvent être éventuellement suivis d'un fuseau horaire indicateur de la forme "[+-]HH:MM" ou juste "Z". La date et l'heure les fonctions utilisent le temps UTC ou "zulu" en interne, et donc le suffixe "Z" est un non-op. Tout suffixe "HH:MM" non nul est soustrait de l'indication date et heure pour calculer l'heure Zoulou. Par exemple, tous les les chaînes de temps suivantes sont équivalentes:

2013-10-07 08:23:19.120
2013-10-07T08:23:19.120Z
2013-10-07 04:23:19.120-04:00

Pour être honnêtement, le SQLite avec utc n'est pas mauvais quand il vient à "oublier" le changement de jour, comme UTC ne pas bouger (il est chronométrique heures physiques). Si vous lui avez dit que tout est dans le même fuseau horaire UTC, ça fera juste une simple soustraction et ne donnez pas un f icus à propos de votre jour.

N'est-ce pas aussi julianday('now') de prendre un 'UTC' ? (désolé si je ne la reçois pas, je vais prendre un deuxième coup d'oeil demain)

je sais que ce n'est pas du tout la façon idéale de faire cela, mais j'ai résolu cela moi-même en utilisant une fonction de compensation dans mon application C# qui tirait les valeurs SQLite. En fait, il m'est venu à l'esprit après avoir écrit ceci que j'aurais pu juste refaire la soustraction de date en C# et sur-écrit mon champ D'âge! Mais comme j'avais juste besoin de modifier les heures (et les jours, si les heures étaient 0 et c'était une date de L'heure avancée) pour la condition donnée, j'ai juste utilisé ceci.

donc j'ai une classe qui fournira un DataTable de résultats basés sur la requête que je fournis à une variable de chaîne statique publique dans cette classe et une autre fonction que j'appelle. Ensuite, j'appelle BindTable() pour lier cette table au ListView dans mon application WPF pour afficher l'information.

je tire mon DataTable en appelant ADOClass.adoDataTable . Une fois que j'ai le DataTable, Je n'ai qu'à itérer les lignes, stocker la Date Créée en tant que variable, et la chaîne D'âge (que j'utilise la fonction pour mettre à jour si nécessaire)) en tant que variable. Si la Date créée répond à la condition .IsDaylightSavingTime() , elle doit obtenir une heure soustraite. Si l'âge était dit, 0 heures (et quelques minutes impaires) vieux, nous devons mettre les jours en arrière un jour, et les heures à 23.

private void BindTable()
{            
    DataTable dt = ADOClass.adoDataTable;

    if (!Oracle_DAL.ConnTest()) // if no Oracle connection, SQLite is running and it needs DST correction
    {
        int oldHours = 0;
        int newHours = 0;
        int oldDays = 0;
        int newDays = 0;
        string ageCell = String.Empty;
        string hoursString = String.Empty;
        string daysString = String.Empty;
        string crDate = String.Empty;

        if (dt != null && dt.Rows != null)
        {
            if (dt.Rows.Count > 0)
            {
                foreach (DataRow dr in dt.Rows)
                {
                    crDate = dr["CREATED_DATE"] != null ? dr["CREATED_DATE"].ToString() : String.Empty;
                    if (!String.IsNullOrEmpty(crDate))
                    {
                        DateTime createdDate = DateTime.Parse(crDate);
                        if (createdDate.IsDaylightSavingTime())
                        {
                            ageCell = dr["AGE"] != null ? dr["AGE"].ToString() : String.Empty;
                            if (!String.IsNullOrEmpty(ageCell))
                            {
                                hoursString = ageCell.Split(',')[3];
                                hoursString = hoursString.TrimStart(' ');
                                oldHours = int.Parse(hoursString.Split(' ')[0]);

                                if (oldHours == 0)
                                {
                                    newHours = 23;
                                    daysString = ageCell.Split(',')[2];
                                    daysString = daysString.TrimStart(' ');
                                    oldDays = int.Parse(daysString.Split(' ')[0]);
                                    oldDays--;
                                    newDays = oldDays;
                                    ageCell = ageCell.Replace(daysString, newDays.ToString() + " days");
                                    dr["AGE"] = ageCell;
                                }
                                else
                                {
                                    oldHours--;
                                    newHours = oldHours;                                    
                                }
                                dr["AGE"] = ageCell.Replace(hoursString, newHours.ToString() + " hours");
                            }
                        }
                    }
                }                        
            }
        }
    }

    lstData.DataContext = dt;  // binds to my ListView's grid
}

( NOTE: je me suis rendu compte plus tard que, parce que j'ai testé cette fonction un jour non-HNR, et que cela était destiné à corriger les problèmes avec les dates D'HNR, que quand il redevient HNR, je crois que les choses vont changer. Je pense que je ferais finir par avoir à ajouter une heure à mes résultats pour les dates non-DST pour le faire fonctionner, à ce point. Il faudrait donc procéder à une vérification supplémentaire si DateTime.Now est conforme à .IsDaylightSavingTime() afin de savoir quoi faire. Je peut re-visiter ce post à l'époque.)

et au cas où quelqu'un serait curieux..... Voici la requête complète que j'exécutais dans Oracle:

SELECT CREATED_DATE, (SYSDATE - CREATED_DATE) AS TOTALDAYS, 
FLOOR(ABS(MONTHS_BETWEEN(CREATED_DATE, SYSDATE)) / 12) || ' years, '  
|| (FLOOR(ABS(MONTHS_BETWEEN(CREATED_DATE, SYSDATE))) - 
   (FLOOR(ABS(MONTHS_BETWEEN(CREATED_DATE, SYSDATE)) / 12)) * 12) || ' months, '  
-- we take total days - years(as days) - months(as days) to get remaining days
|| FLOOR((SYSDATE - CREATED_DATE) -      -- total days
   (FLOOR((SYSDATE - CREATED_DATE)/365)*12)*(365/12) -      -- years, as days
   -- this is total months - years (as months), to get number of months, 
   -- then multiplied by 30.416667 to get months as days (and remove it from total days)
   FLOOR(FLOOR(((SYSDATE - CREATED_DATE)/365)*12 - (FLOOR((SYSDATE - CREATED_DATE)/365)*12)) * (365/12)))  
|| ' days, '   
-- Here, we can just get the remainder decimal from total days minus 
-- floored total days and multiply by 24       
|| FLOOR(
     ((SYSDATE - CREATED_DATE)-(FLOOR(SYSDATE - CREATED_DATE)))*24
   )
|| ' hours, ' 
-- Minutes just use the unfloored hours equation minus floored hours, 
-- then multiply by 60
|| ROUND(
       (
         (
           ((SYSDATE - CREATED_DATE)-(FLOOR(SYSDATE - CREATED_DATE)))*24
         ) - 
         FLOOR((((SYSDATE - CREATED_DATE)-(FLOOR(SYSDATE - CREATED_DATE)))*24))
       )*60
    )
|| ' minutes'  
AS AGE FROM MyTable`

et ceci est ma dernière requête complète pour SQLite à partir de mon application:

    private static readonly string mainqueryCommandTextSQLite = "SELECT " + 
        "CREATED_DATE, " +
        " (julianday('now') - julianday(CREATED_DATE, 'utc')) AS TOTALDAYS, " +
        //            " (((julianday('now') - julianday(CREATED_DATE))/365)*12) || ' total months, ' || " +
        //            " ((CAST ((julianday('now') - julianday(CREATED_DATE))/365 AS INTEGER))*12) || ' years as months, ' || " +

        // Provide years, months
        " CAST ((julianday('now') - julianday(CREATED_DATE, 'utc'))/365 AS INTEGER) || ' years, ' || " +
        " CAST (((((julianday('now') - julianday(CREATED_DATE, 'utc'))/365)*12) - (CAST ((julianday('now') - julianday(CREATED_DATE, 'utc'))/365 AS INTEGER)*12)) AS INTEGER)  || ' months, ' " +

        // Provide days
        "|| ((CAST ((julianday('now') - julianday(CREATED_DATE, 'utc')) AS INTEGER) - " +  // total number of days
        " (CAST ((julianday('now') - julianday(CREATED_DATE, 'utc'))/365 AS INTEGER)*365) ) -" + // years in days  
        " CAST((30.41667 * ((CAST ((((julianday('now') - julianday(CREATED_DATE, 'utc'))/365)*12) AS INTEGER)) - ((CAST ((julianday('now') - julianday(CREATED_DATE, 'utc')) / 365 AS INTEGER)) * 12))) AS INTEGER)) " + // days of remaining months using total months - months from # of floored years * (365/12)
        " || ' days, ' " +

        // BUG:  These next two do not get accurate hours during DST months (March - Nov)
        // This gives hours
        "|| CAST ((((julianday('now') - julianday(CREATED_DATE, 'utc')) - " +
        " CAST ((julianday('now') - julianday(CREATED_DATE, 'utc')) AS INTEGER))*24) AS INTEGER) " +

        // This gives hours.minutes
        //"|| (((julianday('now') - julianday(CREATED_DATE, 'utc')) - CAST ((julianday('now') - julianday(CREATED_DATE, 'utc')) AS INTEGER))*24) " +

        // This gives days.hours, but taking the decimal and multiplying by 24 to get actual hours 
        // gives an incorrect result
        //"|| ((" +
        //        "(0.0 + strftime('%S', 'now', 'localtime') " +
        //        "+ 60*strftime('%M', 'now', 'localtime') " +
        //        "+ 24*60*strftime('%H', 'now', 'localtime') " +
        //        "+ 24*60*60*strftime('%j', 'now', 'localtime')) - " +
        //        "(strftime('%S', CREATED_DATE) " +
        //        "+ 60*strftime('%M', CREATED_DATE) " +
        //        "+ 24*60*strftime('%H', CREATED_DATE) " +
        //        "+ 24*60*60*strftime('%j', CREATED_DATE)) " +
        //    ")/60/60/24) " +
        "|| ' hours, ' " +

        // Provide minutes
        "|| CAST (ROUND(((((julianday('now') - julianday(CREATED_DATE, 'utc')) - CAST ((julianday('now') - julianday(CREATED_DATE, 'utc')) AS INTEGER))*24) - " +
        "(CAST((((julianday('now') - julianday(CREATED_DATE, 'utc')) - CAST((julianday('now') - julianday(CREATED_DATE, 'utc')) AS INTEGER)) * 24) AS INTEGER)))*60) AS INTEGER)" +
        "|| ' minutes' " +
        " AS AGE FROM MyTable";

et nouvelle capture d'écran, montrant tout ce qui correspond (sauf le nombre total de jours, que je peux modifier en soustrayant 1/24 de ma fonction C# et mettre à jour de la même manière, pour les dates de L'heure D'été):

mise à JOUR

depuis que Wernfried a trouvé 2 requêtes en SQLite qui annulent la nécessité de cette fonction, je vais accepter que la réponse à comment résoudre ce problème:

Pour Oracle -

• SELECT (SYSDATE - CREATED_DATE) FROM MyTable

ou à l'aide de to_date syntaxe de format est bon pour la jours.heures, et de faire des conversions. Prendre la portion décimale et multiplier par 24 est bon pour les heures et est indépendant de DST, comme je voulais. Voir ci-dessus pour la requête complète que j'ai utilisé pour le formatage en années, mois, jours, heures et procès-verbaux.

Pour SQLite -

comme Wernfried a trouvé, l'un ou l'autre de ces deux fonctionnera:

• julianday('now', 'localtime') - julianday(CREATED_DATE)

• julianday(datetime('now', 'localtime')||'Z') - julianday(CREATED_DATE||'Z')

et cela évite la nécessité de ma fonction ci-dessus.

si vous utilisez:

• julianday('now') - julianday(CREATED_DATE, 'utc')

comme j'ai dans le code précédent, ci-dessus, alors vous auriez besoin de mon compensateur DST fonction, loin au-dessus.