Plus tôt Timestamp pris en charge dans PostgreSQL

Je travaille avec différentes bases de données dans un certain nombre de fuseaux horaires différents (et des périodes de temps) et une chose qui, normalement, est originaire des problèmes, est la date/heure de définition.

Pour cette raison, et depuis une date est une référence à une valeur de départ, pour garder une trace de la façon dont il a été calculé, j'ai essayer de stocker la date de base; à savoir: le montant minimum de la date de prise en charge dans l'ordinateur/de base de données;

Si je vois bien, cela dépend du SGBD et le stockage de ce type.
Dans SQL Server, j'ai trouvé un couple de façons de calculer cette "date";

SELECT CONVERT(DATETIME, 0)

ou

SELECT DATEADD(MONTH, 0, 0 )

ou même un casting comme ceci:

DECLARE @300 BINARY(8) 
SET @300 = 0x00000000 + CAST(300 AS BINARY(4))
set @dt=(SELECT CAST(@300 AS DATETIME) AS BASEDATE)
print CAST(@dt AS NVARCHAR(100))

(où @dt est une variable datetime)

Ma question est, est-il un semblable mode de calcul de la date de base PostgreSQL, c'est à dire: la valeur du minimum de la date de prise en charge et est sur la base de tous les calculs?

À partir de la description de l' date type, je peux voir que le minimum date de prise en charge est 4713 avant jc, mais il est un moyen d'obtenir cette valeur par programme (par exemple sous la forme d'un chaîne de date), comme je le fais dans SQL Server?

Vous pouvez bien appeler cette "0 jour" une date de base en SQL Serveur, mais si vous pensez que c'est également le minimum date de prise en charge (et de vos mots, il ne semble pas comme vous le faites), vous vous trompez. Il serait de convertir à 1900-01-01, et smalldatetime est la seule date/heure type qui ne peut pas gérer les dates plus tôt. Sans doute la plus largement utilisée datetime soutient les dates de 1753-01-01, et les nouveaux types de date, datetime2, datetimeoffset valeurs de support vers le bas pour 0001-01-01, juste pour info.
Depuis que je suis à la recherche d'une référence, plutôt que d'une valeur minimale (même si je l'ai bien la valeur minimale pourrait servir de référence...), je m'en tiendrai à cela: sélectionnez to_timestamp(0)::date;

OriginalL'auteur doublebyte | 2013-10-30

  1. 9

    Le manuel indique les valeurs :

    • De faible valeur: 4713 avant jc
    • De haute valeur: 294276 AD

    avec la mise en garde, comme Chris l'a noté, que -infinity est également pris en charge.

    Voir le note plus tard dans la même page dans le manuel; le ci-dessus n'est vrai que si vous utilisez entier horodateurs, qui sont par défaut dans tous vaguement les dernières versions de PostgreSQL. En cas de doute:

    SHOW integer_datetimes;

    vais vous le dire. Si vous utilisez la virgule flottante datetimes au lieu de cela, vous obtenez une plus grande portée et moins (non-linéaire) de précision. Toute tentative pour travailler le minimum par programmation doit faire face à cette restriction.

    PostgreSQL n'est pas seulement vous laisser fonte de zéro à un horodatage pour obtenir le minimum possible d'horodatage, ni ne présente beaucoup de sens si vous utilisez la virgule flottante datetimes. Vous peut utiliser la date julienne fonction de conversion, mais cela vous donne la époque pas le un minimum de temps:

    postgres=> select to_timestamp(0);
      to_timestamp      
------------------------
 1970-01-01 08:00:00+08
(1 row)

    car il accepte les valeurs négatives. Vous pensez que la donner négative exemple maxint, mais les résultats sont surprenant au point où je me demande si nous avons un wrap-around bug qui rôdent ici:

    postgres=> select to_timestamp(-922337203685477);
          to_timestamp           
---------------------------------
 294247-01-10 12:00:54.775808+08
(1 row)

postgres=> select to_timestamp(-92233720368547);
          to_timestamp           
---------------------------------
 294247-01-10 12:00:54.775808+08
(1 row)

postgres=> select to_timestamp(-9223372036854);
         to_timestamp         
------------------------------
 294247-01-10 12:00:55.552+08
(1 row)

postgres=> select to_timestamp(-922337203685);
ERROR:  timestamp out of range
postgres=> select to_timestamp(-92233720368);
          to_timestamp           
---------------------------------
 0954-03-26 09:50:36+07:43:24 BC
(1 row)

postgres=> select to_timestamp(-9223372036);
         to_timestamp         
------------------------------
 1677-09-21 07:56:08+07:43:24
(1 row)

    (Peut-être lié au fait que to_timestamp prend une double, même si ces données sont stockées entiers ces jours-ci?).

    Je pense que c'est peut-être plus sage de laisser la fourchette d'horodatage être un timestamp vous n'obtenez pas une erreur. Après tout, la plage valide horodateurs n'est pas continue:

    postgres=> SELECT TIMESTAMP '2000-02-29';
      timestamp      
---------------------
 2000-02-29 00:00:00
(1 row)

postgres=> SELECT TIMESTAMP '2001-02-29';
ERROR:  date/time field value out of range: "2001-02-29"
LINE 1: SELECT TIMESTAMP '2001-02-29';

    de sorte que vous ne pouvez pas supposer que juste parce que une valeur est entre les deux valides horodateurs, c'est son auto valide.

    En fait, c'est vraiment bizarre, que PostgreSQL accepte les valeurs que prolonger les intervalles permis, plutôt que de lancer une erreur. Je pense qu'il serait judicieux de calculer la date minimale, comme la date calculée à partir de la minimale prise en charge entier (ou que Craig la réponse de suggérer, de type BigInt). Dans PostgreSQL 9.3 manuel, il est indiqué que le minimum de prises en charge de type BigInt est -9223372036854775808. Donc, je devrais être capable de calculer le minimum de la date comme ceci: "sélectionnez to_timestamp(-9223372036854775808)::date", ce qui donne comme résultat "294247-01-10", ne correspond pas à la proposition de 4713 avant jc dans le manuel!!
    Fait encore plus étrange par la sortie de select extract(epoch from TIMESTAMP '294247-01-10');. Pas convaincu par la justesse de la date de fonctions à valeurs extrêmes.

    OriginalL'auteur Craig Ringer

  2. 6

    La première timestamp 'l'infini'. C'est une valeur spéciale. L'autre côté est "infini" qui est plus tard qu'un timestamp spécifique.

    Je ne sais pas d'un moyen d'obtenir ce programaticly. Je voudrais juste utiliser la valeur codée de la façon dont vous pouvez utiliser la valeur NULL. Cela signifie que vous avez à gérer des infinités sur le côté client.

    Merci. Et pour ajouter à cela, les éléments suivants sont legel requêtes: select ('-infinity'::timestamptz) > ('2000-01-01'::timestamptz) et select ('infinity'::timestamptz) > ('2000-01-01'::timestamptz) la production de true et false respectivement sur PostgreSQL 9.6.2 on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2, 64-bit.

    OriginalL'auteur Chris Travers