Znajdź liczbę wszystkich nakładających się interwałów

$lookup etap potoku w tym kontekście „zawsze” zwróci w wyniku tablicę, nawet jeśli jest pusta. Nazwa właściwości wyjściowej "scalająca" z istniejącym dokumentem będzie miała postać "overlaps" jak określono w "jako" właściwość $lookup scena.

Zgodnie z $lookup , możemy wtedy wykonać proste $match z regularnym wyrażeniem zapytania wykorzystującym $exists test na 0 wartość indeksu tablicy wyjściowej. Tam, gdzie faktycznie w tablicy znajduje się jakaś zawartość, a zatem „nakłada się”, warunek będzie spełniony, a dokument zwrócony, pokazując liczbę lub dokumenty „nakładające się” zgodnie z wyborem.

Inne wersje – zapytania do „dołączenia”

Alternatywnym przypadkiem, w którym MongoDB nie ma tej obsługi, jest ręczne „dołączanie” przez wydawanie tych samych warunków zapytania opisanych powyżej dla każdego badanego dokumentu:

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);

Jest to zasadniczo ta sama logika, z tą różnicą, że musimy wrócić „z powrotem do bazy danych”, aby wysłać zapytanie pasujące do nakładających się dokumentów. Tym razem są to "operatory zapytań" używane do znalezienia, gdzie aktualne wartości dokumentu mieszczą się między tymi z przetworzonego dokumentu.

Ponieważ wyniki są już zwracane z serwera, nie ma limitu BSON na dodawanie zawartości do danych wyjściowych. Możesz mieć ograniczenia pamięci, ale to inny problem. Mówiąc najprościej, zwracamy tablicę, a nie kursor za pomocą .toArray() więc mamy pasujące dokumenty i możemy po prostu uzyskać dostęp do długości tablicy, aby uzyskać liczbę. Jeśli faktycznie nie potrzebujesz dokumentów, użyj .count() zamiast .find() jest znacznie bardziej wydajny, ponieważ nie ma narzutu na pobieranie dokumentu.

Wynik jest następnie po prostu scalany z istniejącym dokumentem, gdzie inną ważną różnicą jest to, że skoro tezy są „wieloma zapytaniami”, nie ma możliwości podania warunku, że muszą coś „dopasować”. Pozostaje nam więc zastanowienie się, że będą wyniki, w których liczba (lub długość tablicy) wynosi 0 i wszystko, co możemy teraz zrobić, to zwrócić null wartość, którą możemy później .filter() z tablicy wyników. Inne metody iterowania kursora wykorzystują tę samą podstawową zasadę „odrzucania” wyników tam, gdzie ich nie chcemy. Ale nic nie zatrzymuje zapytania na serwerze, a to filtrowanie jest „przetwarzaniem końcowym” w takiej czy innej formie.

Zmniejszanie złożoności

Tak więc powyższe podejścia działają z opisaną strukturą, ale oczywiście ogólna złożoność wymaga, aby dla każdego dokumentu zasadniczo zbadać każdy inny dokument w kolekcji w celu znalezienia nakładania się. Dlatego podczas korzystania z $lookup pozwala na pewną "wydajność" w zmniejszeniu kosztów transportu i odpowiedzi, nadal boryka się z tym samym problemem, że nadal zasadniczo porównujesz każdy dokument ze wszystkim.

Lepsze rozwiązanie, „gdzie możesz je dopasować” jest zamiast tego przechowywanie „twardej wartości”* reprezentującej interwał w każdym dokumencie. Na przykład możemy „założyć”, że istnieją stałe okresy „rezerwacji” trwające jedną godzinę w ciągu dnia, co daje łącznie 24 okresy rezerwacji. To „może” być reprezentowane w następujący sposób:

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

W przypadku danych zorganizowanych w ten sposób, gdzie istniał ustawiony wskaźnik dla interwału, złożoność jest znacznie zmniejszona, ponieważ tak naprawdę jest to tylko kwestia „grupowania” wartości interwału z tablicy w ramach „rezerwacji” właściwość:

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

A wynik:

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

To poprawnie identyfikuje to dla 10 i 11 interwały oba "A" i "D" zawierać nakładanie się, podczas gdy "B" i "A" nakładają się na 12 . Inne interwały i dopasowania dokumentów są wykluczane za pomocą tego samego $exists test, z wyjątkiem tego czasu na 1 index ( lub obecność drugiego elementu tablicy ), aby zobaczyć, że w grupie było "więcej niż jeden" dokument, co wskazuje na nakładanie się.

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