J'ai essayé de stocker des tweets dans mongodb, chaque objet ressemble à ceci:

{
"_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
}

Comment pourrais-je écrire une requête qui vérifie le created_at et trouve tous les objets entre 18:47 et 19:00? Dois-je mettre à jour mes documents pour que les dates soient stockées dans un format spécifique?

Interroger une plage de dates (mois ou jour spécifique) dans le livre de recettes MongoDB a une très bonne explication à ce sujet, mais ci-dessous, j'ai essayé moi-même et cela semble fonctionner.

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)" }

Sur la base de mes expériences, vous devrez sérialiser vos dates dans un format pris en charge par MongoDB, car les éléments suivants ont donné des résultats de recherche indésirables.

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" }

Dans le deuxième exemple, aucun résultat n'était attendu, mais il y en avait toujours un. En effet, une comparaison de chaîne de base est effectuée.

Clarifier. Ce qu'il faut savoir, c'est que:

• Oui, vous devez passer un objet Javascript Date.
• Oui, il doit être compatible avec ISODate
• Oui, d'après mon expérience pour que cela fonctionne, vous devez manipuler la date en ISO
• Oui, travailler avec des dates est généralement toujours un processus fastidieux, et le mongo ne fait pas exception

Voici un extrait de code de travail, où nous faisons un peu de manipulation de date pour garantir que Mongo (ici j'utilise le module mangouste et souhaite des résultats pour les lignes dont l'attribut date est inférieur à (avant) la date donnée comme paramètre myDate) peut gérer correctement:

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

MongoDB stocke en fait le millis d'une date en tant qu'int (64), comme prescrit par http://bsonspec.org/#/specification

Cependant, cela peut devenir assez déroutant lorsque vous récupérez des dates car le pilote client instanciera un objet date avec son propre fuseau horaire local. Le pilote JavaScript de la console mongo le fera certainement.

Donc, si vous vous souciez de vos fuseaux horaires, assurez-vous de savoir ce que c'est censé être lorsque vous le récupérez. Cela ne devrait pas avoir autant d'importance pour les requêtes, car cela équivaudra toujours au même int (64), quel que soit le fuseau horaire de votre objet date (j'espère). Mais je ferais certainement des requêtes avec des objets de date réels (pas des chaînes) et laisserais le pilote faire son travail.

Python et pymongo

Recherche d'objets entre deux dates en Python avec pymongoen collection posts(basé sur le tutoriel ):

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)

Où {"$gte": from_date, "$lt": to_date}spécifie la plage en termes de datetime.datetimetypes.

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

Remplacer collectionpar le nom de la collection que vous souhaitez exécuter la requête

Utilisez ce code pour rechercher l'enregistrement entre deux dates à l'aide de $gteet $lt:

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

Utilisation avec Moment.js et les opérateurs de requête de comparaison

  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) { ... });

Convertissez vos dates en fuseau horaire GMT lorsque vous les placez dans Mongo. De cette façon, il n'y a jamais de problème de fuseau horaire. Ensuite, faites le calcul sur le champ Twitter / fuseau horaire lorsque vous retirez les données pour la présentation.

Pourquoi ne pas convertir la chaîne en un entier de la forme YYYYMMDDHHMMSS? Chaque incrément de temps créerait alors un entier plus grand, et vous pouvez filtrer sur les entiers au lieu de vous soucier de la conversion en temps ISO.

utilisez $ gte et $ lte pour trouver entre les données de date dans 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")}})

Vous pouvez également vérifier cela. Si vous utilisez cette méthode, utilisez la fonction d'analyse pour obtenir des valeurs de la base de données 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`) ]
                        },
                    ]
                 }
              }
           }
        }
     }
])

Vous pouvez également vérifier cela ou essayer au lieu d'utiliser l'agrégat

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

j'ai essayé dans ce modèle selon mes besoins j'ai besoin de stocker une date chaque fois qu'un objet est créé plus tard je veux récupérer tous les enregistrements (documents) entre deux dates dans mon fichier html j'utilisais le format suivant mm / jj / 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>

dans mon fichier py (python) je l'ai converti en "iso fomate" de la manière suivante

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

et enregistré dans ma collection dbmongo avec "SelectedDate" comme champ dans ma collection

récupérer des données ou des documents entre 2 dates que j'ai utilisées après la requête

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