DocumentDB SQL-빠른 가이드

DocumentDB는 Azure에서 실행되는 Microsoft의 최신 NoSQL 문서 데이터베이스 플랫폼입니다. 이 자습서에서는 DocumentDB에서 지원하는 특수 버전의 SQL을 사용하여 문서를 쿼리하는 방법에 대해 모두 알아 봅니다.

NoSQL 문서 데이터베이스

DocumentDB는 Microsoft의 최신 NoSQL 문서 데이터베이스이지만 NoSQL 문서 데이터베이스라고하면 NoSQL과 문서 데이터베이스가 정확히 무엇을 의미합니까?

• SQL은 관계형 데이터베이스의 전통적인 쿼리 언어 인 구조적 쿼리 언어를 의미합니다. SQL은 종종 관계형 데이터베이스와 동일합니다.

• NoSQL 데이터베이스를 비 관계형 데이터베이스로 생각하는 것이 더 유용하므로 NoSQL은 실제로 비 관계형을 의미합니다.

다음과 같은 키 값 저장소를 포함하는 다양한 유형의 NoSQL 데이터베이스가 있습니다.

• Azure 테이블 저장소
• Cassandra와 같은 열 기반 저장소
• NEO4와 같은 그래프 데이터베이스
• MongoDB 및 Azure DocumentDB와 같은 문서 데이터베이스

왜 SQL 구문인가?

처음에는 이상하게 들릴 수 있지만 NoSQL 데이터베이스 인 DocumentDB에서는 SQL을 사용하여 쿼리합니다. 위에서 언급했듯이 이것은 JSON 및 JavaScript 의미 체계에 기반한 SQL의 특수 버전입니다.

• SQL은 언어 일뿐 아니라 풍부하고 표현력이 뛰어난 매우 인기있는 언어이기도합니다. 따라서 데이터베이스에서 문서를 가져오고 싶을 때 배워야 할 쿼리를 완전히 새로운 방식으로 표현하기보다는 SQL의 일부 방언을 사용하는 것이 확실히 좋은 생각처럼 보입니다.

• SQL은 관계형 데이터베이스 용으로 설계되었으며 DocumentDB는 비 관계형 문서 데이터베이스입니다. DocumentDB 팀은 실제로 문서 데이터베이스의 비 관계형 세계에 SQL 구문을 적용했으며, 이것이 바로 JSON 및 JavaScript에서 SQL을 루팅한다는 의미입니다.

• 언어는 여전히 익숙한 SQL로 읽지 만 의미 체계는 모두 관계형 테이블이 아닌 스키마없는 JSON 문서를 기반으로합니다. DocumentDB에서는 SQL 데이터 유형이 아닌 JavaScript 데이터 유형으로 작업합니다. SELECT, FROM, WHERE 등에 익숙하지만 숫자와 문자열로 제한되는 JavaScript 유형, 객체, 배열, Boolean 및 null은 광범위한 SQL 데이터 유형보다 훨씬 적습니다.

• 마찬가지로 식은 T-SQL 형식이 아닌 JavaScript 식으로 평가됩니다. 예를 들어 비정규 화 된 데이터의 세계에서 우리는 행과 열을 처리하지 않고 중첩 된 배열과 객체를 포함하는 계층 구조를 가진 스키마없는 문서를 처리합니다.

SQL은 어떻게 작동합니까?

DocumentDB 팀은 몇 가지 혁신적인 방법으로이 질문에 답했습니다. 그들 중 일부는 다음과 같이 나열됩니다-

• 첫째, 문서의 모든 속성을 자동으로 인덱싱하도록 기본 동작을 변경하지 않았다고 가정하면 쿼리에서 점 표기법을 사용하여 문서 내에 얼마나 깊게 중첩되어 있든 관계없이 모든 속성의 경로를 탐색 할 수 있습니다.

• 또한 관계형 세계에서 두 테이블간에 조인이 수행되는 방식과 매우 유사한 방식으로 중첩 된 배열 요소가 문서 내의 부모 요소와 조인되는 문서 내 조인을 수행 할 수 있습니다.

• 쿼리는 데이터베이스에서 문서를있는 그대로 반환하거나 원하는 문서 데이터를 최대한 많이 또는 적게 기반으로 원하는 사용자 지정 JSON 모양을 프로젝션 할 수 있습니다.

• DocumentDB의 SQL은 다음과 같은 많은 일반적인 연산자를 지원합니다.

  • 산술 및 비트 연산

  • AND 및 OR 논리

  • 같음 및 범위 비교

  • 문자열 연결

• 쿼리 언어는 또한 다양한 내장 함수를 지원합니다.

Azure Portal에는 DocumentDB 데이터베이스에 대해 SQL 쿼리를 실행할 수있는 쿼리 탐색기가 있습니다. 쿼리 탐색기를 사용하여 가능한 가장 간단한 쿼리로 시작하는 쿼리 언어의 다양한 기능과 기능을 보여줄 것입니다.

Step 1 − Azure Portal을 열고 데이터베이스 블레이드에서 쿼리 탐색기 블레이드를 클릭합니다.

쿼리는 컬렉션 범위 내에서 실행되므로 쿼리 탐색기를 통해이 드롭 다운에서 컬렉션을 선택할 수 있습니다. 세 가지 문서가 포함 된 Families 컬렉션에 설정 한 상태로 둡니다. 이 예에서이 세 가지 문서를 살펴 보겠습니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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
}

쿼리 탐색기는이 간단한 쿼리 SELECT * FROM c로 열립니다.이 쿼리는 컬렉션에서 모든 문서를 검색합니다. 간단하지만 관계형 데이터베이스의 동등한 쿼리와는 여전히 상당히 다릅니다.

Step 2− 관계형 데이터베이스에서 SELECT *는 DocumentDB에있는 동안 모든 열을 반환 함을 의미합니다. 결과의 각 문서가 데이터베이스에 저장된 그대로 반환되기를 원한다는 의미입니다.

그러나 단순히 SELECT *를 실행하는 대신 특정 속성 및 식을 선택하면 결과에서 각 문서에 대해 원하는 새 모양이 투영됩니다.

Step 3 − '실행'을 클릭하여 쿼리를 실행하고 결과 블레이드를 엽니 다.

알 수 있듯이 WakefieldFamily, SmithFamily 및 AndersonFamily가 검색됩니다.

다음은 결과로 검색된 세 가지 문서입니다. SELECT * FROM c 질문.

[ 
   { 
      "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/" 
   }, 
	
   { 
      "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, 
      "_rid": "Ic8LAJFujgEDAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEDAAAAAAAAAA==/", 
      "_etag": "\"00000600-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   }, 
	
   { 
      "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, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   }
]

그러나 이러한 결과에는 모두 밑줄 문자로 시작하는 시스템 생성 속성도 포함됩니다.

이 장에서는 일반 SQL의 표준 FROM 절처럼 작동하지 않는 FROM 절을 다룰 것입니다.

쿼리는 항상 특정 컬렉션의 컨텍스트 내에서 실행되며 컬렉션 내의 문서간에 조인 할 수 없으므로 FROM 절이 필요한 이유가 궁금합니다. 실제로는 포함하지 않지만 포함하지 않으면 컬렉션의 문서를 쿼리하지 않습니다.

이 절의 목적은 쿼리가 작동해야하는 데이터 소스를 지정하는 것입니다. 일반적으로 전체 컬렉션이 소스이지만 컬렉션의 하위 집합을 대신 지정할 수 있습니다. FROM <from_specification> 절은 원본이 필터링되거나 나중에 쿼리에서 프로젝션되지 않는 한 선택 사항입니다.

동일한 예를 다시 살펴 보겠습니다. 다음은AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

위의 쿼리에서“SELECT * FROM c”는 전체 Families 컬렉션이 열거 할 소스임을 나타냅니다.

하위 문서

소스를 더 작은 하위 집합으로 줄일 수도 있습니다. 각 문서에서 하위 트리 만 검색하려는 경우 다음 예제와 같이 하위 루트가 소스가 될 수 있습니다.

다음 쿼리를 실행하면-

SELECT * FROM Families.parents

다음 하위 문서가 검색됩니다.

[ 
   [ 
      { 
         "familyName": "Wakefield", 
         "givenName": "Robin" 
      },
		
      { 
         "familyName": "Miller", 
         "givenName": "Ben" 
      } 
   ],
	
   [ 
      { 
         "familyName": "Smith", 
         "givenName": "James"
      },
		
      { 
         "familyName": "Curtis", 
         "givenName": "Helen" 
      } 
   ],
	
   [ 
      { 
         "firstName": "Thomas", 
         "relationship": "father" 
      },
		
      { 
         "firstName": "Mary Kay", 
         "relationship": "mother" 
      } 
   ] 
]

이 쿼리의 결과 부모 하위 문서 만 검색되는 것을 볼 수 있습니다.

이 장에서는 FROM 절과 같이 선택 사항 인 WHERE 절을 다룰 것입니다. 소스에서 제공하는 JSON 문서 형식으로 데이터를 가져 오는 동안 조건을 지정하는 데 사용됩니다. 모든 JSON 문서는 결과를 고려하기 위해 지정된 조건을 "true"로 평가해야합니다. 주어진 조건이 충족되면 JSON 문서 형식으로 특정 데이터를 반환합니다. WHERE 절을 사용하여 레코드를 필터링하고 필요한 레코드 만 가져올 수 있습니다.

이 예에서는 동일한 세 가지 문서를 고려합니다. 다음은AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

WHERE 절이 사용되는 간단한 예를 살펴 보겠습니다.

이 쿼리의 WHERE 절에서 (WHERE f.id = "WakefieldFamily") 조건이 지정됩니다.

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

위 쿼리가 실행되면 다음 출력과 같이 WakefieldFamily에 대한 전체 JSON 문서가 반환됩니다.

[ 
   { 
      "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/" 
   } 
]

연산자는 비교 및 ​​산술 연산과 같은 연산을 수행하기 위해 주로 SQL WHERE 절에서 사용되는 예약어 또는 문자입니다. DocumentDB SQL은 다양한 스칼라 표현식도 지원합니다. 가장 일반적으로 사용되는 것은binary and unary expressions.

다음 SQL 연산자가 현재 지원되며 쿼리에 사용할 수 있습니다.

SQL 비교 연산자

다음은 DocumentDB SQL 문법에서 사용할 수있는 모든 비교 연산자 목록입니다.

S. 아니.	연산자 및 설명
1	= 두 피연산자의 값이 같은지 확인합니다. 그렇다면 조건이 참이됩니다.
2	!= 두 피연산자의 값이 같은지 확인합니다. 값이 같지 않으면 조건이 참이됩니다.
삼	<> 두 피연산자의 값이 같은지 확인합니다. 값이 같지 않으면 조건이 참이됩니다.
4	> 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 큰지 확인합니다. 그렇다면 조건이 참이됩니다.
5	< 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작은 지 확인합니다. 그렇다면 조건이 참이됩니다.
6	>= 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크거나 같은지 확인합니다. 그렇다면 조건이 참이됩니다.
7	<= 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작거나 같은지 확인합니다. 그렇다면 조건이 참이됩니다.

SQL 논리 연산자

다음은 DocumentDB SQL 문법에서 사용할 수있는 모든 논리 연산자의 목록입니다.

S. 아니.	연산자 및 설명
1	AND AND 연산자를 사용하면 SQL 문의 WHERE 절에 여러 조건이있을 수 있습니다.
2	BETWEEN BETWEEN 연산자는 최소값과 최대 값이 주어진 경우 값 집합 내에있는 값을 검색하는 데 사용됩니다.
삼	IN IN 연산자는 값을 지정된 리터럴 값 목록과 비교하는 데 사용됩니다.
4	OR OR 연산자는 SQL 문의 WHERE 절에서 여러 조건을 결합하는 데 사용됩니다.
5	NOT NOT 연산자는 사용되는 논리 연산자의 의미를 반대로합니다. 예를 들어, NOT EXISTS, NOT BETWEEN, NOT IN 등입니다. 이것은 부정 연산자입니다.

SQL 산술 연산자

다음은 DocumentDB SQL 문법에서 사용할 수있는 모든 산술 연산자 목록입니다.

S. 아니.	연산자 및 설명
1	+ Addition − 연산자의 양쪽에 값을 추가합니다.
2	- Subtraction − 왼손 피연산자에서 오른손 피연산자를 뺍니다.
삼	* Multiplication − 연산자의 양쪽에있는 값을 곱합니다.
4	/ Division − 왼손 피연산자를 오른손 피연산자로 나눕니다.
5	% Modulus − 왼손 피연산자를 오른손 피연산자로 나누고 나머지를 반환합니다.

이 예제에서도 동일한 문서를 고려할 것입니다. 다음은AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

WHERE 절에서 비교 연산자를 사용하는 간단한 예를 살펴 보겠습니다.

이 쿼리에서는 WHERE 절에서 (WHERE f.id = "WakefieldFamily") 조건이 지정되고 ID가 WakefieldFamily와 같은 문서를 검색합니다.

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

위 쿼리가 실행되면 다음 출력과 같이 WakefieldFamily에 대한 전체 JSON 문서가 반환됩니다.

[ 
   { 
      "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/" 
   } 
]

쿼리가 점수가 5보다 큰 어린이 데이터를 검색하는 또 다른 예를 살펴 보겠습니다.

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

위의 질의가 실행되면 출력과 같이 다음과 같은 하위 문서를 검색합니다.

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

BETWEEN 키워드는 SQL에서와 같이 값 범위에 대한 쿼리를 표현하는 데 사용됩니다. BETWEEN은 문자열이나 숫자에 사용할 수 있습니다. DocumentDB와 ANSI SQL에서 BETWEEN을 사용하는 것의 주요 차이점은 혼합 유형의 속성에 대해 범위 쿼리를 표현할 수 있다는 것입니다.

예를 들어, 어떤 문서에서는 "등급"을 숫자로 사용할 수 있고 다른 문서에서는 문자열 일 수 있습니다. 이러한 경우 두 가지 다른 유형의 결과 간의 비교는 "정의되지 않음"이며 문서를 건너 뜁니다.

이전 예의 세 가지 문서를 살펴 보겠습니다. 다음은AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

쿼리가 첫 번째 자녀의 성적이 1-5 (둘 다 포함) 인 모든 가족 문서를 반환하는 예를 살펴 보겠습니다.

다음은 BETWEEN 키워드를 사용한 쿼리와 AND 논리 연산자입니다.

SELECT * 
FROM Families.children[0] c 
WHERE c.grade BETWEEN 1 AND 5

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "givenName": "Michelle", 
      "gender": "female", 
      "grade": 1 
   }, 
	
   { 
      "firstName": "Henriette Thaulow", 
      "gender": "female", 
      "grade": 5, 
		
      "pets": [ 
         { 
            "givenName": "Fluffy",
            "type": "Rabbit" 
         } 
      ] 
   } 
]

이전 예의 범위를 벗어난 등급을 표시하려면 다음 쿼리에 표시된대로 NOT BETWEEN을 사용하십시오.

SELECT * 
FROM Families.children[0] c 
WHERE c.grade NOT BETWEEN 1 AND 5

이 쿼리가 실행될 때. 다음 출력을 생성합니다.

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

IN 키워드는 지정된 값이 목록의 값과 일치하는지 여부를 확인하는 데 사용할 수 있습니다. IN 연산자를 사용하면 WHERE 절에 여러 값을 지정할 수 있습니다. IN은 여러 OR 절을 연결하는 것과 같습니다.

유사한 세 가지 문서는 이전 예제에서 수행 한 것으로 간주됩니다. 다음은AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

간단한 예를 살펴 보겠습니다.

다음은 familyName이 "Smith"또는 Wakefield 인 데이터를 검색하는 쿼리입니다.

SELECT * 
FROM Families.parents[0] f 
WHERE f.familyName IN ('Smith', 'Wakefield')

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "familyName": "Wakefield", 
      "givenName": "Robin" 
   }, 
	
   { 
      "familyName": "Smith", 
      "givenName": "James" 
   } 
]

ID가 "SmithFamily"또는 "AndersenFamily"중 하나 인 모든 가족 문서를 검색하는 또 다른 간단한 예를 고려해 보겠습니다. 다음은 쿼리입니다.

SELECT * 
FROM Families  
WHERE Families.id IN ('SmithFamily', 'AndersenFamily')

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "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, 
      "_rid": "Ic8LAJFujgEDAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEDAAAAAAAAAA==/", 
      "_etag": "\"00000600-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   },
	
   { 
      "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, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   }
]

단일 값만 반환한다는 것을 알고있는 경우 VALUE 키워드는 본격적인 개체를 만드는 오버 헤드를 방지하여보다 간결한 결과 집합을 생성하는 데 도움이 될 수 있습니다. VALUE 키워드는 JSON 값을 반환하는 방법을 제공합니다.

간단한 예를 살펴 보겠습니다.

다음은 키워드가 VALUE 인 쿼리입니다.

SELECT VALUE "Hello World, this is DocumentDB SQL Tutorial"

이 쿼리가 실행되면 "Hello World, this is DocumentDB SQL Tutorial"스칼라를 반환합니다.

[ 
   "Hello World, this is DocumentDB SQL Tutorial" 
]

또 다른 예에서 이전 예의 세 문서를 고려해 보겠습니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

다음은 쿼리입니다.

SELECT VALUE f.location 
FROM Families f

이 쿼리가 실행되면 위치 레이블이없는 주소를 반환합니다.

[ 
   { 
      "state": "NY", 
      "county": "Manhattan", 
      "city": "NY" 
   }, 
	
   { 
      "state": "NY", 
      "county": "Queens", 
      "city": "Forest Hills" 
   },
	
   { 
      "state": "WA", 
      "county": "King", 
      "city": "Seattle" 
   } 
]

이제 VALUE Keyword없이 동일한 쿼리를 지정하면 위치 레이블이있는 주소를 반환합니다. 다음은 쿼리입니다.

SELECT f.location 
FROM Families f

이 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "location": { 
         "state": "NY", 
         "county": "Manhattan", 
         "city": "NY" 
      } 
   }, 
	
   { 
      "location": { 
         "state": "NY", 
         "county": "Queens", 
         "city": "Forest Hills" 
      } 
   },
	
   { 
      "location": { 
         "state": "WA", 
         "county": "King", 
         "city": "Seattle" 
      } 
   } 
]

Microsoft Azure DocumentDB는 JSON 문서에서 SQL을 사용하여 문서 쿼리를 지원합니다. 쿼리에서 ORDER BY 절을 사용하여 숫자와 문자열에 대한 컬렉션의 문서를 정렬 할 수 있습니다. 절에는 결과를 검색해야하는 순서를 지정하는 선택적 ASC / DESC 인수가 포함될 수 있습니다.

이전 예제와 동일한 문서를 고려할 것입니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

간단한 예를 살펴 보겠습니다.

다음은 ORDER BY 키워드를 포함하는 쿼리입니다.

SELECT  f.id, f.children[0].givenName,f.children[0].grade  
FROM Families f  
ORDER BY f.children[0].grade

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "id": "SmithFamily", 
      "givenName": "Michelle", 
      "grade": 1 
   },
	
   { 
      "id": "AndersenFamily", 
      "grade": 5 
   },
	
   { 
      "id": "WakefieldFamily", 
      "givenName": "Jesse", 
      "grade": 6 
   } 
]

또 다른 간단한 예를 살펴 보겠습니다.

다음은 ORDER BY 키워드와 DESC 선택적 키워드를 포함하는 쿼리입니다.

SELECT f.id, f.parents[0].familyName 
FROM Families f  
ORDER BY f.parents[0].familyName DESC

위의 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   {
      "id": "WakefieldFamily", 
      "familyName": "Wakefield" 
   },
	
   { 
      "id": "SmithFamily", 
      "familyName": "Smith" 
   },
	
   {
      "id": "AndersenFamily" 
   }
]

DocumentDB SQL에서 Microsoft는 JSON 배열에 대한 반복을 지원하기 위해 IN 키워드와 함께 사용할 수있는 새로운 구조를 추가했습니다. 반복에 대한 지원은 FROM 절에서 제공됩니다.

이전 예제와 유사한 세 가지 문서를 다시 고려할 것입니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

FROM 절에 IN 키워드가없는 간단한 예를 살펴 보겠습니다.

다음은 Families 컬렉션에서 모든 부모를 반환하는 쿼리입니다.

SELECT *  
FROM Families.parents

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   [ 
      { 
         "familyName": "Wakefield", 
         "givenName": "Robin" 
      },
		
      { 
         "familyName": "Miller", 
         "givenName": "Ben" 
      } 
   ], 
	
   [ 
      { 
         "familyName": "Smith", 
         "givenName": "James" 
      },
		
      { 
         "familyName": "Curtis", 
         "givenName": "Helen" 
      } 
   ], 
	
   [ 
      { 
         "firstName": "Thomas", 
         "relationship": "father" 
      },
		
      {
         "firstName": "Mary Kay", 
         "relationship": "mother" 
      } 
   ] 
]

위 출력에서 ​​볼 수 있듯이 각 제품군의 부모는 별도의 JSON 배열로 표시됩니다.

같은 예를 살펴 보지만 이번에는 FROM 절에서 IN 키워드를 사용합니다.

다음은 IN 키워드가 포함 된 쿼리입니다.

SELECT *  
FROM c IN Families.parents

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "familyName": "Wakefield", 
      "givenName": "Robin" 
   }, 
	
   { 
      "familyName": "Miller", 
      "givenName": "Ben" 
   },
	
   { 
      "familyName": "Smith", 
      "givenName": "James" 
   },
	
   { 
      "familyName": "Curtis", 
      "givenName": "Helen" 
   },
	
   { 
      "firstName": "Thomas", 
      "relationship": "father" 
   },
	
   { 
      "firstName": "Mary Kay", 
      "relationship": "mother" 
   }
	
   { 
      "id": "WakefieldFamily", 
      "givenName": "Jesse", 
      "grade": 6 
   } 
]

위의 예에서 반복을 사용하면 컬렉션의 상위 항목에 대해 반복을 수행하는 쿼리의 출력 배열이 서로 다른 것을 알 수 있습니다. 따라서 각 제품군의 모든 부모가 단일 어레이에 추가됩니다.

관계형 데이터베이스에서 Joins 절은 데이터베이스에있는 두 개 이상의 테이블의 레코드를 결합하는 데 사용되며 정규화 된 스키마를 디자인하는 동안 테이블간에 조인해야하는 필요성은 매우 중요합니다. DocumentDB는 스키마없는 문서의 비정규 화 된 데이터 모델을 다루기 때문에 DocumentDB SQL의 JOIN은 논리적으로 "selfjoin"과 동일합니다.

이전 예에서와 같이 세 가지 문서를 고려해 보겠습니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

JOIN 절이 작동하는 방식을 이해하기 위해 예제를 살펴 보겠습니다.

다음은 하위 문서에 루트를 결합하는 쿼리입니다.

SELECT f.id 
FROM Families f 
JOIN c IN f.children

위의 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "id": "WakefieldFamily" 
   },
	
   { 
      "id": "WakefieldFamily" 
   },
	
   { 
      "id": "SmithFamily" 
   },
	
   { 
      "id": "SmithFamily" 
   },
	
   { 
      "id": "AndersenFamily" 
   } 
]

위의 예에서 조인은 문서 루트와 두 JSON 개체간에 교차 제품을 만드는 하위 하위 루트 사이에 있습니다. 다음은 참고할 사항입니다.

• FROM 절에서 JOIN 절은 반복자입니다.

• 처음 두 문서 WakefieldFamily 및 SmithFamily에는 두 개의 하위 항목이 포함되어 있으므로 결과 집합에는 각 하위 항목에 대해 별도의 개체를 생성하는 교차 제품도 포함됩니다.

• 세 번째 문서 AndersenFamily에는 자식이 하나만 포함되어 있으므로이 문서에 해당하는 단일 개체 만 있습니다.

동일한 예를 살펴 보겠습니다. 그러나 이번에는 JOIN 절을 더 잘 이해하기 위해 자식 이름도 검색합니다.

다음은 하위 문서에 루트를 결합하는 쿼리입니다.

SELECT  
   f.id AS familyName, 
   c.givenName AS childGivenName, 
   c.firstName AS childFirstName 
FROM Families f  
JOIN c IN f.children

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "familyName": "WakefieldFamily", 
      "childGivenName": "Jesse" 
   },
	
   { 
      "familyName": "WakefieldFamily", 
      "childGivenName": "Lisa" 
   },
	
   { 
      "familyName": "SmithFamily", 
      "childGivenName": "Michelle" 
   },
	
   { 
      "familyName": "SmithFamily", 
      "childGivenName": "John" 
   },
	
   { 
      "familyName": "AndersenFamily", 
      "childFirstName": "Henriette Thaulow" 
   } 
]

관계형 데이터베이스에서 SQL 별칭은 테이블 또는 열 머리글의 이름을 임시로 바꾸는 데 사용됩니다. 마찬가지로 DocumentDB에서 별칭은 JSON 문서, 하위 문서, 개체 또는 모든 필드의 이름을 임시로 바꾸는 데 사용됩니다.

이름 변경은 일시적인 변경이며 실제 문서는 변경되지 않습니다. 기본적으로 별칭은 필드 / 문서 이름을 더 읽기 쉽게 만들기 위해 만들어집니다. 앨리어싱의 경우 선택 사항 인 AS 키워드가 사용됩니다.

이전 예제에서 사용 된 것과 유사한 문서 3 개를 고려해 보겠습니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

별칭을 논의하기위한 예를 살펴 보겠습니다.

다음은 하위 문서에 루트를 결합하는 쿼리입니다. f.id AS familyName, c.givenName AS childGivenName 및 c.firstName AS childFirstName과 같은 별칭이 있습니다.

SELECT  
   f.id AS familyName, 
   c.givenName AS childGivenName, 
   c.firstName AS childFirstName 
FROM Families f  
JOIN c IN f.children

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "familyName": "WakefieldFamily", 
      "childGivenName": "Jesse" 
   },
	
   { 
      "familyName": "WakefieldFamily",
	  "childGivenName": "Lisa" 
   },
	
   { 
      "familyName": "SmithFamily", 
      "childGivenName": "Michelle" 
   },
	
   { 
      "familyName": "SmithFamily", 
      "childGivenName": "John" 
   },
	
   { 
      "familyName": "AndersenFamily", 
      "childFirstName": "Henriette Thaulow" 
   } 
]

위의 출력은 파일 이름이 변경되었지만 일시적인 변경이며 원본 문서는 수정되지 않음을 보여줍니다.

DocumentDB SQL에서 Microsoft는 배열을 쉽게 만들 수있는 주요 기능을 추가했습니다. 이는 쿼리를 실행할 때 결과적으로 쿼리 결과로 JSON 객체와 유사한 컬렉션 배열을 생성한다는 것을 의미합니다.

이전 예제와 동일한 문서를 고려해 보겠습니다.

다음은 AndersenFamily 문서.

{ 
   "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 
}

다음은 SmithFamily 문서.

{ 
   "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 
}

다음은 WakefieldFamily 문서.

{ 
   "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 
}

예를 살펴 보겠습니다.

다음은 각 가족의 성 및 주소를 반환하는 쿼리입니다.

SELECT f.id AS FamilyName, 
[f.location.city, f.location.county, f.location.state] AS Address 
FROM Families f

보시다시피 도시, 카운티 및 주 필드는 대괄호로 묶여 배열을 만들고이 배열의 이름은 Address입니다. 위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "FamilyName": "WakefieldFamily", 
      "Address": [ 
         "NY", 
         "Manhattan", 
         "NY" 
      ] 
   },
	
   { 
      "FamilyName": "SmithFamily", 
      "Address": [
         "Forest Hills", 
         "Queens", 
         "NY" 
      ] 
   },
	
   { 
      "FamilyName": "AndersenFamily", 
      "Address": [ 
         "Seattle", 
         "King", 
         "WA" 
      ] 
   } 
]

위 출력의 주소 배열에시, 카운티 및 주 정보가 추가됩니다.

DocumentDB SQL에서 SELECT 절은 상수, 산술 식, 논리식 등과 같은 스칼라 식도 지원합니다. 일반적으로 스칼라 쿼리는 컬렉션의 문서를 실제로 쿼리하지 않고 식을 평가하기 때문에 거의 사용되지 않습니다. 그러나 스칼라 식 쿼리를 사용하여 기본 사항, 쿼리에서 식을 사용하고 JSON을 구성하는 방법을 배우는 것이 여전히 유용하며 이러한 개념은 컬렉션의 문서에 대해 실행할 실제 쿼리에 직접 적용됩니다.

여러 스칼라 쿼리가 포함 된 예를 살펴 보겠습니다.

쿼리 탐색기에서 실행할 텍스트 만 선택하고 '실행'을 클릭합니다. 첫 번째를 실행 해 보겠습니다.

SELECT "Hello"

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "$1": "Hello" 
   } 
]

이 출력은 약간 혼란스러워 보일 수 있으므로 분석해 보겠습니다.

• 첫째, 지난 데모에서 보았 듯이 쿼리 결과는 JSON 배열로 반환되기 때문에 항상 대괄호 안에 포함됩니다. 단일 문서 만 반환하는 이와 같은 스칼라 표현식 쿼리의 결과도 마찬가지입니다.

• 하나의 문서가 포함 된 배열이 있고 해당 문서에는 SELECT 문의 단일 표현식에 대한 단일 속성이 있습니다.

• SELECT 문은이 속성의 이름을 제공하지 않으므로 DocumentDB는 $ 1을 사용하여 자동으로 생성합니다.

• 이것은 일반적으로 우리가 원하는 것이 아니기 때문에 AS를 사용하여 쿼리에서 표현식의 별칭을 지정할 수 있습니다.이 예에서는 생성 된 문서의 속성 이름을 원하는 방식으로 설정합니다.

SELECT "Hello" AS word

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "word": "Hello" 
   } 
]

마찬가지로 다음은 또 다른 간단한 쿼리입니다.

SELECT ((2 + 11 % 7)-2)/3

쿼리는 다음 출력을 검색합니다.

[ 
   { 
      "$1": 1.3333333333333333 
   } 
]

중첩 배열 및 포함 된 개체를 형성하는 또 다른 예를 살펴 보겠습니다.

SELECT 
   { 
      "words1": 
         ["Hello", "World"], 
      "words2": 
         ["How", "Are", "You?"] 
   } AS allWords

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "allWords": { 
         "words1": [ 
            "Hello", 
            "World" 
         ],
			
         "words2": [ 
            "How", 
            "Are", 
            "You?" 
         ] 
      } 
   } 
]

관계형 데이터베이스에서 매개 변수가있는 쿼리는 매개 변수에 자리 표시자가 사용되고 실행 시간에 매개 변수 값이 제공되는 쿼리입니다. DocumentDB는 매개 변수가있는 쿼리도 지원하며 매개 변수가있는 쿼리의 매개 변수는 익숙한 @ 표기법으로 표현할 수 있습니다. 매개 변수화 된 쿼리를 사용하는 가장 중요한 이유는 SQL 주입 공격을 방지하기위한 것입니다. 또한 강력한 처리 및 사용자 입력 이스케이프를 제공 할 수 있습니다.

.Net SDK를 사용할 예를 살펴 보겠습니다. 다음은 컬렉션을 삭제하는 코드입니다.

private async static Task DeleteCollection(DocumentClient client, string collectionId) { 
   Console.WriteLine(); 
   Console.WriteLine(">>> Delete Collection {0} in {1} <<<", 
   collectionId, _database.Id);  
   var query = new SqlQuerySpec { 
      QueryText = "SELECT * FROM c WHERE c.id = @id", 
      Parameters = new SqlParameterCollection { new SqlParameter { Name = 
         "@id", Value = collectionId } } 
   };
   
   DocumentCollection collection = client.CreateDocumentCollectionQuery(database.SelfLink, 
      query).AsEnumerable().First();  
		
   await client.DeleteDocumentCollectionAsync(collection.SelfLink);  
	
   Console.WriteLine("Deleted collection {0} from database {1}", 
      collectionId, _database.Id); 
}

매개 변수가있는 쿼리의 구성은 다음과 같습니다.

var query = new SqlQuerySpec { 
   QueryText = "SELECT * FROM c WHERE c.id = @id",
   Parameters = new SqlParameterCollection { new SqlParameter { Name = 
      "@id", Value = collectionId } } 
};

collectionId를 하드 코딩하지 않으므로이 메소드를 사용하여 컬렉션을 삭제할 수 있습니다. SQL Server와 유사하게 '@'기호를 사용하여 매개 변수 이름을 접두사로 지정할 수 있습니다.

위의 예에서는이 SqlQuerySpec의 매개 변수 속성에 할당 된이 SqlParameterCollection에 Id 매개 변수가 정의되어있는 Id별로 특정 컬렉션을 쿼리합니다. 그런 다음 SDK는 내부에 collectionId가 포함 된 DocumentDB에 대한 최종 쿼리 문자열을 구성하는 작업을 수행합니다. 쿼리를 실행 한 다음 SelfLink를 사용하여 컬렉션을 삭제합니다.

다음은 CreateDocumentClient 작업 구현입니다.

private static async Task CreateDocumentClient() { 
   // Create a new instance of the DocumentClient 
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) { 
      database = client.CreateDatabaseQuery("SELECT * FROM 
         c WHERE c.id = 'earthquake'").AsEnumerable().First(); 
			
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink, 
         "SELECT * FROM c WHERE c.id = 'myfirstdb'").AsEnumerable().First();
			
      await DeleteCollection(client, "MyCollection1"); 
      await DeleteCollection(client, "MyCollection2"); 
   } 
}

코드가 실행되면 다음과 같은 출력이 생성됩니다.

**** Delete Collection MyCollection1 in mydb **** 
Deleted collection MyCollection1 from database myfirstdb 
 
**** Delete Collection MyCollection2 in mydb **** 
Deleted collection MyCollection2 from database myfirstdb

다른 예를 살펴 보겠습니다. 성 및 주소 상태를 매개 변수로 사용하는 쿼리를 작성하고 사용자 입력에 따라 lastname 및 location.state의 다양한 값에 대해이를 실행할 수 있습니다.

SELECT *  
FROM Families f 
WHERE f.lastName = @lastName AND f.location.state = @addressState

이 요청은 다음 코드와 같이 매개 변수화 된 JSON 쿼리로 DocumentDB에 전송 될 수 있습니다.

{       
   "query": "SELECT * FROM Families f WHERE f.lastName = @lastName AND 
      f.location.state = @addressState", 
		
   "parameters": [           
      {"name": "@lastName", "value": "Wakefield"},          
      {"name": "@addressState", "value": "NY"},            
   ]  
}

DocumentDB는 쿼리 내에서 사용할 수있는 일반적인 작업을위한 다양한 내장 함수를 지원합니다. 수학적 계산을 수행하기위한 많은 함수와 다양한 스키마로 작업하는 동안 매우 유용한 유형 검사 함수가 있습니다. 이러한 함수는 특정 속성이 존재하는지, 그것이 숫자인지 문자열인지, 부울인지 객체인지 여부를 테스트 할 수 있습니다.

또한 문자열 구문 분석 및 조작을위한 이러한 편리한 함수와 배열 작업을위한 여러 함수를 사용하여 배열 연결 및 배열에 특정 요소가 포함되어 있는지 테스트하는 것과 같은 작업을 수행 할 수 있습니다.

다음은 다양한 유형의 내장 함수입니다.

S. 아니.	내장 기능 및 설명
1	수학 함수 수학 함수는 일반적으로 인수로 제공되는 입력 값을 기반으로 계산을 수행하고 숫자 값을 반환합니다.
2	유형 검사 기능 유형 검사 기능을 사용하면 SQL 쿼리 내에서 표현식 유형을 확인할 수 있습니다.
삼	문자열 함수 문자열 함수는 문자열 입력 값에 대해 작업을 수행하고 문자열, 숫자 또는 부울 값을 반환합니다.
4	배열 함수 배열 함수는 배열 입력 값에 대해 연산을 수행하고 숫자, 부울 또는 배열 값의 형태로 반환합니다.
5	공간 함수 DocumentDB는 지리 공간 쿼리를위한 OGC (Open Geospatial Consortium) 내장 기능도 지원합니다.

DocumentDB에서는 실제로 SQL을 사용하여 문서를 쿼리합니다. .NET 개발을 수행하는 경우 사용할 수 있고 LINQ 쿼리에서 적절한 SQL을 생성 할 수있는 LINQ 공급자도 있습니다.

지원되는 데이터 유형

DocumentDB에서 모든 JSON 기본 유형은 다음과 같이 DocumentDB .NET SDK에 포함 된 LINQ 공급자에서 지원됩니다.

• Numeric
• Boolean
• String
• Null

지원되는 표현

다음 스칼라 식은 DocumentDB .NET SDK에 포함 된 LINQ 공급자에서 지원됩니다.

• Constant Values − 원시 데이터 유형의 상수 값을 포함합니다.

• Property/Array Index Expressions − 표현식은 객체 또는 배열 요소의 속성을 나타냅니다.

• Arithmetic Expressions − 숫자 및 부울 값에 대한 일반적인 산술 표현식을 포함합니다.

• String Comparison Expression − 문자열 값을 상수 문자열 값과 비교하는 것을 포함합니다.

• Object/Array Creation Expression− 복합 값 유형 또는 익명 유형의 객체 또는 이러한 객체의 배열을 반환합니다. 이러한 값은 중첩 될 수 있습니다.

지원되는 LINQ 연산자

다음은 DocumentDB .NET SDK에 포함 된 LINQ 공급자에서 지원되는 LINQ 연산자 목록입니다.

• Select − 프로젝션은 객체 생성을 포함한 SQL SELECT로 변환됩니다.

• Where− 필터는 SQL WHERE로 변환되고 &&, || 사이의 변환을 지원합니다. 그리고! SQL 연산자에.

• SelectMany− SQL JOIN 절에 배열을 해제 할 수 있습니다. 배열 요소를 필터링하기 위해 표현식을 연결 / 중첩하는 데 사용할 수 있습니다.

• OrderBy and OrderByDescending − 오름차순 / 내림차순으로 ORDER BY로 변환합니다.

• CompareTo− 범위 비교로 변환합니다. .NET에서 비교할 수 없기 때문에 일반적으로 문자열에 사용됩니다.

• Take − 쿼리 결과를 제한하기 위해 SQL TOP으로 변환합니다.

• Math Functions − .NET의 Abs, Acos, Asin, Atan, Ceiling, Cos, Exp, Floor, Log, Log10, Pow, Round, Sign, Sin, Sqrt, Tan, Truncate에서 동등한 SQL 내장 함수로의 변환을 지원합니다.

• String Functions − .NET의 Concat, Contains, EndsWith, IndexOf, Count, ToLower, TrimStart, Replace, Reverse, TrimEnd, StartsWith, SubString, ToUpper에서 동등한 SQL 내장 함수로의 변환을 지원합니다.

• Array Functions − .NET의 Concat, Contains 및 Count에서 동등한 SQL 내장 함수로의 변환을 지원합니다.

• Geospatial Extension Functions − 스텁 메소드 Distance, Within, IsValid 및 IsValidDetailed에서 동등한 SQL 내장 함수로 변환을 지원합니다.

• User-Defined Extension Function − 스텁 메서드 UserDefinedFunctionProvider.Invoke에서 해당 사용자 정의 함수로의 변환을 지원합니다.

• Miscellaneous− 통합 및 조건부 연산자의 번역을 지원합니다. 컨텍스트에 따라 포함을 문자열 CONTAINS, ARRAY_CONTAINS 또는 SQL IN으로 변환 할 수 있습니다.

.Net SDK를 사용할 예를 살펴 보겠습니다. 다음은이 예에서 고려할 세 가지 문서입니다.

신규 고객 1

{ 
   "name": "New Customer 1", 
   "address": { 
      "addressType": "Main Office", 
      "addressLine1": "123 Main Street", 
		
      "location": { 
         "city": "Brooklyn", 
         "stateProvinceName": "New York" 
      },
	  
      "postalCode": "11229", 
      "countryRegionName": "United States" 
   }, 
}

신규 고객 2

{ 
   "name": "New Customer 2", 
	
   "address": {
      "addressType": "Main Office", 
      "addressLine1": "678 Main Street", 
		
      "location": { 
         "city": "London", 
         "stateProvinceName": " London " 
      }, 
	  
      "postalCode": "11229", 
      "countryRegionName": "United Kingdom" 
   }, 
}

신규 고객 3

{ 
   "name": "New Customer 3", 
	
   "address": { 
      "addressType": "Main Office", 
      "addressLine1": "12 Main Street", 
		
      "location": { 
         "city": "Brooklyn", 
         "stateProvinceName": "New York" 
      },
	  
      "postalCode": "11229", 
      "countryRegionName": "United States" 
   },
}

다음은 LINQ를 사용하여 쿼리하는 코드입니다. LINQ 쿼리를 다음에서 정의했습니다.q하지만 .ToList를 실행할 때까지 실행되지 않습니다.

private static void QueryDocumentsWithLinq(DocumentClient client) { 
   Console.WriteLine(); 
   Console.WriteLine("**** Query Documents (LINQ) ****"); 
   Console.WriteLine();  
   Console.WriteLine("Quering for US customers (LINQ)"); 
   var q = 
      from d in client.CreateDocumentQuery<Customer>(collection.DocumentsLink) 
      where d.Address.CountryRegionName == "United States" 
		
   select new { 
      Id = d.Id, 
      Name = d.Name, 
      City = d.Address.Location.City 
   };
   
   var documents = q.ToList();  
   Console.WriteLine("Found {0} US customers", documents.Count); 
	
   foreach (var document in documents) { 
      var d = document as dynamic; 
      Console.WriteLine(" Id: {0}; Name: {1}; City: {2}", d.Id, d.Name, d.City); 
   }
   
   Console.WriteLine(); 
}

SDK는 LINQ 쿼리를 DocumentDB 용 SQL 구문으로 변환하여 LINQ 구문을 기반으로 SELECT 및 WHERE 절을 생성합니다.

CreateDocumentClient 작업에서 위의 쿼리를 호출 해 보겠습니다.

private static async Task CreateDocumentClient() { 
   // Create a new instance of the DocumentClient 
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)) { 
      database = client.CreateDatabaseQuery("SELECT * FROM c WHERE c.id = 
         'myfirstdb'").AsEnumerable().First(); 
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink, 
         "SELECT * FROM c WHERE c.id = 'MyCollection'").AsEnumerable().First();  
      QueryDocumentsWithLinq(client); 
   } 
}

위의 코드가 실행되면 다음과 같은 출력이 생성됩니다.

**** Query Documents (LINQ) **** 
 
Quering for US customers (LINQ) 
Found 2 US customers 
   Id: 7e9ad4fa-c432-4d1a-b120-58fd7113609f; Name: New Customer 1; City: Brooklyn 
   Id: 34e9873a-94c8-4720-9146-d63fb7840fad; Name: New Customer 1; City: Brooklyn

요즘 JavaScript는 브라우저뿐만 아니라 어디에나 있습니다. DocumentDB는 JavaScript를 일종의 현대 T-SQL로 수용하고 데이터베이스 엔진 내에서 기본적으로 JavaScript 논리의 트랜잭션 실행을 지원합니다. DocumentDB는 저장 프로 시저 및 트리거와 관련하여 컬렉션에서 직접 JavaScript 기반 응용 프로그램 논리를 실행하기위한 프로그래밍 모델을 제공합니다.

간단한 저장 프로 시저를 생성하는 예를 살펴 보겠습니다. 다음은 단계입니다-

Step 1 − 새 콘솔 응용 프로그램을 만듭니다.

Step 2− NuGet에서 .NET SDK를 추가합니다. 여기서는 .NET SDK를 사용합니다. 즉, 저장 프로 시저를 생성, 실행 및 삭제하는 C # 코드를 작성하지만 저장 프로 시저 자체는 JavaScript로 작성됩니다.

Step 3 − 솔루션 탐색기에서 프로젝트를 마우스 오른쪽 버튼으로 클릭합니다.

Step 4 − 저장 프로 시저에 대한 새 JavaScript 파일을 추가하고 이름을 HelloWorldStoreProce.js로 지정합니다.

모든 저장 프로시 저는 JavaScript 함수일 뿐이므로 새 함수를 만들고 당연히이 함수의 이름도 지정합니다. HelloWorldStoreProce. 함수에 이름을 부여해도 상관 없습니다. DocumentDB는이 저장 프로 시저를 만들 때 제공 한 ID로만 참조합니다.

function HelloWorldStoreProce() { 
   var context = getContext(); 
   var response = context.getResponse(); 
   response.setBody('Hello, and welcome to DocumentDB!'); 
}

저장 프로 시저가 수행하는 모든 작업은 컨텍스트에서 응답 개체를 가져 와서 setBody호출자에게 문자열을 반환하는 메서드. C # 코드에서는 저장 프로 시저를 만들고 실행 한 다음 삭제합니다.

저장 프로시 저는 컬렉션별로 범위가 지정되므로 저장 프로 시저를 만들려면 컬렉션의 SelfLink가 필요합니다.

Step 5 −에 대한 첫 번째 쿼리 myfirstdb 데이터베이스 다음 MyCollection 수집.

저장 프로 시저를 만드는 것은 DocumentDB에서 다른 리소스를 만드는 것과 같습니다.

private async static Task SimpleStoredProcDemo() {  
   var endpoint = "https://azuredocdbdemo.documents.azure.com:443/"; 
   var masterKey = 
      "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";
	  
   using (var client = new DocumentClient(new Uri(endpoint), masterKey)) { 
      // Get database 
      Database database = client 
         .CreateDatabaseQuery("SELECT * FROM c WHERE c.id = 'myfirstdb'") 
         .AsEnumerable() 
         .First();
			
      // Get collection 
      DocumentCollection collection = client 
         .CreateDocumentCollectionQuery(database.CollectionsLink, "SELECT * FROM 
         c WHERE c.id = 'MyCollection'") 
         .AsEnumerable() 
         .First();
			
      // Create stored procedure 
      var sprocBody = File.ReadAllText(@"..\..\HelloWorldStoreProce.js"); 
		
      var sprocDefinition = new StoredProcedure { 
         Id = "HelloWorldStoreProce", 
         Body = sprocBody 
      };
	  
      StoredProcedure sproc = await client.
         CreateStoredProcedureAsync(collection.SelfLink, sprocDefinition); 
      Console.WriteLine("Created stored procedure {0} ({1})", 
         sproc.Id, sproc.ResourceId);
				  
      // Execute stored procedure 
      var result = await client.ExecuteStoredProcedureAsync
      
       (sproc.SelfLink); Console.WriteLine("Executed stored procedure; response = {0}", result.Response); // Delete stored procedure await client.DeleteStoredProcedureAsync(sproc.SelfLink); Console.WriteLine("Deleted stored procedure {0} ({1})", sproc.Id, sproc.ResourceId); } } 
      

Step 6 − 먼저 새 리소스에 대한 Id를 사용하여 정의 개체를 생성 한 다음 다음에서 Create 메서드 중 하나를 호출합니다. DocumentClient목적. 저장 프로 시저의 경우 정의에는 서버로 전달하려는 실제 JavaScript 코드와 ID가 포함됩니다.

Step 7 − 전화 File.ReadAllText JS 파일에서 스토어드 프로 시저 코드를 추출합니다.

Step 8 − 정의 개체의 본문 속성에 저장 프로 시저 코드를 할당합니다.

DocumentDB에 관한 한 여기서 정의에서 지정한 Id는 실제로 JavaScript 함수의 이름에 관계없이 저장 프로 시저의 이름입니다.

그럼에도 불구하고 저장 프로 시저 및 기타 서버 측 개체를 만들 때 JavaScript 함수의 이름을 지정하고 해당 함수 이름이 DocumentDB에 대한 정의에서 설정 한 Id와 일치하는 것이 좋습니다.

Step 9 − 전화 CreateStoredProcedureAsync, 전달 SelfLink 에 대한 MyCollection수집 및 저장 프로 시저 정의. 이렇게하면 저장 프로 시저가 생성되고ResourceId DocumentDB가 할당했습니다.

Step 10 − 저장 프로 시저를 호출합니다. ExecuteStoredProcedureAsync저장 프로 시저에서 반환 된 값의 예상 데이터 형식으로 설정 한 형식 매개 변수를 사용합니다. 동적 개체를 반환하려는 경우 개체로 간단히 지정할 수 있습니다. 이는 런타임에 속성이 바인딩되는 개체입니다.

이 예에서는 저장 프로 시저가 문자열을 반환한다는 것을 알고 있으므로 다음을 호출합니다. ExecuteStoredProcedureAsync<string>.

다음은 Program.cs 파일의 전체 구현입니다.

using Microsoft.Azure.Documents; 
using Microsoft.Azure.Documents.Client; 
using Microsoft.Azure.Documents.Linq; 

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.IO; 

using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
 
namespace DocumentDBStoreProce { 
   class Program { 
      private static void Main(string[] args) { 
         Task.Run(async () => { 
            await SimpleStoredProcDemo(); 
         }).Wait(); 
      } 
	  
      private async static Task SimpleStoredProcDemo() {  
         var endpoint = "https://azuredocdbdemo.documents.azure.com:443/"; 
         var masterKey = 
            "BBhjI0gxdVPdDbS4diTjdloJq7Fp4L5RO/StTt6UtEufDM78qM2CtBZWbyVwFPSJIm8AcfDu2O+AfV T+TYUnBQ==";  
				
         using (var client = new DocumentClient(new Uri(endpoint), masterKey)) { 
            // Get database 
            Database database = client 
               .CreateDatabaseQuery("SELECT * FROM c WHERE c.id = 'myfirstdb'")
               .AsEnumerable() 
               .First(); 
					
            // Get collection 
            DocumentCollection collection = client 
               .CreateDocumentCollectionQuery(database.CollectionsLink, 
               "SELECT * FROM c WHERE c.id = 'MyCollection'") 
               .AsEnumerable() 
               .First();
					 
            // Create stored procedure 
            var sprocBody = File.ReadAllText(@"..\..\HelloWorldStoreProce.js"); 
				
            var sprocDefinition = new StoredProcedure { 
               Id = "HelloWorldStoreProce", 
               Body = sprocBody 
            };
			
            StoredProcedure sproc = await client
               .CreateStoredProcedureAsync(collection.SelfLink, sprocDefinition);
					
            Console.WriteLine("Created stored procedure {0} ({1})", sproc
               .Id, sproc.ResourceId);
					 
            // Execute stored procedure 
            var result = await client
               .ExecuteStoredProcedureAsync<string>(sproc.SelfLink); 
            Console.WriteLine("Executed stored procedure; response = {0}", 
               result.Response);
					
            // Delete stored procedure 
            await client.DeleteStoredProcedureAsync(sproc.SelfLink); 
            Console.WriteLine("Deleted stored procedure {0} ({1})", 
               sproc.Id, sproc.ResourceId); 
         } 
      } 
   } 
}

위의 코드가 실행되면 다음과 같은 출력이 생성됩니다.

Created stored procedure HelloWorldStoreProce (Ic8LAMEUVgACAAAAAAAAgA==)

Executed stored procedure; response = Hello, and welcome to DocumentDB!

위 출력에서 ​​볼 수 있듯이 응답 속성에는 "Hello, welcome to DocumentDB!"가 있습니다. 저장 프로 시저에서 반환합니다.

DocumentDB SQL은 사용자 정의 함수 (UDF)를 지원합니다. UDF는 작성할 수있는 또 다른 종류의 JavaScript 함수이며 예상대로 작동합니다. 쿼리에서 참조 할 수있는 사용자 지정 비즈니스 논리로 쿼리 언어를 확장하는 UDF를 만들 수 있습니다.

DocumentDB SQL 구문은 이러한 UDF를 사용하는 사용자 지정 응용 프로그램 논리를 지원하도록 확장되었습니다. UDF는 DocumentDB에 등록 된 다음 SQL 쿼리의 일부로 참조 될 수 있습니다.

이 예에 대해 다음 세 가지 문서를 고려해 보겠습니다.

AndersenFamily 문서는 다음과 같습니다.

{ 
   "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 
}

SmithFamily 문서는 다음과 같습니다.

{ 
   "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 
}

WakefieldFamily 문서는 다음과 같습니다.

{ 
   "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 
}

간단한 UDF를 만드는 예제를 살펴 보겠습니다.

다음은 구현입니다 CreateUserDefinedFunctions.

private async static Task CreateUserDefinedFunctions(DocumentClient client) { 
   Console.WriteLine(); 
   Console.WriteLine("**** Create User Defined Functions ****"); 
   Console.WriteLine();  
	
   await CreateUserDefinedFunction(client, "udfRegEx");  
}

udfRegEx가 있고 CreateUserDefinedFunction에서 로컬 파일에서 JavaScript 코드를 얻습니다. 새 UDF에 대한 정의 개체를 생성하고 다음 코드와 같이 컬렉션의 SelfLink 및 udfDefinition 개체를 사용하여 CreateUserDefinedFunctionAsync를 호출합니다.

private async static Task<UserDefinedFunction>
CreateUserDefinedFunction(DocumentClient client, string udfId) { 
   var udfBody = File.ReadAllText(@"..\..\Server\" + udfId + ".js"); 
	
   var udfDefinition = new UserDefinedFunction { 
      Id = udfId, 
      Body = udfBody 
   }; 
   
   var result = await client
      .CreateUserDefinedFunctionAsync(_collection.SelfLink, udfDefinition); 
   var udf = result.Resource; 
	
   Console.WriteLine("Created user defined function {0}; RID: {1}", 
      udf.Id, udf.ResourceId);  
		
   return udf; 
}

결과의 리소스 속성에서 새 UDF를 가져와 호출자에게 다시 반환합니다. 기존 UDF를 표시하려면 다음을 구현합니다.ViewUserDefinedFunctions. 우리는 부른다CreateUserDefinedFunctionQuery 평소와 같이 반복합니다.

private static void ViewUserDefinedFunctions(DocumentClient client) { 
   Console.WriteLine(); 
   Console.WriteLine("**** View UDFs ****"); 
   Console.WriteLine(); 
	
   var udfs = client  
      .CreateUserDefinedFunctionQuery(_collection.UserDefinedFunctionsLink) 
      .ToList();  
		
   foreach (var udf in udfs) { 
      Console.WriteLine("User defined function {0}; RID: {1}", udf.Id, udf.ResourceId); 
   }
}

DocumentDB SQL은 하위 문자열 또는 정규 표현식을 검색하는 내장 함수를 제공하지 않으므로 다음의 작은 한 줄로 JavaScript 함수 인 그 차이를 채 웁니다.

function udfRegEx(input, regex) { 
   return input.match(regex); 
}

첫 번째 매개 변수의 입력 문자열이 주어지면 두 번째 매개 변수의 패턴 일치 문자열을에 전달하는 JavaScript의 내장 정규식 지원을 사용합니다.match. 하위 문자열 쿼리를 실행하여 Andersen이라는 단어가 포함 된 모든 상점을 찾을 수 있습니다.lastName 특성.

private static void Execute_udfRegEx(DocumentClient client) { 
   var sql = "SELECT c.name FROM c WHERE udf.udfRegEx(c.lastName, 'Andersen') != null";
	
   Console.WriteLine(); 
   Console.WriteLine("Querying for Andersen"); 
	
   var documents = client.CreateDocumentQuery(_collection.SelfLink, sql).ToList();  
   Console.WriteLine("Found {0} Andersen:", documents.Count); 
	
   foreach (var document in documents) { 
      Console.WriteLine("Id: {0}, Name: {1}", document.id, document.lastName); 
   } 
}

접두사로 모든 ​​UDF 참조를 한정해야합니다. udf. 우리는 방금 SQL을CreateDocumentQuery일반적인 쿼리처럼. 마지막으로 위의 쿼리를CreateDocumentClient 직무

private static async Task CreateDocumentClient() { 
   // Create a new instance of the DocumentClient 
	
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)){ 
      database = client.CreateDatabaseQuery("SELECT * FROM c WHERE 
         c.id = 'myfirstdb'").AsEnumerable().First();
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink, 
         "SELECT * FROM c WHERE c.id = 'Families'").AsEnumerable().First();
			 
      await CreateUserDefinedFunctions(client);
   
      ViewUserDefinedFunctions(client);
   
      Execute_udfRegEx(client); 
   } 
}

위의 코드가 실행되면 다음과 같은 출력이 생성됩니다.

**** Create User Defined Functions ****  
Created user defined function udfRegEx; RID: kV5oANVXnwAlAAAAAAAAYA==  
**** View UDFs ****  
User defined function udfRegEx; RID: kV5oANVXnwAlAAAAAAAAYA==  
Querying for Andersen 
Found 1 Andersen: 
 Id: AndersenFamily, Name: Andersen

Composite Query기존 쿼리의 데이터를 결합한 다음 결합 된 데이터 세트를 표시하는 보고서 결과를 표시하기 전에 필터, 집계 등을 적용 할 수 있습니다. 복합 쿼리는 기존 쿼리에 대한 여러 수준의 관련 정보를 검색하고 결합 된 데이터를 단일 및 평면화 된 쿼리 결과로 제공합니다.

복합 쿼리를 사용하면 다음과 같은 옵션도 있습니다.

• 사용자의 속성 선택에 따라 필요하지 않은 테이블 및 필드를 제거하려면 SQL 정리 옵션을 선택하십시오.

• ORDER BY 및 GROUP BY 절을 설정합니다.

• 복합 쿼리의 결과 집합에 대한 필터로 WHERE 절을 설정합니다.

위의 연산자를 구성하여보다 강력한 쿼리를 구성 할 수 있습니다. DocumentDB는 중첩 된 컬렉션을 지원하기 때문에 컴포지션을 연결하거나 중첩 할 수 있습니다.

이 예제를 위해 다음 문서를 고려해 봅시다.

AndersenFamily 문서는 다음과 같습니다.

{ 
   "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 
}

SmithFamily 문서는 다음과 같습니다.

{ 
   "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 
}

WakefieldFamily 문서는 다음과 같습니다.

{ 
   "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 
}

연결된 쿼리의 예를 살펴 보겠습니다.

다음은 첫 번째 자녀가있는 가족의 ID와 위치를 검색하는 쿼리입니다. givenName 미셸입니다.

SELECT f.id,f.location 
FROM Families f 
WHERE f.children[0].givenName = "Michelle"

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[
   { 
      "id": "SmithFamily", 
      "location": { 
         "state": "NY", 
         "county": "Queens", 
         "city": "Forest Hills" 
      }
   }
]

연결된 쿼리의 다른 예를 살펴 보겠습니다.

다음은 첫 번째 자녀 등급이 3보다 큰 모든 문서를 반환하는 쿼리입니다.

SELECT * 
FROM Families f 
WHERE ({grade: f.children[0].grade}.grade > 3)

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "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/" 
   },
	
   { 
      "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, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   } 
]

살펴 보겠습니다 example 중첩 된 쿼리의

다음은 모든 부모를 반복 한 다음 문서를 반환하는 쿼리입니다. familyName 스미스입니다.

SELECT * 
FROM p IN Families.parents 
WHERE p.familyName = "Smith"

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   { 
      "familyName": "Smith", 
      "givenName": "James" 
   } 
]

고려하자 another example 중첩 된 쿼리의

다음은 모든 항목을 반환하는 쿼리입니다. familyName.

SELECT VALUE p.familyName
FROM Families f 
JOIN p IN f.parents

위 쿼리가 실행되면 다음과 같은 출력이 생성됩니다.

[ 
   "Wakefield", 
   "Miller", 
   "Smith", 
   "Curtis" 
]