Comment filtrer une date d'un DateTimeField dans Django?

J'essaye de filtrer une DateTimeFieldcomparaison avec une date. Je veux dire:

MyObject.objects.filter(datetime_attr=datetime.date(2009,8,22))

J'obtiens une liste de requêtes vide comme réponse parce que (je pense) je ne considère pas le temps, mais je veux "à tout moment".

Y a-t-il un moyen facile dans Django de faire cela?

J'ai le temps dans le datetime réglé, ce n'est pas le cas 00:00.

Ces recherches sont implémentées django.views.generic.date_basedcomme suit:

{'date_time_field__range': (datetime.datetime.combine(date, datetime.time.min),
                            datetime.datetime.combine(date, datetime.time.max))} 

Comme il est assez détaillé, il est prévu d'améliorer la syntaxe à l'aide de l' __dateopérateur. Cochez " # 9596 La comparaison d'un DateTimeField à une date est trop difficile " pour plus de détails.

YourModel.objects.filter(datetime_published__year='2008', 
                         datetime_published__month='03', 
                         datetime_published__day='27')

// éditer après les commentaires

YourModel.objects.filter(datetime_published=datetime(2008, 03, 27))

ne fonctionne pas car il crée un objet datetime avec des valeurs d'heure définies sur 0, de sorte que l'heure dans la base de données ne correspond pas.

Voici les résultats que j'ai obtenus avec la fonction timeit d'ipython:

from datetime import date
today = date.today()

timeit[Model.objects.filter(date_created__year=today.year, date_created__month=today.month, date_created__day=today.day)]
1000 loops, best of 3: 652 us per loop

timeit[Model.objects.filter(date_created__gte=today)]
1000 loops, best of 3: 631 us per loop

timeit[Model.objects.filter(date_created__startswith=today)]
1000 loops, best of 3: 541 us per loop

timeit[Model.objects.filter(date_created__contains=today)]
1000 loops, best of 3: 536 us per loop

contient semble être plus rapide.

Django dispose désormais d' un filtre __date queryset pour interroger les objets datetime par rapport aux dates dans la version de développement. Ainsi, il sera bientôt disponible en 1.9.

Mymodel.objects.filter(date_time_field__contains=datetime.date(1986, 7, 28))

ce qui précède est ce que j'ai utilisé. Non seulement cela fonctionne, mais il a également un support logique inhérent.

Depuis Django 1.9, la façon de faire est d'utiliser __datesur un objet datetime.

Par exemple: MyObject.objects.filter(datetime_attr__date=datetime.date(2009,8,22))

Cela produit les mêmes résultats que l'utilisation de __year, __month et __day et semble fonctionner pour moi:

YourModel.objects.filter(your_datetime_field__startswith=datetime.date(2009,8,22))

en supposant que active_on est un objet date, incrémentez-le de 1 jour puis faites range

next_day = active_on + datetime.timedelta(1)
queryset = queryset.filter(date_created__range=(active_on, next_day) )

Voici une technique intéressante - j'ai exploité la procédure startswith telle qu'implémentée avec Django sur MySQL pour obtenir le résultat de rechercher uniquement une date / heure à travers uniquement la date. Fondamentalement, lorsque Django effectue la recherche dans la base de données, il doit effectuer une conversion de chaîne pour l'objet de stockage DATETIME MySQL, vous pouvez donc filtrer sur cela, en laissant de côté la partie horodatage de la date - de cette façon% LIKE% ne correspond qu'à la date objet et vous obtiendrez chaque horodatage pour la date donnée.

datetime_filter = datetime(2009, 8, 22) 
MyObject.objects.filter(datetime_attr__startswith=datetime_filter.date())

Cela exécutera la requête suivante:

SELECT (values) FROM myapp_my_object \ 
WHERE myapp_my_object.datetime_attr LIKE BINARY 2009-08-22%

Le LIKE BINARY dans ce cas correspondra à tout pour la date, quel que soit l'horodatage. Y compris des valeurs telles que:

+---------------------+
| datetime_attr       |
+---------------------+
| 2009-08-22 11:05:08 |
+---------------------+

J'espère que cela aidera tout le monde jusqu'à ce que Django propose une solution!

Il y a un article de blog fantastique qui couvre cela ici: Comparaison des dates et des heures de données dans l'ORM Django

La meilleure solution publiée pour Django> 1.7, <1.9 est d'enregistrer une transformation:

from django.db import models

class MySQLDatetimeDate(models.Transform):
    """
    This implements a custom SQL lookup when using `__date` with datetimes.
    To enable filtering on datetimes that fall on a given date, import
    this transform and register it with the DateTimeField.
    """
    lookup_name = 'date'

    def as_sql(self, compiler, connection):
        lhs, params = compiler.compile(self.lhs)
        return 'DATE({})'.format(lhs), params

    @property
    def output_field(self):
        return models.DateField()

Ensuite, vous pouvez l'utiliser dans vos filtres comme ceci:

Foo.objects.filter(created_on__date=date)

ÉDITER

Cette solution dépend définitivement du back-end. De l'article:

Bien sûr, cette implémentation repose sur votre saveur particulière de SQL ayant une fonction DATE (). MySQL le fait. Il en va de même pour SQLite. D'un autre côté, je n'ai pas travaillé personnellement avec PostgreSQL, mais certaines recherches sur Google me portent à croire qu'il n'a pas de fonction DATE (). Donc, une implémentation aussi simple semble être nécessairement quelque peu dépendante du backend.

Hm .. Ma solution fonctionne:

Mymodel.objects.filter(date_time_field__startswith=datetime.datetime(1986, 7, 28))

Model.objects.filter(datetime__year=2011, datetime__month=2, datetime__day=30)

Dans Django 1.7.6 fonctionne:

MyObject.objects.filter(datetime_attr__startswith=datetime.date(2009,8,22))

Voir l'article Documentation Django

ur_data_model.objects.filter(ur_date_field__gte=datetime(2009, 8, 22), ur_date_field__lt=datetime(2009, 8, 23))