Abfrage von Mongodb nach Monat, Tag, Jahr … einer Datumszeit

Ich verwende mongodb und speichere auf diese Weise datetime in meiner Datenbank

für ein Datum “17-11-2011 18:00” speichere ich:

date = datetime.datetime(2011, 11, 17, 18, 0)
db.mydatabase.mycollection.insert({"date" : date})

Ich möchte so eine Anfrage stellen

month = 11
db.mydatabase.mycollection.find({"date.month" : month})

oder

day = 17
db.mydatabase.mycollection.find({"date.day" : day})

weiß jemand, wie man diese Abfrage macht?

Datumsangaben werden in ihrem Zeitstempelformat gespeichert. Wenn Sie alles haben möchten, was zu einem bestimmten Monat gehört, fragen Sie nach Beginn und Ende des Monats.

var start = new Date(2010, 11, 1);
var end = new Date(2010, 11, 30);

db.posts.find({created_on: {$gte: start, $lt: end}});
//taken from http://cookbook.mongodb.org/patterns/date_range/

Sie können mongodb-Sammlungen nicht direkt nach Datumskomponenten wie Tag oder Monat abfragen. Aber es ist möglich, indem Sie das spezielle verwenden $wo Javascript-Ausdruck

db.mydatabase.mycollection.find({$where : function() { return this.date.getMonth() == 11} })

oder einfach

db.mydatabase.mycollection.find({$where : 'return this.date.getMonth() == 11'})

(Aber ich bevorzuge das erste)

Sehen Sie sich die folgenden Shell-Befehle an, um die Teile des Datums zu erhalten

>date = ISODate("2011-09-25T10:12:34Z")
> date.getYear()
111
> date.getMonth()
8
> date.getdate()
25

BEARBEITEN:

Verwenden Sie $where nur, wenn Sie keine andere Wahl haben. Es kommt mit den Leistungsproblemen. Bitte lesen Sie die Kommentare unten von @kamaradclimber und @dcrosta. Ich werde diesen Beitrag öffnen, damit die anderen Leute die Fakten darüber erfahren.

und schau dir den Link an $where-Klauseln und -Funktionen in Abfragen Für mehr Information

Wie wäre es, den Monat in einer eigenen Eigenschaft zu speichern, da Sie ihn abfragen müssen? weniger elegant als $where, aber wahrscheinlich besser abschneiden, da es indiziert werden kann.

Wenn Sie nach Dokumenten suchen möchten, die zu einem bestimmten Monat gehören, stellen Sie sicher, dass Sie wie folgt abfragen:

// Anything greater than this month and less than the next month
db.posts.find({created_on: {$gte: new Date(2015, 6, 1), $lt: new Date(2015, 7, 1)}});

Vermeiden Sie Abfragen wie unten so oft wie möglich.

// This may not find document with date as the last date of the month
db.posts.find({created_on: {$gte: new Date(2015, 6, 1), $lt: new Date(2015, 6, 30)}});

// don't do this too
db.posts.find({created_on: {$gte: new Date(2015, 6, 1), $lte: new Date(2015, 6, 30)}});

Verwenden Sie die $expr Operator, der die Verwendung von Aggregationsausdrücken innerhalb der Abfragesprache ermöglicht. Dies gibt Ihnen die Möglichkeit, die Datumsaggregationsoperatoren in Ihrer Abfrage wie folgt:

month = 11
db.mydatabase.mycollection.find({ 
    "$expr": { 
        "$eq": [ { "$month": "$date" }, month ] 
    } 
})

oder

day = 17
db.mydatabase.mycollection.find({ 
    "$expr": { 
        "$eq": [ { "$dayOfMonth": "$date" }, day ] 
    } 
})

Sie können auch eine Aggregatoperation mit dem aggregate() Funktion, die a . aufnimmt $redact Pipeline:

month = 11
db.mydatabase.mycollection.aggregate([
    {
        "$redact": {
            "$cond": [
                { "$eq": [ { "$month": "$date" }, month ] },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

Für die andere Anfrage

day = 17
db.mydatabase.mycollection.aggregate([
    {
        "$redact": {
            "$cond": [
                { "$eq": [ { "$dayOfMonth": "$date" }, day ] },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

Verwenden von ODER

month = 11
day = 17
db.mydatabase.mycollection.aggregate([
    {
        "$redact": {
            "$cond": [
                { 
                    "$or": [ 
                        { "$eq": [ { "$month": "$date" }, month ] },
                        { "$eq": [ { "$dayOfMonth": "$date" }, day ] }
                    ] 
                },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

UND . verwenden

var month = 11,
    day = 17;
db.collection.aggregate([
    {
        "$redact": {
            "$cond": [
                { 
                    "$and": [ 
                        { "$eq": [ { "$month": "$createdAt" }, month ] },
                        { "$eq": [ { "$dayOfMonth": "$createdAt" }, day ] }
                    ] 
                },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    }
])

Der $redact Operator enthält die Funktionalität von $project und $match Pipeline und gibt alle Dokumente zurück, die der Bedingung entsprechen mit $$KEEP und verwerfen Sie diejenigen aus der Pipeline, die nicht übereinstimmen, indem Sie verwenden $$PRUNE Variable.

Sie können Aufzeichnungen nach Monat, Tag, Jahr usw. von Datumsangaben nach finden Datumsaggregationsoperatoren, mögen $dayOfYear, $dayOfWeek, $Monat, $Jahr etc.

Als Beispiel, wenn Sie alle Bestellungen haben möchten, die im April 2016 erstellt wurden, können Sie die folgende Abfrage verwenden.

db.getCollection('orders').aggregate(
   [
     {
       $project:
         {
           doc: "$$ROOT",
           year: { $year: "$created" },
           month: { $month: "$created" },
           day: { $dayOfMonth: "$created" }
         }
     },
     { $match : { "month" : 4, "year": 2016 } }
   ]
)

Hier wird ein Datumstypfeld in Dokumenten erstellt, und $$ROOT haben wir verwendet, um alle anderen Felder in der nächsten Phase an das Projekt weiterzugeben und uns alle Details der Dokumente zu geben.

Sie können die obige Abfrage nach Ihren Bedürfnissen optimieren, es ist nur ein Beispiel. Um mehr über Datumsaggregationsoperatoren zu erfahren, besuchen Sie die Verbindung.

Sie können verwenden MongoDB_DataObject Wrapper, um eine solche Abfrage wie folgt durchzuführen:

$model = new MongoDB_DataObject('orders');

$model->whereAdd('MONTH(created) = 4 AND YEAR(created) = 2016');

$model->find();

while ($model->fetch()) {
    var_dump($model);
}

ODER auf ähnliche Weise mit direkter Abfragezeichenfolge:

$model = new MongoDB_DataObject();

$model->query('SELECT * FROM orders WHERE MONTH(created) = 4 AND YEAR(created) = 2016');

while ($model->fetch()) {
    var_dump($model);
}