Намерете броя на всички припокриващи се интервали

$lookup етапът на тръбопровод в този контекст "винаги" ще върне масив в резултат, дори ако е празен. Името на изходното свойство „сливане“ в съществуващия документ ще бъде „припокриване“ както е посочено в "as" свойство към $lookup етап.

Следвайки $lookup , тогава можем да направим прост $match с регулярен израз за заявка, използващ $exists тест за 0 стойност на индекса на изходния масив. Когато действително има някакво съдържание в масива и следователно се „припокрива“, условието ще бъде вярно и документът ще бъде върнат, показвайки или броя, или документите, „припокриващи се“ според вашия избор.

Други версии - Заявки за „присъединяване“

Алтернативният случай, при който вашата MongoDB няма тази поддръжка, е да се „присъедините“ ръчно, като зададете същите условия на заявка, описани по-горе за всеки прегледан документ:

db.getCollection('collection').find().map( d => {
  var overlaps = db.getCollection('collection').find({
    "_id": { "$ne": d._id },
    "$or": [
      { "starttime": { "$gte": d.starttime, "$lte": d.endtime } },
      { "endtime": { "$gte": d.starttime, "$lte": d.endtime } }
    ]
  }).toArray();

  return ( overlaps.length !== 0 ) 
    ? Object.assign(
        d,
        {
          "overlaps": {
            "count": overlaps.length,
            "documents": overlaps
          }
        }
      )
    : null;
}).filter(e => e != null);

По същество това е същата логика, с изключение на това, че всъщност трябва да се върнем „обратно към базата данни“, за да издадем заявката, за да съответства на припокриващите се документи. Този път това са „операторите на заявки“, използвани за намиране къде текущите стойности на документа попадат между тези на обработения документ.

Тъй като резултатите вече са върнати от сървъра, няма ограничение за ограничение на BSON за добавяне на съдържание към изхода. Може да имате ограничения на паметта, но това е друг проблем. Просто казано, ние връщаме масива, а не курсора чрез .toArray() така че имаме съответстващите документи и можем просто да получим достъп до дължината на масива, за да получим брой. Ако всъщност не се нуждаете от документите, използвайте .count() вместо .find() е далеч по-ефективен, тъй като няма допълнителни разходи за извличане на документи.

Тогава изходът просто се обединява със съществуващия документ, където другото важно разграничение е, че тъй като тезите са „множество заявки“, няма начин да се осигури условието, че те трябва да „съвпадат“ с нещо. Така че това ни оставя да вземем предвид, че ще има резултати, при които броят (или дължината на масива) е 0 и всичко, което можем да направим в момента, е да върнем null стойност, която по-късно можем да .filter() от масива с резултати. Други методи за повторение на курсора използват същия основен принцип на "отхвърляне" на резултатите там, където не ги искаме. Но нищо не спира заявката да се изпълнява на сървъра и това филтриране е „последваща обработка“ под една или друга форма.

Намаляване на сложността

Така че горните подходи работят със структурата, както е описано, но разбира се цялостната сложност изисква за всеки документ да трябва по същество да изследвате всеки друг документ в колекцията, за да търсите припокривания. Следователно, докато използвате $lookup позволява известна "ефективност" при намаляване на разходите за транспорт и отговор, той все още страда от същия проблем, че все още по същество сравнявате всеки документ с всичко.

По-добро решение "там, където можете да го направите" е вместо това да съхранява "твърда стойност"*, представителна за интервала на всеки документ. Например можем да „предположим“, че има солидни периоди на „резервация“ от един час в рамките на деня за общо 24 периода на резервация. Това „може“ да бъде представено нещо като:

{ "_id": "A", "booking": [ 10, 11, 12 ] }
{ "_id": "B", "booking": [ 12, 13, 14 ] }
{ "_id": "C", "booking": [ 7, 8 ] }
{ "_id": "D", "booking": [ 9, 10, 11 ] }

С данни, организирани по този начин, където има зададен индикатор за интервала, сложността е значително намалена, тъй като всъщност е просто въпрос на „групиране“ на стойността на интервала от масива в рамките на „rezervation“ свойство:

db.booking.aggregate([
  { "$unwind": "$booking" },
  { "$group": { "_id": "$booking", "docs": { "$push": "$_id" } } },
  { "$match": { "docs.1": { "$exists": true } } }
])

И резултатът:

{ "_id" : 10, "docs" : [ "A", "D" ] }
{ "_id" : 11, "docs" : [ "A", "D" ] }
{ "_id" : 12, "docs" : [ "A", "B" ] }

Това правилно идентифицира това за 10 и 11 интервали и "A" и "D" съдържат припокриването, докато "B" и "A" припокриване на 12 . Други съвпадения на интервали и документи се изключват чрез същия $exists тест, освен този път на 1 индекс (или присъстващ втори елемент от масив), за да видите, че има „повече от един“ документ в групирането, което означава припокриване.

db.booking.aggregate([
  { "$unwind": "$booking" },
  { "$group": { "_id": "$booking", "docs": { "$push": "$_id" } } },
  { "$match": { "docs.1": { "$exists": true } } },
  { "$unwind": "$docs" },
  { "$group": {
    "_id": "$docs",
    "intervals": { "$push": "$_id" }  
  }}
])

{ "_id" : "B", "intervals" : [ 12 ] }
{ "_id" : "D", "intervals" : [ 10, 11 ] }
{ "_id" : "A", "intervals" : [ 10, 11, 12 ] }