Trova gli oggetti tra due date MongoDB

https://stackoverflow.com/questions/2943222

05-10-2019
|

Domanda

Ho giocato in giro la memorizzazione di tweet all'interno MongoDB, ogni aspetto oggetto come questo:

{
"_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 i created_at e trova tutti gli oggetti tra 18:47 e le 19:00? Ho bisogno di aggiornare i miei documenti in modo che le date sono memorizzate in un formato specifico?

Soluzione

~~Interrogazione per un intervallo di date (mese specifico o giorno)~~ nella ~~MongoDB Cookbook~~ ha una buona spiegazione sulla questione, ma al di sotto è 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 delle mie esperienze è necessario per serializzare le date in un formato che supporta MongoDB, perché il seguente ha dato risultati di ricerca non desiderato.

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 ci si aspettava alcun risultato, ma c'era ancora uno ottenuto. Questo perché un confronto di stringhe di base è fatto.

Altri suggerimenti

Per chiarire. Ciò che è importante sapere è che:

Sì, è necessario passare un oggetto JavaScript Date.
Sì, deve essere isodate amichevole
Sì, dalla mia esperienza ottenere questo al lavoro, è necessario manipolare la data ISO
Sì, lavorando con date è generalmente sempre un processo noioso, e Mongo non fa eccezione

Ecco un frammento di lavoro di codice, dove facciamo un po 'di manipolazione data per garantire Mongo (qui sto usando il modulo mangusta e voglio risultati per le righe il cui attributo data è inferiore (prima) la data indicata come myDate param ) in grado di gestire in modo corretto:

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

MongoDB in realtà memorizza i Millis di una data come un int (64), come prescritto dal http: // bsonspec. org / # / specifica

Tuttavia, si può ottenere abbastanza confuso quando si recuperano le date come il driver client sarà un'istanza di un oggetto data con il proprio fuso orario locale. Il driver JavaScript nella console Mongo sarà certamente farlo.

Quindi, se vi preoccupate per i vostri fusi orari, quindi assicuratevi di sapere quello che si suppone essere quando si ottiene indietro. Questo non dovrebbe importare tanto per le query, in quanto sarà ancora equiparare allo stesso int (64), indipendentemente da ciò che l'oggetto fuso orario data è in (spero). Ma mi piacerebbe sicuramente fare query con gli oggetti di data attuale (non stringhe) e lasciare che il conducente fare la sua cosa.

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

Sostituire collection con il nome di raccolta che si desidera eseguire la query

Python e `pymongo`

Ricerca di oggetti tra due date in Python con pymongo nella collezione posts (in base al esercitazione ):

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 tipi datetime.datetime.

Usa questo codice per trovare il record tra due date utilizzando $gte e $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 paragone Query Operatori

  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 per GMT fuso orario come li stai ripieno in Mongo. In questo modo non c'è mai un problema di fuso orario. Poi basta fare i calcoli sul campo Twitter / fuso orario quando si tira i dati di nuovo fuori per la presentazione.

Perché non convertire la stringa in un numero intero della forma AAAAMMGGHHMMSS? Ogni incremento di tempo sarebbe quindi creare un intero più grande, ed è possibile filtrare sugli interi invece di preoccuparsi di conversione a tempo ISO.

utilizzo $ gte e $ LTE per trovare tra i dati aggiornati 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")}})

ho provato in questo modello come per le mie esigenze ho bisogno di memorizzare una data in cui mai un oggetto viene creato in seguito voglio recuperare tutti i record (documenti) tra due date nel mio file html stavo usando il seguente formato gg / mm / 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) mi sono convertito in "iso fomate" in modo seguente

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

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

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

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

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`) ]
                        },
                    ]
                 }
              }
           }
        }
     }
])

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Trova gli oggetti tra due date MongoDB

Python e pymongo

Python e `pymongo`