MongoDB $sortiment

I MongoDB, $range aggregeringspipeline-operatören returnerar en genererad sekvens av tal i en array.

Den här nummersekvensen är baserad på de indata du anger.

Syntax

Syntaxen ser ut så här:

{ $range: [ <start>, <end>, <non-zero step> ] }

Där är starten och är slutet på sekvensen. Var och en av dessa kan vara vilket giltigt uttryck som helst som löser sig till ett heltal.

 
  är ett valfritt argument som har 1 som standard. Detta argument låter dig ange ett inkrementvärde. Om det tillhandahålls måste det vara ett giltigt uttryck som löser sig till ett heltal som inte är noll. 
 Exempel
 
 Anta att vi har en samling som heter range med följande dokument:
 { "_id" : 1, "start" : 0, "end" : 5 }
{ "_id" : 2, "start" : 1, "end" : 5 }
 
 Vi kan använda $range operatorn för att returnera en array baserat på värdena i dessa dokument.
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 1, 2 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            result: { $range: [ "$start", "$end" ] }
          }
     }
   ]
)
 
 Resultat:
 { "start" : 0, "end" : 5, "result" : [ 0, 1, 2, 3, 4 ] }
{ "start" : 1, "end" : 5, "result" : [ 1, 2, 3, 4 ] }
 
 I det här fallet tillhandahöll vi inte ett tredje argument, och därför $range använder sitt standardstegvärde på 1. Därför ökar arrayelementen med 1.
 Lägg till en explicit ökning
 
 Vi kan lägga till ett tredje argument för att explicit specificera hur mycket varje arrayelement ska öka med. 
 
 Anta att vår samling innehåller följande dokument:
 { "_id" : 3, "start" : 0, "end" : 5, "step" : 1 }
{ "_id" : 4, "start" : 0, "end" : 10, "step" : 2 }
{ "_id" : 5, "start" : 1, "end" : 10, "step" : 2 }
{ "_id" : 6, "start" : 100, "end" : 150, "step" : 10 }
 
 Dessa dokument har ett steg fältet, och så kan vi använda det fältet för det ökande värdet för respektive dokument.
 
 Låt oss nu tillämpa $range till dessa dokument och inkludera steget fältet som ett tredje argument:
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 3, 4, 5, 6 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            step: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 { "start" : 0, "end" : 5, "step" : 1, "result" : [ 0, 1, 2, 3, 4 ] }
{ "start" : 0, "end" : 10, "step" : 2, "result" : [ 0, 2, 4, 6, 8 ] }
{ "start" : 1, "end" : 10, "step" : 2, "result" : [ 1, 3, 5, 7, 9 ] }
{ "start" : 100, "end" : 150, "step" : 10, "result" : [ 100, 110, 120, 130, 140 ] }
 Negativa stegvärden
 
 Steget kan vara ett negativt värde, även om detta måste göras i samband med att dekrementera från en högre start nummer till en lägre ände siffra. 
 
 Låt oss lägga till några fler dokument till vår samling:
 { "_id" : 7, "start" : 0, "end" : 5, "step" : -1 }
{ "_id" : 8, "start" : 5, "end" : 0, "step" : -1 }
{ "_id" : 9, "start" : 0, "end" : -5, "step" : -1 }
 
 Låt oss nu tillämpa $range till dessa dokument:
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 7, 8, 9 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            step: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 { "start" : 0, "end" : 5, "step" : -1, "result" : [ ] }
{ "start" : 5, "end" : 0, "step" : -1, "result" : [ 5, 4, 3, 2, 1 ] }
{ "start" : 0, "end" : -5, "step" : -1, "result" : [ 0, -1, -2, -3, -4 ] }
 
 Vi kan se att det första dokumentet returnerade en tom array eftersom det negativa stegvärdet ligger utanför intervallet som tillhandahålls av start och slut fält.
 
 De efterföljande dokumenten producerade dock ett minskande värdeintervall.
 När steget är noll
 
 Stegvärdet måste vara ett heltal som inte är noll. Ange steget 0 returnerar ett fel.
 
 Anta att vi lägger till följande dokument i vår samling:
 { "_id" : 10, "start" : 1, "end" : 5, "step" : 0 }
 
 Det här är vad som händer när vi tillämpar $range till det dokumentet:
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 10 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$range requires a non-zero step value",
	"code" : 34449,
	"codeName" : "Location34449"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 
 Felmeddelandet berättar uttryckligen för oss att $range kräver ett stegvärde som inte är noll .
 Nullsteg
 
 Steget kan inte vara null antingen.
 
 Anta att vi har följande dokument:
 { "_id" : 11, "start" : 1, "end" : 5, "step" : null }
 
 Och vi tillämpar $range till det:
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 11 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$range requires a numeric step value, found value of type:null",
	"code" : 34447,
	"codeName" : "Location34447"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 
 Detta talar om för oss att $range kräver ett numeriskt stegvärde, hittat värde av typen:null .
 Nullintervall
 
 Om start och/eller slut fälten är null , då returneras ett fel.
 
 Anta att vi har följande dokument:
 { "_id" : 11, "start" : 1, "end" : 5, "step" : null }
 
 Och tillämpa $range till det:
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 11 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$range requires a numeric starting value, found value of type: null",
	"code" : 34443,
	"codeName" : "Location34443"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
DBCoexample@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 
 Detta talar om för oss att $range kräver ett numeriskt startvärde, hittat värde av typen:null .
 
 Ett liknande meddelande skulle visas om slutvärdet var null. 
 
 Här är ett dokument med null slutvärde:
 { "_id" : 13, "start" : 1, "end" : null, "step" : 1 }
 
 Låt oss tillämpa $range :
 db.range.aggregate(
   [
     { $match: { _id: { $in: [ 13 ] } } },
     {
       $project:
          {
            _id: 0,
            start: 1,
            end: 1,
            result: { $range: [ "$start", "$end", "$step" ] }
          }
     }
   ]
)
 
 Resultat:
 uncaught exception: Error: command failed: {
	"ok" : 0,
	"errmsg" : "$range requires a numeric ending value, found value of type: null",
	"code" : 34445,
	"codeName" : "Location34445"
} : aggregate failed :
example@sqldat.com/mongo/shell/utils.js:25:13
example@sqldat.com/mongo/shell/assert.js:18:14
example@sqldat.com/mongo/shell/assert.js:639:17
example@sqldat.com/mongo/shell/assert.js:729:16
example@sqldat.com/mongo/shell/db.js:266:5
example@sqldat.com/mongo/shell/collection.js:1058:12
@(shell):1:1
 
 Den här gången berättar det för oss att $range kräver ett numeriskt slutvärde, hittat värde av typen:null .