Ho giocato per memorizzare i tweet all'interno di mongodb, ogni oggetto è simile al seguente:

{
"_id" : ObjectId("4c02c58de500fe1be1000005"),
"contributors" : null,
"text" : "Hello world",
"user" : {
    "following" : null,
    "followers_count" : 5,
    "utc_offset" : null,
    "location" : "",
    "profile_text_color" : "000000",
    "friends_count" : 11,
    "profile_link_color" : "0000ff",
    "verified" : false,
    "protected" : false,
    "url" : null,
    "contributors_enabled" : false,
    "created_at" : "Sun May 30 18:47:06 +0000 2010",
    "geo_enabled" : false,
    "profile_sidebar_border_color" : "87bc44",
    "statuses_count" : 13,
    "favourites_count" : 0,
    "description" : "",
    "notifications" : null,
    "profile_background_tile" : false,
    "lang" : "en",
    "id" : 149978111,
    "time_zone" : null,
    "profile_sidebar_fill_color" : "e0ff92"
},
"geo" : null,
"coordinates" : null,
"in_reply_to_user_id" : 149183152,
"place" : null,
"created_at" : "Sun May 30 20:07:35 +0000 2010",
"source" : "web",
"in_reply_to_status_id" : {
    "floatApprox" : 15061797850
},
"truncated" : false,
"favorited" : false,
"id" : {
    "floatApprox" : 15061838001
}

Come potrei scrivere una query che controlla il Created_at e trova tutti gli oggetti tra le 18:47 e le 19:00? Devo aggiornare i miei documenti in modo che le date siano memorizzate in un formato specifico?

Interrogare per un intervallo di date (mese o giorno specifico) nel ricettario MongoDB ha un'ottima spiegazione in merito, ma di seguito è qualcosa che ho provato io stesso e sembra funzionare.

items.save({
    name: "example",
    created_at: ISODate("2010-04-30T00:00:00.000Z")
})
items.find({
    created_at: {
        $gte: ISODate("2010-04-29T00:00:00.000Z"),
        $lt: ISODate("2010-05-01T00:00:00.000Z")
    }
})
=> { "_id" : ObjectId("4c0791e2b9ec877893f3363b"), "name" : "example", "created_at" : "Sun May 30 2010 00:00:00 GMT+0300 (EEST)" }

Sulla base dei miei esperimenti dovrai serializzare le tue date in un formato supportato da MongoDB, poiché i seguenti risultati di ricerca indesiderati.

items.save({
    name: "example",
    created_at: "Sun May 30 18.49:00 +0000 2010"
})
items.find({
    created_at: {
        $gte:"Mon May 30 18:47:00 +0000 2015",
        $lt: "Sun May 30 20:40:36 +0000 2010"
    }
})
=> { "_id" : ObjectId("4c079123b9ec877893f33638"), "name" : "example", "created_at" : "Sun May 30 18.49:00 +0000 2010" }

Nel secondo esempio non ci si aspettava risultati, ma ce n'era ancora uno ottenuto. Questo perché viene eseguito un confronto di stringhe di base.

Chiarire. Ciò che è importante sapere è che:

• Sì, devi passare un oggetto Date Javascript.
• Sì, deve essere ISODate friendly
• Sì, dalla mia esperienza per far funzionare tutto ciò, è necessario modificare la data in ISO
• Sì, lavorare con le date è generalmente sempre un processo noioso e mongo non fa eccezione

Ecco un frammento di codice funzionante, in cui facciamo un po 'di manipolazione della data per garantire che Mongo (qui sto usando il modulo mongoose e voglio risultati per le righe il cui attributo date è inferiore a (prima) la data indicata come parametro myDate) in grado di gestire correttamente:

var inputDate = new Date(myDate.toISOString());
MyModel.find({
    'date': { $lte: inputDate }
})

MongoDB in realtà memorizza i millis di una data come int (64), come prescritto da http://bsonspec.org/#/specification

Tuttavia, può diventare piuttosto confuso quando si recuperano le date poiché il driver client crea un'istanza di un oggetto data con il proprio fuso orario locale. Il driver JavaScript nella console mongo lo farà sicuramente.

Quindi, se ti importa dei tuoi fusi orari, assicurati di sapere cosa dovrebbe essere quando lo riavrai. Questo non dovrebbe importare molto per le query, poiché equivarrà comunque allo stesso int (64), indipendentemente dal fuso orario in cui si trova l'oggetto data (spero). Ma sicuramente farei query con oggetti data effettivi (non stringhe) e lascerei che il driver faccia la sua cosa.

Python e pymongo

Trovare oggetti tra due date in Python con pymongoin collection posts(basato sul tutorial ):

from_date = datetime.datetime(2010, 12, 31, 12, 30, 30, 125000)
to_date = datetime.datetime(2011, 12, 31, 12, 30, 30, 125000)

for post in posts.find({"date": {"$gte": from_date, "$lt": to_date}}):
    print(post)

Dove {"$gte": from_date, "$lt": to_date}specifica l'intervallo in termini di datetime.datetimetipi.

db.collection.find({"createdDate":{$gte:new ISODate("2017-04-14T23:59:59Z"),$lte:new ISODate("2017-04-15T23:59:59Z")}}).count();

Sostituisci collectioncon il nome della raccolta che desideri eseguire la query

Usa questo codice per trovare il record tra due date usando $gtee $lt:

db.CollectionName.find({"whenCreated": {
    '$gte': ISODate("2018-03-06T13:10:40.294Z"),
    '$lt': ISODate("2018-05-06T13:10:40.294Z")
}});

Utilizzo con Moment.js e operatori di query di confronto

  var today = moment().startOf('day');
  // "2018-12-05T00:00:00.00
  var tomorrow = moment(today).endOf('day');
  // ("2018-12-05T23:59:59.999

  Example.find(
  {
    // find in today
    created: { '$gte': today, '$lte': tomorrow }
    // Or greater than 5 days
    // created: { $lt: moment().add(-5, 'days') },
  }), function (err, docs) { ... });

Converti le tue date nel fuso orario GMT mentre le stai inserendo in Mongo. In questo modo non c'è mai un problema di fuso orario. Quindi fai i calcoli sul campo Twitter / fuso orario quando estrai i dati per la presentazione.

Perché non convertire la stringa in un numero intero nel formato AAAAMMGGHHMMSS? Ogni incremento di tempo creerebbe quindi un numero intero più grande e sarà possibile filtrare i numeri interi invece di preoccuparsi della conversione in tempo ISO.

usa $ gte e $ lte per trovare tra i dati della data in mongodb

var tomorrowDate = moment(new Date()).add(1, 'days').format("YYYY-MM-DD");
db.collection.find({"plannedDeliveryDate":{ $gte: new Date(tomorrowDate +"T00:00:00.000Z"),$lte: new Date(tomorrowDate + "T23:59:59.999Z")}})

Puoi anche dare un'occhiata. Se si utilizza questo metodo, utilizzare la funzione di analisi per ottenere valori dal database Mongo:

db.getCollection('user').find({
    createdOn: {
        $gt: ISODate("2020-01-01T00:00:00.000Z"),
        $lt: ISODate("2020-03-01T00:00:00.000Z")
    }
})

mongoose.model('ModelName').aggregate([
    {
        $match: {
            userId: mongoose.Types.ObjectId(userId)
        }
    },
    {
        $project: {
            dataList: {
              $filter: {
                 input: "$dataList",
                 as: "item",
                 cond: { 
                    $and: [
                        {
                            $gte: [ "$$item.dateTime", new Date(`2017-01-01T00:00:00.000Z`) ]
                        },
                        {
                            $lte: [ "$$item.dateTime", new Date(`2019-12-01T00:00:00.000Z`) ]
                        },
                    ]
                 }
              }
           }
        }
     }
])

Puoi anche controllare questo o provare invece di usare aggregato

db.getCollection('user').find({
    createdOn: {
        $gt: ISODate("2020-01-01T00:00:00.000Z"),
        $lt: ISODate("2020-03-01T00:00:00.000Z")
    }
})

ho provato in questo modello secondo i miei requisiti ho bisogno di memorizzare una data ogni volta che un oggetto viene creato in seguito voglio recuperare tutti i record (documenti) tra due date nel mio file html che stavo usando il seguente formato mm / gg / aaaa

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
<head>

    <script>
//jquery
    $(document).ready(function(){  
    $("#select_date").click(function() { 
    $.ajax({
    type: "post",
    url: "xxx", 
    datatype: "html",
    data: $("#period").serialize(),  
    success: function(data){
    alert(data);
    } ,//success

    }); //event triggered

    });//ajax
    });//jquery  
    </script>

    <title></title>
</head>

<body>
    <form id="period" name='period'>
        from <input id="selecteddate" name="selecteddate1" type="text"> to 
        <input id="select_date" type="button" value="selected">
    </form>
</body>
</html>

nel mio file py (python) l'ho convertito in "iso fomate" nel modo seguente

date_str1   = request.POST["SelectedDate1"] 
SelectedDate1   = datetime.datetime.strptime(date_str1, '%m/%d/%Y').isoformat()

e salvato nella mia raccolta dbmongo con "SelectedDate" come campo nella mia raccolta

per recuperare dati o documenti tra 2 date ho usato la seguente query

db.collection.find( "SelectedDate": {'$gte': SelectedDate1,'$lt': SelectedDate2}})