Come posso filtrare una data di un DateTimeField in Django?

Sto cercando di filtrare un DateTimeFieldconfronto con una data. Intendo:

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

Ricevo un elenco di query vuoto come risposta perché (penso) non sto prendendo in considerazione il tempo, ma voglio "in qualsiasi momento".

C'è un modo semplice in Django per farlo?

Ho impostato il tempo nel datetime, non lo è 00:00.

Tali ricerche sono implementate django.views.generic.date_basedcome segue:

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

Poiché è abbastanza dettagliato, ci sono piani per migliorare la sintassi usando l' __dateoperatore. Controlla " # 9596 Confrontare un DateTimeField con una data è troppo difficile " per maggiori dettagli.

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

// modifica dopo i commenti

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

non funziona perché crea un oggetto datetime con valori di ora impostati su 0, quindi l'ora nel database non corrisponde.

Ecco i risultati che ho ottenuto con la funzione timeit di 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

contiene sembra essere più veloce.

Ora Django ha il filtro Queryset __date per interrogare oggetti datetime rispetto alle date nella versione di sviluppo. Pertanto, sarà presto disponibile in 1.9.

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

quanto sopra è quello che ho usato. Non solo funziona, ma ha anche un supporto logico intrinseco.

A partire da Django 1.9, il modo per farlo è usando __dateun oggetto datetime.

Per esempio: MyObject.objects.filter(datetime_attr__date=datetime.date(2009,8,22))

Questo produce gli stessi risultati dell'utilizzo di __year, __month e __day e sembra funzionare per me:

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

supponendo che active_on sia un oggetto data, incrementalo di 1 giorno, quindi fai intervallo

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

Ecco una tecnica interessante: ho sfruttato la procedura startwith implementata con Django su MySQL per ottenere il risultato di cercare un datetime solo attraverso la data. Fondamentalmente, quando Django esegue la ricerca nel database, deve eseguire una conversione di stringa per l'oggetto di archiviazione MySQL DATETIME, in modo da poter filtrare su questo, tralasciando la porzione di data e ora della data, in questo modo% LIKE% corrisponde solo alla data oggetto e otterrai tutti i timestamp per la data specificata.

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

Ciò eseguirà la seguente query:

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

Il LIKE BINARY in questo caso corrisponderà a tutto per la data, indipendentemente dal timestamp. Compresi valori come:

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

Spero che questo aiuti tutti fino a quando Django non esce con una soluzione!

C'è un fantastico post sul blog che tratta questo qui: Confronto di date e orari nel Django ORM

La migliore soluzione pubblicata per Django> 1.7, <1.9 è quella di registrare una trasformazione:

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()

Quindi puoi usarlo nei tuoi filtri in questo modo:

Foo.objects.filter(created_on__date=date)

MODIFICARE

Questa soluzione dipende sicuramente dal back-end. Dall'articolo:

Naturalmente, questa implementazione si basa sul tuo particolare sapore di SQL con una funzione DATE (). MySQL lo fa. Lo stesso vale per SQLite. D'altra parte, non ho lavorato personalmente con PostgreSQL, ma alcuni googling mi portano a credere che non abbia una funzione DATE (). Quindi un'implementazione così semplice sembra che sarà necessariamente in qualche modo dipendente dal backend.

Hm .. La mia soluzione funziona:

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

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

In Django 1.7.6 funziona:

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

Vedi l'articolo Django Documentation

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