DocumentDB SQL - Operatoren

Ein Operator ist ein reserviertes Wort oder ein Zeichen, das hauptsächlich in einer SQL WHERE-Klausel verwendet wird, um Operationen auszuführen, z. B. Vergleiche und arithmetische Operationen. DocumentDB SQL unterstützt auch eine Vielzahl von skalaren Ausdrücken. Die am häufigsten verwendeten sindbinary and unary expressions.

Die folgenden SQL-Operatoren werden derzeit unterstützt und können in Abfragen verwendet werden.

SQL-Vergleichsoperatoren

Im Folgenden finden Sie eine Liste aller in der DocumentDB SQL-Grammatik verfügbaren Vergleichsoperatoren.

S.No.	Operatoren & Beschreibung
1	= Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr.
2	!= Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.
3	<> Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.
4	> Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.
5	< Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.
6	>= Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.
7	<= Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.

Logische SQL-Operatoren

Im Folgenden finden Sie eine Liste aller logischen Operatoren, die in der DocumentDB SQL-Grammatik verfügbar sind.

S.No.	Operatoren & Beschreibung
1	AND Der AND-Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQL-Anweisung.
2	BETWEEN Der Operator BETWEEN wird verwendet, um nach Werten zu suchen, die innerhalb eines Satzes von Werten liegen, wobei der Minimalwert und der Maximalwert angegeben werden.
3	IN Der IN-Operator wird verwendet, um einen Wert mit einer Liste der angegebenen Literalwerte zu vergleichen.
4	OR Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung zu kombinieren.
5	NOT Der NOT-Operator kehrt die Bedeutung des logischen Operators um, mit dem er verwendet wird. Zum Beispiel NICHT EXISTIERT, NICHT ZWISCHEN, NICHT IN usw. Dies ist ein negativer Operator.

SQL-Arithmetikoperatoren

Im Folgenden finden Sie eine Liste aller in der DocumentDB SQL-Grammatik verfügbaren arithmetischen Operatoren.

S.No.	Operatoren & Beschreibung
1	+ Addition - Fügt Werte auf beiden Seiten des Operators hinzu.
2	- Subtraction - Subtrahiert den rechten Operanden vom linken Operanden.
3	* Multiplication - Multipliziert Werte auf beiden Seiten des Operators.
4	/ Division - Teilt den linken Operanden durch den rechten Operanden.
5	% Modulus - Dividiert den linken Operanden durch den rechten Operanden und gibt den Rest zurück.

Wir werden die gleichen Dokumente auch in diesem Beispiel betrachten. Es folgt dieAndersenFamily Dokument.

{ 
   "id": "AndersenFamily", 
   "lastName": "Andersen", 
	
   "parents": [ 
      { "firstName": "Thomas", "relationship":  "father" }, 
      { "firstName": "Mary Kay", "relationship":  "mother" } 
   ], 
	
   "children": [ 
      { 
         "firstName": "Henriette Thaulow", 
         "gender": "female", 
         "grade": 5, 
         "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ] 
      } 
   ],
	
   "location": { "state": "WA", "county": "King", "city": "Seattle" }, 
   "isRegistered": true 
}

Es folgt die SmithFamily Dokument.

{ 
   "id": "SmithFamily", 
	
   "parents": [ 
      { "familyName": "Smith", "givenName": "James" }, 
      { "familyName": "Curtis", "givenName": "Helen" } 
   ],
	
   "children": [ 
      { 
         "givenName": "Michelle", 
         "gender": "female", 
         "grade": 1 
      },
		
      { 
         "givenName": "John", 
         "gender": "male",
         "grade": 7, 
			
         "pets": [ 
            { "givenName": "Tweetie", "type": "Bird" } 
         ] 
      } 
   ],
	
   "location": { 
      "state": "NY", 
      "county": "Queens", 
      "city": "Forest Hills" 
   },
	
   "isRegistered": true 
}

Es folgt die WakefieldFamily Dokument.

{ 
   "id": "WakefieldFamily", 
	
   "parents": [ 
      { "familyName": "Wakefield", "givenName": "Robin" }, 
      { "familyName": "Miller", "givenName": "Ben" } 
   ],
	
   "children": [ 
      { 
         "familyName": "Merriam", 
         "givenName": "Jesse", 
         "gender": "female", 
         "grade": 6,
			
         "pets": [ 
            { "givenName": "Charlie Brown", "type": "Dog" }, 
            { "givenName": "Tiger", "type": "Cat" }, 
            { "givenName": "Princess", "type": "Cat" } 
         ] 
      },
		
      { 
         "familyName": "Miller", 
         "givenName": "Lisa", 
         "gender": "female", 
         "grade": 3, 
			
         "pets": [ 
            { "givenName": "Jake", "type": "Snake" } 
         ] 
      } 
   ],
	
   "location": { "state": "NY", "county": "Manhattan", "city": "NY" }, 
   "isRegistered": false 
}

Schauen wir uns ein einfaches Beispiel an, in dem ein Vergleichsoperator in der WHERE-Klausel verwendet wird.

In dieser Abfrage wird in der WHERE-Klausel die Bedingung (WHERE f.id = "WakefieldFamily") angegeben, und das Dokument wird abgerufen, dessen ID WakefieldFamily entspricht.

SELECT * 
FROM f  
WHERE f.id = "WakefieldFamily"

Wenn die obige Abfrage ausgeführt wird, wird das vollständige JSON-Dokument für WakefieldFamily zurückgegeben, wie in der folgenden Ausgabe gezeigt.

[ 
   { 
      "id": "WakefieldFamily", 
      "parents": [ 
         { 
            "familyName": "Wakefield", 
            "givenName": "Robin" 
         },
			
         { 
            "familyName": "Miller", 
            "givenName": "Ben" 
         } 
      ],
		
      "children": [ 
         { 
            "familyName": "Merriam", 
            "givenName": "Jesse", 
            "gender": "female", 
            "grade": 6,
				
            "pets": [ 
               { 
                  "givenName": "Charlie Brown", 
                  "type": "Dog" 
               }, 
					
               { 
                  "givenName": "Tiger", 
                  "type": "Cat" 
               },
					
               { 
                  "givenName": "Princess", 
                  "type": "Cat" 
               } 
            ]
				
         },
			
         { 
            "familyName": "Miller", 
            "givenName": "Lisa", 
            "gender": "female", 
            "grade": 3, 
				
            "pets": [ 
               { 
                  "givenName": "Jake", 
                  "type": "Snake" 
               } 
            ] 
         } 
      ],
		
      "location": { 
         "state": "NY", 
         "county": "Manhattan", 
         "city": "NY" 
      }, 
		
      "isRegistered": false, 
      "_rid": "Ic8LAJFujgECAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgECAAAAAAAAAA==/", 
      "_etag": "\"00000500-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   } 
]

Schauen wir uns ein anderes Beispiel an, in dem die Abfrage die untergeordneten Daten abruft, deren Note größer als 5 ist.

SELECT * 
FROM Families.children[0] c 
WHERE (c.grade > 5)

Wenn die obige Abfrage ausgeführt wird, wird das folgende Unterdokument abgerufen, wie in der Ausgabe gezeigt.

[
   {
      "familyName": "Merriam", 
      "givenName": "Jesse", 
      "gender": "female", 
      "grade": 6, 
		
      "pets": [
         { 
            "givenName": "Charlie Brown", 
            "type": "Dog" 
         }, 
			
         { 
            "givenName": "Tiger", 
            "type": "Cat" 
         }, 
			
         { 
            "givenName": "Princess", 
            "type": "Cat" 
         } 
      ] 
   } 
]