Posso interrogare MongoDB ObjectId per data?

So che ObjectIds contiene la data in cui sono stati creati. C'è un modo per interrogare questo aspetto dell'ObjectId?

La suddivisione dei timestamp in ObjectIds copre in modo dettagliato le query basate sulle date incorporate nell'IdId.

Brevemente nel codice JavaScript:

/* This function returns an ObjectId embedded with a given datetime */
/* Accepts both Date object and string input */

function objectIdWithTimestamp(timestamp) {
    /* Convert string date to Date object (otherwise assume timestamp is a date) */
    if (typeof(timestamp) == 'string') {
        timestamp = new Date(timestamp);
    }

    /* Convert date object to hex seconds since Unix epoch */
    var hexSeconds = Math.floor(timestamp/1000).toString(16);

    /* Create an ObjectId with that hex timestamp */
    var constructedObjectId = ObjectId(hexSeconds + "0000000000000000");

    return constructedObjectId
}


/* Find all documents created after midnight on May 25th, 1980 */
db.mycollection.find({ _id: { $gt: objectIdWithTimestamp('1980/05/25') } });

L'uso della funzione integrata fornita dai driver mongodb in Node.js consente di eseguire query in base a qualsiasi data e ora:

var timestamp = Date.now();
var objectId = ObjectID.createFromTime(timestamp / 1000);

In alternativa, per cercare record prima dell'ora corrente, puoi semplicemente fare:

var objectId = new ObjectID(); // or ObjectId in the mongo shell

Fonte: http://mongodb.github.io/node-mongodb-native/api-bson-generated/objectid.html

In pymongo, può essere fatto in questo modo:

import datetime
from bson.objectid import ObjectId
mins = 15
gen_time = datetime.datetime.today() - datetime.timedelta(mins=mins) 
dummy_id = ObjectId.from_datetime(gen_time)
result = list(db.coll.find({"_id": {"$gte": dummy_id}}))

Poiché i primi 4 byte di un ObjectId rappresentano un timestamp , per eseguire una query cronologicamente sulla tua raccolta, ordina semplicemente per id:

# oldest first; use pymongo.DESCENDING for most recent first
items = db.your_collection.find().sort("_id", pymongo.ASCENDING)

Dopo aver ottenuto i documenti, puoi ottenere il tempo di generazione dell'ObjectId in questo modo:

id = some_object_id
generation_time = id.generation_time

come trovare Trova il comando (questa data [2015-1-12] a questa data [2015-1-15]):

db.collection.find ({_ id: {$ gt: ObjectId (Math.floor ((new Date ('2015/1/12')) / 1000) .toString (16) + "0000000000000000"), $ lt: ObjectId (Math.floor ((new Date ('2015/1/15')) / 1000) .toString (16) + "0000000000000000")}}). Pretty ()

Conta il comando (questa data [2015-1-12] fino a questa data [2015-1-15]):

db.collection.count ({_ id: {$ gt: ObjectId (Math.floor ((new Date ('2015/1/12')) / 1000) .toString (16) + "000000000000000000"), $ lt: ObjectId (Math.floor ((new Date ('2015/1/15')) / 1000) .toString (16) + "0000000000000000")}})

Rimuovi il comando (questa data [2015-1-12] a questa data [2015-1-15]):

db.collection.remove ({_ id: {$ gt: ObjectId (Math.floor ((new Date ('2015/1/12')) / 1000) .toString (16) + "000000000000000000"), $ lt: ObjectId (Math.floor ((new Date ('2015/1/15')) / 1000) .toString (16) + "0000000000000000")}})

È possibile utilizzare la $convertfunzione per estrarre la data da ObjectId a partire dalla versione 4.0.

Qualcosa di simile a

$convert: { input: "$_id", to: "date" } 

È possibile eseguire una query sulla data confrontando tra ora di inizio e fine per la data.

db.collectionname.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2018-07-03T00:00:00.000Z")]},
      {"$lte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2018-07-03T11:59:59.999Z")]}
    ]
  }
})

O

È possibile utilizzare la scorciatoia $toDateper ottenere lo stesso.

db.collectionname.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$toDate":"$_id"}, ISODate("2018-07-03T00:00:00.000Z")]},
      {"$lte":[{"$toDate":"$_id"},ISODate("2018-07-03T11:59:59.999Z")]}
    ]
  }
})

Per ottenere i documenti degli ultimi 60 giorni nella raccolta di mongo ho usato di seguito la query nella shell.

db.collection.find({_id: {$lt:new ObjectId( Math.floor(new Date(new Date()-1000*60*60*24*60).getTime()/1000).toString(16) + "0000000000000000" )}})

Se vuoi fare una query sul range, puoi farlo come in questo post . Ad esempio, per una query per un giorno specifico (ovvero il 4 aprile 2015):

> var objIdMin = ObjectId(Math.floor((new Date('2015/4/4'))/1000).toString(16) + "0000000000000000")
> var objIdMax = ObjectId(Math.floor((new Date('2015/4/5'))/1000).toString(16) + "0000000000000000")
> db.collection.find({_id:{$gt: objIdMin, $lt: objIdMax}}).pretty()

Dalla documentazione:

o = new ObjectId()
date = o.getTimestamp()

in questo modo hai una data che è un ISODate.

Guarda http://www.mongodb.org/display/DOCS/Optimizing+Object+IDs#OptimizingObjectIDs-Extractinsertiontimesfromidratherthanhavingaseparatetimestampfield . per maggiori informazioni

Utilizzando MongoObjectID dovresti trovare anche i risultati come indicato di seguito

db.mycollection.find({ _id: { $gt: ObjectId("5217a543dd99a6d9e0f74702").getTimestamp().getTime()}});

In rotaie mongoidè possibile eseguire query utilizzando

  time = Time.utc(2010, 1, 1)
  time_id = ObjectId.from_time(time)
  collection.find({'_id' => {'$lt' => time_id}})