Find antal af alle overlappende intervaller

$lookup pipeline-stadiet i denne sammenhæng vil "altid" returnere et array i resultat, selvom det er tomt. Navnet på outputegenskaben, der "flettes" ind i det eksisterende dokument, vil være "overlapninger" som angivet i "as" ejendom til $lookup scene.

Efter $lookup , kan vi så lave en simpel $match med et regulært forespørgselsudtryk, der anvender $exists test for 0 indeksværdi for output-array. Hvor der faktisk er noget indhold i arrayet og derfor "overlapper", vil betingelsen være sand, og dokumentet returneres, og viser enten antallet eller dokumenterne "overlappende" i henhold til dit valg.

Andre versioner - Forespørgsler om at "deltage"

Det alternative tilfælde, hvor din MongoDB mangler denne støtte, er at "tilslutte sig" manuelt ved at udstede de samme forespørgselsbetingelser som beskrevet ovenfor for hvert undersøgt dokument:

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

Dette er i det væsentlige den samme logik, bortset fra at vi faktisk skal gå "tilbage til databasen" for at udstede forespørgslen til at matche de overlappende dokumenter. Denne gang er det "forespørgselsoperatorerne", der bruges til at finde, hvor de aktuelle dokumentværdier falder mellem værdierne i det behandlede dokument.

Fordi resultaterne allerede er returneret fra serveren, er der ingen BSON-begrænsning for at tilføje indhold til outputtet. Du har muligvis hukommelsesbegrænsninger, men det er et andet problem. Kort sagt returnerer vi arrayet i stedet for markøren via .toArray() så vi har de matchende dokumenter og kan simpelthen få adgang til arraylængden for at få en optælling. Hvis du faktisk ikke har brug for dokumenterne, så brug .count() i stedet for .find() er langt mere effektivt, da dokumentet ikke henter overhead.

Outputtet bliver så simpelthen slået sammen med det eksisterende dokument, hvor den anden vigtige skelnen er, at da afhandlinger er "flere forespørgsler", er der ingen måde at give betingelsen om, at de skal "matche" noget. Så dette efterlader os med at overveje, at der vil være resultater, hvor antallet (eller matrixlængden) er 0 og alt, hvad vi kan gøre på dette tidspunkt, er at returnere en null værdi, som vi senere kan .filter() fra resultatarrayet. Andre metoder til at iterere markøren anvender det samme grundlæggende princip om at "kassere" resultater, hvor vi ikke ønsker dem. Men intet forhindrer, at forespørgslen køres på serveren, og denne filtrering er "efterbehandling" i en eller anden form.

Reduktion af kompleksitet

Så ovenstående tilgange fungerer med strukturen som beskrevet, men den overordnede kompleksitet kræver naturligvis, at man for hvert dokument i det væsentlige skal undersøge hvert andet dokument i samlingen for at se efter overlapninger. Derfor, mens du bruger $lookup giver mulighed for en vis "effektivitet" i reduktion af transport- og responsomkostninger lider det stadig af det samme problem, at du stadig i det væsentlige sammenligner hvert dokument med alting.

En bedre løsning "hvor du kan få den til at passe" er i stedet at gemme en "hard value"*, der repræsenterer intervallet på hvert dokument. For eksempel kunne vi "antage", at der er solide "booking" perioder på en time inden for en dag for i alt 24 bookingperioder. Dette "kunne" være repræsenteret noget som:

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

Med data organiseret på den måde, hvor der var en indstillet indikator for intervallet, reduceres kompleksiteten betydeligt, da det egentlig bare er et spørgsmål om at "gruppere" på intervalværdien fra arrayet i "booking" ejendom:

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

Og outputtet:

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

Det identificerer korrekt det for 10 og 11 intervaller både "A" og "D" indeholde overlapningen, mens "B" og "A" overlap på 12 . Andre intervaller og dokumenter, der matcher, er udelukket via de samme $exists test undtagen denne gang på 1 indeks (eller andet array-element er til stede) for at se, at der var "mere end ét" dokument i grupperingen, hvilket indikerer et overlap.

Dette bruger simpelthen $unwind aggregeringspipeline-stadiet for at "dekonstruere/denormalisere" matrixindholdet, så vi kan få adgang til de indre værdier til gruppering. Det er præcis, hvad der sker i $group trin, hvor den angivne "nøgle" er reservationsinterval-id'et og $push operator bruges til at "indsamle" data om det aktuelle dokument, som blev fundet i den gruppe. $match er som forklaret tidligere.

Dette kan endda udvides til alternativ præsentation:

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

Med output:

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

Det er en forenklet demonstration, men hvor de data, du har, ville tillade den den slags analyse, der kræves, er dette den langt mere effektive tilgang. Så hvis du kan beholde "granulariteten", der skal fastsættes til "indstillede" intervaller, som almindeligvis kan registreres på hvert dokument, så kan analysen og rapporteringen bruge sidstnævnte tilgang til hurtigt og effektivt at identificere sådanne overlapninger.

I bund og grund er det sådan, du alligevel ville implementere det, du grundlæggende nævnte som en "bedre" tilgang, og den første er en "lille" forbedring i forhold til det, du oprindeligt teoretiserede. Se hvilken der faktisk passer til din situation, men dette burde forklare implementeringen og forskellene.