DocumentDB SQL - Hướng dẫn nhanh
DocumentDB là nền tảng cơ sở dữ liệu tài liệu NoSQL mới nhất của Microsoft chạy trên Azure. Trong hướng dẫn này, chúng ta sẽ tìm hiểu tất cả về cách truy vấn tài liệu bằng cách sử dụng phiên bản SQL đặc biệt được hỗ trợ bởi DocumentDB.
Cơ sở dữ liệu tài liệu NoSQL
DocumentDB là cơ sở dữ liệu tài liệu NoSQL mới nhất của Microsoft, tuy nhiên, khi chúng tôi nói cơ sở dữ liệu tài liệu NoSQL, chính xác thì ý của chúng tôi là NoSQL và cơ sở dữ liệu tài liệu là gì?
SQL có nghĩa là Ngôn ngữ truy vấn có cấu trúc, là ngôn ngữ truy vấn truyền thống của cơ sở dữ liệu quan hệ. SQL thường được coi là cơ sở dữ liệu quan hệ.
Sẽ thực sự hữu ích hơn khi coi cơ sở dữ liệu NoSQL là cơ sở dữ liệu không quan hệ, vì vậy NoSQL thực sự có nghĩa là không quan hệ.
Có nhiều loại cơ sở dữ liệu NoSQL khác nhau bao gồm các kho lưu trữ giá trị quan trọng như:
- Lưu trữ bảng Azure
- Cửa hàng dựa trên cột, như Cassandra
- Cơ sở dữ liệu đồ thị, như NEO4
- Cơ sở dữ liệu tài liệu, như MongoDB và Azure DocumentDB
Tại sao cú pháp SQL?
Điều này thoạt nghe có vẻ lạ, nhưng trong DocumentDB là cơ sở dữ liệu NoSQL, chúng tôi truy vấn bằng SQL. Như đã đề cập ở trên, đây là một phiên bản SQL đặc biệt được bắt nguồn từ ngữ nghĩa JSON và JavaScript.
SQL chỉ là một ngôn ngữ, nhưng nó cũng là một ngôn ngữ rất phổ biến, giàu tính biểu cảm. Vì vậy, có vẻ như là một ý tưởng hay khi sử dụng một số phương ngữ của SQL hơn là nghĩ ra một cách hoàn toàn mới để diễn đạt các truy vấn mà chúng ta cần học nếu bạn muốn lấy tài liệu ra khỏi cơ sở dữ liệu của mình.
SQL được thiết kế cho cơ sở dữ liệu quan hệ và DocumentDB là cơ sở dữ liệu tài liệu không quan hệ. Nhóm DocumentDB đã thực sự điều chỉnh cú pháp SQL cho thế giới phi quan hệ của cơ sở dữ liệu tài liệu và đây là ý nghĩa của việc root SQL trong JSON và JavaScript.
Ngôn ngữ này vẫn đọc như SQL quen thuộc, nhưng ngữ nghĩa tất cả đều dựa trên các tài liệu JSON miễn phí của lược đồ chứ không phải các bảng quan hệ. Trong DocumentDB, chúng ta sẽ làm việc với các kiểu dữ liệu JavaScript hơn là các kiểu dữ liệu SQL. Chúng ta sẽ quen thuộc với SELECT, FROM, WHERE, v.v., nhưng với các kiểu JavaScript, bị giới hạn ở số và chuỗi, đối tượng, mảng, Boolean và null ít hơn nhiều so với phạm vi rộng của các kiểu dữ liệu SQL.
Tương tự, các biểu thức được đánh giá là biểu thức JavaScript chứ không phải là một số dạng T-SQL. Ví dụ: trong thế giới dữ liệu không chuẩn hóa, chúng tôi không xử lý các hàng và cột, mà là các tài liệu không có giản đồ với cấu trúc phân cấp chứa các mảng và đối tượng lồng nhau.
SQL hoạt động như thế nào?
Nhóm DocumentDB đã trả lời câu hỏi này theo một số cách sáng tạo. Một vài trong số chúng được liệt kê như sau:
Đầu tiên, giả sử bạn không thay đổi hành vi mặc định để tự động lập chỉ mục mọi thuộc tính trong tài liệu, bạn có thể sử dụng ký hiệu chấm trong các truy vấn của mình để điều hướng đường dẫn đến bất kỳ thuộc tính nào cho dù nó có được lồng sâu như thế nào trong tài liệu.
Bạn cũng có thể thực hiện phép nối nội bộ tài liệu trong đó các phần tử mảng lồng nhau được nối với phần tử mẹ của chúng trong tài liệu theo cách rất giống với cách phép nối được thực hiện giữa hai bảng trong thế giới quan hệ.
Các truy vấn của bạn có thể trả về tài liệu từ cơ sở dữ liệu như hiện tại hoặc bạn có thể chiếu bất kỳ hình dạng JSON tùy chỉnh nào mà bạn muốn dựa trên nhiều hay ít dữ liệu tài liệu mà bạn muốn.
SQL trong DocumentDB hỗ trợ nhiều toán tử phổ biến bao gồm:
Phép toán số học và bitwise
Logic VÀ và HOẶC
So sánh bình đẳng và phạm vi
Nối chuỗi
Ngôn ngữ truy vấn cũng hỗ trợ một loạt các chức năng tích hợp sẵn.
Cổng Azure có Trình khám phá truy vấn cho phép chúng tôi chạy bất kỳ truy vấn SQL nào dựa trên cơ sở dữ liệu DocumentDB của chúng tôi. Chúng tôi sẽ sử dụng Trình khám phá truy vấn để chứng minh nhiều khả năng và tính năng khác nhau của ngôn ngữ truy vấn bắt đầu với truy vấn đơn giản nhất có thể.
Step 1 - Mở Azure Portal, và trong phiến cơ sở dữ liệu, hãy nhấp vào phiến Query Explorer.
Hãy nhớ rằng các truy vấn chạy trong phạm vi của một bộ sưu tập và do đó, Trình khám phá truy vấn cho phép chúng tôi chọn bộ sưu tập trong menu thả xuống này. Chúng tôi sẽ đặt nó thành bộ sưu tập Gia đình chứa ba tài liệu. Hãy xem xét ba tài liệu trong ví dụ này.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Trình khám phá Truy vấn mở ra với truy vấn đơn giản SELECT * FROM c này, truy vấn này chỉ đơn giản là lấy tất cả các tài liệu từ bộ sưu tập. Mặc dù nó đơn giản, nó vẫn khá khác so với truy vấn tương đương trong cơ sở dữ liệu quan hệ.
Step 2- Trong cơ sở dữ liệu quan hệ, SELECT * có nghĩa là trả về tất cả các cột khi ở trong DocumentDB. Nó có nghĩa là bạn muốn mỗi tài liệu trong kết quả của bạn được trả về chính xác như được lưu trữ trong cơ sở dữ liệu.
Nhưng khi bạn chọn các thuộc tính và biểu thức cụ thể thay vì chỉ đưa ra một SELECT *, thì bạn đang chiếu một hình dạng mới mà bạn muốn cho mỗi tài liệu trong kết quả.
Step 3 - Nhấp vào 'Chạy' để thực hiện truy vấn và mở thanh Kết quả.
Như có thể thấy WakefieldFamily, SmithFamily và AndersonFamily được truy xuất.
Sau đây là ba tài liệu được truy xuất do kết quả của SELECT * FROM c truy vấn.
[
{
"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/"
}
]Tuy nhiên, những kết quả này cũng bao gồm các thuộc tính do hệ thống tạo ra, tất cả đều có tiền tố là ký tự gạch dưới.
Trong chương này, chúng ta sẽ đề cập đến mệnh đề FROM, mệnh đề này không hoạt động giống như mệnh đề FROM tiêu chuẩn trong SQL thông thường.
Các truy vấn luôn chạy trong ngữ cảnh của một tập hợp cụ thể và không thể kết hợp giữa các tài liệu trong tập hợp, điều này khiến chúng tôi tự hỏi tại sao chúng tôi cần mệnh đề FROM. Trên thực tế, chúng tôi không có, nhưng nếu chúng tôi không bao gồm nó, thì chúng tôi sẽ không truy vấn các tài liệu trong bộ sưu tập.
Mục đích của điều khoản này là chỉ định nguồn dữ liệu mà truy vấn phải hoạt động. Thông thường, toàn bộ tập hợp là nguồn, nhưng thay vào đó, người ta có thể chỉ định một tập hợp con của tập hợp. Mệnh đề FROM <from_specification> là tùy chọn trừ khi nguồn được lọc hoặc chiếu sau trong truy vấn.
Hãy xem lại cùng một ví dụ. Sau đây làAndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}
Trong truy vấn trên, “SELECT * FROM c”Chỉ ra rằng toàn bộ bộ sưu tập Gia đình là nguồn để liệt kê.
Tài liệu phụ
Nguồn cũng có thể được giảm xuống một tập hợp con nhỏ hơn. Khi chúng ta chỉ muốn truy xuất một cây con trong mỗi tài liệu, gốc con sau đó có thể trở thành nguồn, như được minh họa trong ví dụ sau.
Khi chúng tôi chạy truy vấn sau:
SELECT * FROM Families.parentsCác tài liệu phụ sau đây sẽ được lấy ra.
[
[
{
"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"
}
]
]Theo kết quả của truy vấn này, chúng tôi có thể thấy rằng chỉ các tài liệu con của cha mẹ được truy xuất.
Trong chương này, chúng ta sẽ đề cập đến mệnh đề WHERE, cũng là tùy chọn như mệnh đề FROM. Nó được sử dụng để chỉ định một điều kiện trong khi tìm nạp dữ liệu ở dạng tài liệu JSON do nguồn cung cấp. Bất kỳ tài liệu JSON nào cũng phải đánh giá các điều kiện được chỉ định là "đúng" để được xem xét cho kết quả. Nếu điều kiện đã cho được thỏa mãn, thì chỉ khi đó nó mới trả về dữ liệu cụ thể ở dạng (các) tài liệu JSON. Chúng ta có thể sử dụng mệnh đề WHERE để lọc các bản ghi và chỉ tìm nạp các bản ghi cần thiết.
Chúng ta sẽ xem xét ba tài liệu giống nhau trong ví dụ này. Sau đây làAndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ đơn giản trong đó mệnh đề WHERE được sử dụng.
Trong truy vấn này, trong mệnh đề WHERE, điều kiện (WHERE f.id = "WakefieldFamily") được chỉ định.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Khi truy vấn trên được thực thi, nó sẽ trả về tài liệu JSON hoàn chỉnh cho WakefieldFamily như được hiển thị trong kết quả sau.
[
{
"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/"
}
]Toán tử là một từ dành riêng hoặc một ký tự được sử dụng chủ yếu trong mệnh đề SQL WHERE để thực hiện (các) hoạt động, chẳng hạn như so sánh và các phép toán số học. DocumentDB SQL cũng hỗ trợ nhiều loại biểu thức vô hướng. Thường được sử dụng nhất làbinary and unary expressions.
Các toán tử SQL sau hiện được hỗ trợ và có thể được sử dụng trong các truy vấn.
Toán tử so sánh SQL
Sau đây là danh sách tất cả các toán tử so sánh có sẵn trong ngữ pháp SQL DocumentDB.
| Không. | Nhà khai thác & Mô tả |
|---|---|
| 1 | = Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không. Nếu có, thì điều kiện trở thành true. |
| 2 | != Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không. Nếu các giá trị không bằng nhau thì điều kiện trở thành true. |
| 3 | <> Kiểm tra xem giá trị của hai toán hạng có bằng nhau hay không. Nếu các giá trị không bằng nhau thì điều kiện trở thành true. |
| 4 | > Kiểm tra xem giá trị của toán hạng bên trái có lớn hơn giá trị của toán hạng bên phải hay không. Nếu có, thì điều kiện trở thành true. |
| 5 | < Kiểm tra xem giá trị của toán hạng bên trái có nhỏ hơn giá trị của toán hạng bên phải hay không. Nếu có, thì điều kiện trở thành true. |
| 6 | >= Kiểm tra xem giá trị của toán hạng bên trái có lớn hơn hoặc bằng giá trị của toán hạng bên phải hay không. Nếu có, thì điều kiện trở thành true. |
| 7 | <= Kiểm tra nếu giá trị của toán hạng bên trái nhỏ hơn hoặc bằng giá trị của toán hạng bên phải. Nếu có, thì điều kiện trở thành true. |
Toán tử logic SQL
Sau đây là danh sách tất cả các toán tử logic có sẵn trong ngữ pháp SQL DocumentDB.
| Không. | Nhà khai thác & Mô tả |
|---|---|
| 1 | AND Toán tử AND cho phép tồn tại nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQL. |
| 2 | BETWEEN Toán tử BETWEEN được sử dụng để tìm kiếm các giá trị nằm trong một bộ giá trị, cho giá trị nhỏ nhất và giá trị lớn nhất. |
| 3 | IN Toán tử IN được sử dụng để so sánh một giá trị với danh sách các giá trị theo nghĩa đen đã được chỉ định. |
| 4 | OR Toán tử OR được sử dụng để kết hợp nhiều điều kiện trong mệnh đề WHERE của câu lệnh SQL. |
| 5 | NOT Toán tử NOT đảo ngược ý nghĩa của toán tử logic mà nó được sử dụng. Ví dụ: KHÔNG TỒN TẠI, KHÔNG GIỮA, KHÔNG VÀO, v.v ... Đây là toán tử phủ định. |
Toán tử số học SQL
Sau đây là danh sách tất cả các toán tử số học có sẵn trong ngữ pháp SQL DocumentDB.
| Không. | Nhà khai thác & Mô tả |
|---|---|
| 1 | + Addition - Thêm giá trị vào hai bên của toán tử. |
| 2 | - Subtraction - Trừ toán hạng bên phải với toán hạng bên trái. |
| 3 | * Multiplication - Nhân các giá trị ở hai bên của toán tử. |
| 4 | / Division - Chia toán hạng bên trái cho toán hạng bên phải. |
| 5 | % Modulus - Chia toán hạng bên trái cho toán hạng bên phải và trả về phần dư. |
Chúng tôi cũng sẽ xem xét các tài liệu tương tự trong ví dụ này. Sau đây làAndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ đơn giản trong đó toán tử so sánh được sử dụng trong mệnh đề WHERE.
Trong truy vấn này, trong mệnh đề WHERE, điều kiện (WHERE f.id = "WakefieldFamily") được chỉ định và nó sẽ truy xuất tài liệu có id bằng WakefieldFamily.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Khi truy vấn trên được thực thi, nó sẽ trả về tài liệu JSON hoàn chỉnh cho WakefieldFamily như được hiển thị trong kết quả sau.
[
{
"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/"
}
]Hãy xem xét một ví dụ khác, trong đó truy vấn sẽ truy xuất dữ liệu trẻ em có điểm lớn hơn 5.
SELECT *
FROM Families.children[0] c
WHERE (c.grade > 5)Khi truy vấn trên được thực thi, nó sẽ truy xuất tài liệu con sau như được hiển thị trong đầu ra.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]Từ khóa BETWEEN được sử dụng để diễn đạt các truy vấn đối với các phạm vi giá trị như trong SQL. BETWEEN có thể được sử dụng đối với chuỗi hoặc số. Sự khác biệt chính giữa việc sử dụng BETWEEN trong DocumentDB và ANSI SQL là bạn có thể thể hiện các truy vấn phạm vi dựa trên các thuộc tính của các kiểu hỗn hợp.
Ví dụ: trong một số tài liệu, bạn có thể có "điểm" là một số và trong các tài liệu khác, nó có thể là chuỗi. Trong những trường hợp này, so sánh giữa hai loại kết quả khác nhau là "không xác định", và tài liệu sẽ bị bỏ qua.
Chúng ta hãy xem xét ba tài liệu từ ví dụ trước. Sau đây làAndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ, trong đó truy vấn trả về tất cả các tài liệu gia đình trong đó lớp của đứa trẻ đầu tiên nằm trong khoảng từ 1-5 (bao gồm cả hai).
Sau đây là truy vấn trong đó từ khóa BETWEEN được sử dụng và sau đó là toán tử logic AND.
SELECT *
FROM Families.children[0] c
WHERE c.grade BETWEEN 1 AND 5Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"givenName": "Michelle",
"gender": "female",
"grade": 1
},
{
"firstName": "Henriette Thaulow",
"gender": "female",
"grade": 5,
"pets": [
{
"givenName": "Fluffy",
"type": "Rabbit"
}
]
}
]Để hiển thị các điểm bên ngoài phạm vi của ví dụ trước, hãy sử dụng KHÔNG GIỮA như được hiển thị trong truy vấn sau.
SELECT *
FROM Families.children[0] c
WHERE c.grade NOT BETWEEN 1 AND 5Khi truy vấn này được thực thi. Nó tạo ra kết quả sau.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]Từ khóa IN có thể được sử dụng để kiểm tra xem một giá trị được chỉ định có khớp với bất kỳ giá trị nào trong danh sách hay không. Toán tử IN cho phép bạn chỉ định nhiều giá trị trong mệnh đề WHERE. IN tương đương với việc xâu chuỗi nhiều mệnh đề OR.
Ba tài liệu tương tự được coi là đã thực hiện trong các ví dụ trước đó. Sau đây làAndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ đơn giản.
Sau đây là truy vấn sẽ truy xuất dữ liệu có familyName là “Smith” hoặc Wakefield.
SELECT *
FROM Families.parents[0] f
WHERE f.familyName IN ('Smith', 'Wakefield')Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"familyName": "Wakefield",
"givenName": "Robin"
},
{
"familyName": "Smith",
"givenName": "James"
}
]Hãy xem xét một ví dụ đơn giản khác, trong đó tất cả các tài liệu gia đình sẽ được truy xuất trong đó id là một trong "SmithFamily" hoặc "AndersenFamily". Sau đây là truy vấn.
SELECT *
FROM Families
WHERE Families.id IN ('SmithFamily', 'AndersenFamily')Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"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/"
}
]Khi bạn biết mình chỉ trả về một giá trị duy nhất, thì từ khóa VALUE có thể giúp tạo ra tập hợp kết quả gọn gàng hơn bằng cách tránh chi phí tạo một đối tượng toàn diện. Từ khóa VALUE cung cấp một cách để trả về giá trị JSON.
Hãy xem một ví dụ đơn giản.
Sau đây là truy vấn với từ khóa VALUE.
SELECT VALUE "Hello World, this is DocumentDB SQL Tutorial"Khi truy vấn này được thực thi, nó trả về giá trị vô hướng "Xin chào Thế giới, đây là Hướng dẫn SQL DocumentDB".
[
"Hello World, this is DocumentDB SQL Tutorial"
]Trong một ví dụ khác, chúng ta hãy xem xét ba tài liệu từ các ví dụ trước.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Sau đây là truy vấn.
SELECT VALUE f.location
FROM Families fKhi truy vấn này được thực thi, nó trả về trả về địa chỉ mà không có nhãn vị trí.
[
{
"state": "NY",
"county": "Manhattan",
"city": "NY"
},
{
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
},
{
"state": "WA",
"county": "King",
"city": "Seattle"
}
]Nếu bây giờ chúng ta chỉ định cùng một truy vấn mà không có Từ khoá VALUE, thì nó sẽ trả về địa chỉ có nhãn vị trí. Sau đây là truy vấn.
SELECT f.location
FROM Families fKhi truy vấn này được thực thi, nó tạo ra kết quả sau.
[
{
"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 hỗ trợ truy vấn tài liệu bằng SQL trên tài liệu JSON. Bạn có thể sắp xếp tài liệu trong bộ sưu tập theo số và chuỗi bằng mệnh đề ORDER BY trong truy vấn của mình. Mệnh đề có thể bao gồm một đối số ASC / DESC tùy chọn để xác định thứ tự mà kết quả phải được truy xuất.
Chúng ta sẽ xem xét các tài liệu tương tự như trong các ví dụ trước.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ đơn giản.
Sau đây là truy vấn có chứa từ khóa ORDER BY.
SELECT f.id, f.children[0].givenName,f.children[0].grade
FROM Families f
ORDER BY f.children[0].gradeKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"id": "SmithFamily",
"givenName": "Michelle",
"grade": 1
},
{
"id": "AndersenFamily",
"grade": 5
},
{
"id": "WakefieldFamily",
"givenName": "Jesse",
"grade": 6
}
]Hãy xem xét một ví dụ đơn giản khác.
Sau đây là truy vấn chứa từ khóa ORDER BY và từ khóa tùy chọn DESC.
SELECT f.id, f.parents[0].familyName
FROM Families f
ORDER BY f.parents[0].familyName DESCKhi truy vấn trên được thực thi, nó sẽ tạo ra kết quả sau.
[
{
"id": "WakefieldFamily",
"familyName": "Wakefield"
},
{
"id": "SmithFamily",
"familyName": "Smith"
},
{
"id": "AndersenFamily"
}
]Trong DocumentDB SQL, Microsoft đã thêm một cấu trúc mới có thể được sử dụng với từ khóa IN để hỗ trợ việc lặp qua các mảng JSON. Hỗ trợ cho việc lặp lại được cung cấp trong mệnh đề FROM.
Chúng tôi sẽ xem xét ba tài liệu tương tự từ các ví dụ trước một lần nữa.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ đơn giản không có từ khóa IN trong mệnh đề FROM.
Sau đây là truy vấn sẽ trả về tất cả các phụ huynh từ bộ sưu tập Gia đình.
SELECT *
FROM Families.parentsKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
[
{
"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"
}
]
]Như có thể thấy trong đầu ra ở trên, cha mẹ của mỗi gia đình được hiển thị trong một mảng JSON riêng biệt.
Hãy xem cùng một ví dụ, tuy nhiên lần này chúng ta sẽ sử dụng từ khóa IN trong mệnh đề FROM.
Sau đây là truy vấn có chứa từ khóa IN.
SELECT *
FROM c IN Families.parentsKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"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
}
]Trong ví dụ trên, có thể thấy rằng với sự lặp lại, truy vấn thực hiện lặp lại trên cha mẹ trong tập hợp có mảng đầu ra khác nhau. Do đó, tất cả cha mẹ từ mỗi gia đình được thêm vào một mảng duy nhất.
Trong cơ sở dữ liệu quan hệ, mệnh đề Joins được sử dụng để kết hợp các bản ghi từ hai hoặc nhiều bảng trong cơ sở dữ liệu và nhu cầu kết hợp giữa các bảng là rất quan trọng trong khi thiết kế các lược đồ chuẩn hóa. Vì DocumentDB xử lý mô hình dữ liệu không chuẩn hóa của các tài liệu không có giản đồ, nên JOIN trong DocumentDB SQL tương đương lôgic của một "selfjoin".
Chúng ta hãy xem xét ba tài liệu như trong các ví dụ trước.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ để hiểu cách hoạt động của mệnh đề JOIN.
Sau đây là truy vấn sẽ nối tài liệu gốc với con.
SELECT f.id
FROM Families f
JOIN c IN f.childrenKhi truy vấn trên được thực thi, nó sẽ tạo ra kết quả sau.
[
{
"id": "WakefieldFamily"
},
{
"id": "WakefieldFamily"
},
{
"id": "SmithFamily"
},
{
"id": "SmithFamily"
},
{
"id": "AndersenFamily"
}
]Trong ví dụ trên, phép nối nằm giữa gốc tài liệu và gốc con con tạo nên sản phẩm chéo giữa hai đối tượng JSON. Sau đây là những điểm nhất định cần lưu ý:
Trong mệnh đề FROM, mệnh đề JOIN là một trình lặp.
Hai tài liệu đầu tiên WakefieldFamily và SmithFamily chứa hai phần tử con, do đó tập kết quả cũng chứa tích chéo tạo ra một đối tượng riêng biệt cho mỗi phần tử con.
Tài liệu thứ ba AndersenFamily chỉ chứa một phần tử con, do đó chỉ có một đối tượng duy nhất tương ứng với tài liệu này.
Hãy xem cùng một ví dụ, tuy nhiên lần này chúng ta truy xuất tên con cũng như để hiểu rõ hơn về mệnh đề JOIN.
Sau đây là truy vấn sẽ nối tài liệu gốc với con.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]Trong cơ sở dữ liệu quan hệ, bí danh SQL được sử dụng để tạm thời đổi tên bảng hoặc đầu đề cột. Tương tự, trong DocumentDB, bí danh được sử dụng để tạm thời đổi tên tài liệu JSON, tài liệu con, đối tượng hoặc bất kỳ trường nào.
Việc đổi tên là một thay đổi tạm thời và tài liệu thực tế không thay đổi. Về cơ bản, bí danh được tạo để làm cho tên trường / tài liệu dễ đọc hơn. Đối với bí danh, từ khóa AS được sử dụng là tùy chọn.
Hãy xem xét ba tài liệu tương tự từ những tài liệu được sử dụng trong các ví dụ trước.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ để thảo luận về các bí danh.
Sau đây là truy vấn sẽ nối tài liệu gốc với con. Chúng tôi có các bí danh như f.id AS familyName, c.givenName AS childGivenName và c.firstName AS childFirstName.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]Kết quả trên cho thấy rằng tên đã nộp được thay đổi, nhưng đó là thay đổi tạm thời và các tài liệu gốc không được sửa đổi.
Trong DocumentDB SQL, Microsoft đã thêm một tính năng chính với sự trợ giúp của chúng ta có thể dễ dàng tạo một mảng. Nó có nghĩa là khi chúng ta chạy một truy vấn, kết quả là nó sẽ tạo ra một mảng tập hợp tương tự như đối tượng JSON do kết quả của truy vấn.
Hãy xem xét các tài liệu tương tự như trong các ví dụ trước.
Sau đây là AndersenFamily tài liệu.
{
"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
}Sau đây là SmithFamily tài liệu.
{
"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
}Sau đây là WakefieldFamily tài liệu.
{
"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
}Hãy xem một ví dụ.
Sau đây là truy vấn sẽ trả về họ và địa chỉ của mỗi gia đình.
SELECT f.id AS FamilyName,
[f.location.city, f.location.county, f.location.state] AS Address
FROM Families fCó thể thấy các trường thành phố, quận và tiểu bang được đặt trong dấu ngoặc vuông, các trường này sẽ tạo ra một mảng và mảng này có tên là Địa chỉ. Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"FamilyName": "WakefieldFamily",
"Address": [
"NY",
"Manhattan",
"NY"
]
},
{
"FamilyName": "SmithFamily",
"Address": [
"Forest Hills",
"Queens",
"NY"
]
},
{
"FamilyName": "AndersenFamily",
"Address": [
"Seattle",
"King",
"WA"
]
}
]Thông tin thành phố, quận và tiểu bang được thêm vào mảng Địa chỉ ở đầu ra ở trên.
Trong DocumentDB SQL, mệnh đề SELECT cũng hỗ trợ các biểu thức vô hướng như hằng số, biểu thức số học, biểu thức logic, v.v. Thông thường, các truy vấn vô hướng hiếm khi được sử dụng, vì chúng không thực sự truy vấn các tài liệu trong bộ sưu tập, chúng chỉ đánh giá các biểu thức. Nhưng vẫn hữu ích khi sử dụng truy vấn biểu thức vô hướng để tìm hiểu những điều cơ bản, cách sử dụng biểu thức và định hình JSON trong một truy vấn và những khái niệm này áp dụng trực tiếp cho các truy vấn thực tế mà bạn sẽ chạy với các tài liệu trong một bộ sưu tập.
Hãy xem một ví dụ chứa nhiều truy vấn vô hướng.
Trong Trình khám phá truy vấn, chỉ chọn văn bản sẽ được thực thi và nhấp vào 'Chạy'. Hãy chạy cái đầu tiên này.
SELECT "Hello"Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"$1": "Hello"
}
]Đầu ra này có thể hơi khó hiểu, vì vậy hãy chia nhỏ nó.
Đầu tiên, như chúng ta đã thấy trong bản trình diễn trước, kết quả truy vấn luôn được chứa trong dấu ngoặc vuông vì chúng được trả về dưới dạng một mảng JSON, ngay cả kết quả từ các truy vấn biểu thức vô hướng như kết quả này chỉ trả về một tài liệu duy nhất.
Chúng ta có một mảng với một tài liệu trong đó và tài liệu đó có một thuộc tính duy nhất trong đó cho biểu thức đơn trong câu lệnh SELECT.
Câu lệnh SELECT không cung cấp tên cho thuộc tính này, do đó DocumentDB tự động tạo một thuộc tính bằng cách sử dụng $ 1.
Đây thường không phải là những gì chúng tôi muốn, đó là lý do tại sao chúng tôi có thể sử dụng AS để đặt bí danh cho biểu thức trong truy vấn, đặt tên thuộc tính trong tài liệu được tạo theo cách bạn muốn, từ, trong ví dụ này.
SELECT "Hello" AS wordKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"word": "Hello"
}
]Tương tự, sau đây là một truy vấn đơn giản khác.
SELECT ((2 + 11 % 7)-2)/3Truy vấn lấy kết quả sau.
[
{
"$1": 1.3333333333333333
}
]Hãy xem một ví dụ khác về định hình các mảng và đối tượng nhúng lồng nhau.
SELECT
{
"words1":
["Hello", "World"],
"words2":
["How", "Are", "You?"]
} AS allWordsKhi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"allWords": {
"words1": [
"Hello",
"World"
],
"words2": [
"How",
"Are",
"You?"
]
}
}
]Trong cơ sở dữ liệu quan hệ, truy vấn tham số hóa là truy vấn trong đó trình giữ chỗ được sử dụng cho các tham số và các giá trị tham số được cung cấp tại thời điểm thực thi. DocumentDB cũng hỗ trợ các truy vấn được tham số hóa và các tham số trong truy vấn được tham số hóa có thể được thể hiện bằng ký hiệu @ quen thuộc. Lý do quan trọng nhất để sử dụng các truy vấn được tham số hóa là để tránh các cuộc tấn công SQL injection. Nó cũng có thể cung cấp khả năng xử lý mạnh mẽ và thoát khỏi đầu vào của người dùng.
Hãy xem một ví dụ mà chúng ta sẽ sử dụng .Net SDK. Sau đây là mã sẽ xóa bộ sưu tập.
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);
}Việc xây dựng một truy vấn được tham số hóa như sau.
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection { new SqlParameter { Name =
"@id", Value = collectionId } }
};Chúng tôi không mã hóa cứng collectionId nên phương pháp này có thể được sử dụng để xóa bất kỳ bộ sưu tập nào. Chúng ta có thể sử dụng ký hiệu '@' để đặt tên tham số tiền tố, tương tự như SQL Server.
Trong ví dụ trên, chúng tôi đang truy vấn một tập hợp cụ thể theo Id trong đó tham số Id được xác định trong SqlParameterCollection này được gán cho thuộc tính của tham số của SqlQuerySpec này. Sau đó, SDK thực hiện công việc xây dựng chuỗi truy vấn cuối cùng cho DocumentDB với collectionId được nhúng bên trong nó. Chúng tôi chạy truy vấn và sau đó sử dụng SelfLink của nó để xóa bộ sưu tập.
Sau đây là triển khai tác vụ 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");
}
}Khi mã được thực thi, nó tạo ra kết quả sau.
**** Delete Collection MyCollection1 in mydb ****
Deleted collection MyCollection1 from database myfirstdb
**** Delete Collection MyCollection2 in mydb ****
Deleted collection MyCollection2 from database myfirstdbHãy xem một ví dụ khác. Chúng ta có thể viết một truy vấn lấy họ và trạng thái địa chỉ làm tham số, sau đó thực thi nó cho các giá trị khác nhau của họ và vị trí.state dựa trên đầu vào của người dùng.
SELECT *
FROM Families f
WHERE f.lastName = @lastName AND f.location.state = @addressStateYêu cầu này sau đó có thể được gửi đến DocumentDB dưới dạng truy vấn JSON được tham số hóa như được hiển thị trong đoạn mã sau.
{
"query": "SELECT * FROM Families f WHERE f.lastName = @lastName AND
f.location.state = @addressState",
"parameters": [
{"name": "@lastName", "value": "Wakefield"},
{"name": "@addressState", "value": "NY"},
]
}DocumentDB hỗ trợ một loạt các hàm tích hợp cho các hoạt động phổ biến có thể được sử dụng bên trong các truy vấn. Có một loạt các hàm để thực hiện các phép tính toán học và cũng có các hàm kiểm tra kiểu cực kỳ hữu ích khi làm việc với các lược đồ khác nhau. Các hàm này có thể kiểm tra xem một thuộc tính nhất định có tồn tại hay không và nếu nó tồn tại thì đó là số hay chuỗi, Boolean hay đối tượng.
Chúng tôi cũng nhận được các hàm tiện dụng này để phân tích cú pháp và thao tác chuỗi, cũng như một số hàm để làm việc với mảng cho phép bạn thực hiện những việc như nối các mảng và kiểm tra xem một mảng có chứa một phần tử cụ thể hay không.
Sau đây là các loại chức năng tích hợp khác nhau:
| Không. | Chức năng & Mô tả tích hợp |
|---|---|
| 1 | Các hàm toán học Các hàm toán học thực hiện một phép tính, thường dựa trên các giá trị đầu vào được cung cấp dưới dạng đối số và trả về một giá trị số. |
| 2 | Nhập chức năng kiểm tra Các hàm kiểm tra kiểu cho phép bạn kiểm tra kiểu của một biểu thức trong các truy vấn SQL. |
| 3 | Hàm chuỗi Các hàm chuỗi thực hiện thao tác trên giá trị đầu vào chuỗi và trả về giá trị chuỗi, số hoặc giá trị Boolean. |
| 4 | Hàm mảng Các hàm mảng thực hiện một thao tác trên giá trị đầu vào của mảng và trả về ở dạng giá trị số, Boolean hoặc mảng. |
| 5 | Chức năng không gian DocumentDB cũng hỗ trợ các chức năng tích hợp sẵn của Open Geospatial Consortium (OGC) để truy vấn không gian địa lý. |
Trong DocumentDB, chúng tôi thực sự sử dụng SQL để truy vấn tài liệu. Nếu chúng tôi đang phát triển .NET, thì cũng có một nhà cung cấp LINQ có thể được sử dụng và có thể tạo SQL thích hợp từ một truy vấn LINQ.
Các loại dữ liệu được hỗ trợ
Trong DocumentDB, tất cả các kiểu nguyên thủy JSON đều được hỗ trợ trong trình cung cấp LINQ đi kèm với DocumentDB .NET SDK như sau:
- Numeric
- Boolean
- String
- Null
Biểu thức được hỗ trợ
Các biểu thức vô hướng sau được hỗ trợ trong trình cung cấp LINQ đi kèm với DocumentDB .NET SDK.
Constant Values - Bao gồm các giá trị không đổi của các kiểu dữ liệu nguyên thủy.
Property/Array Index Expressions - Biểu thức chỉ thuộc tính của một đối tượng hoặc một phần tử mảng.
Arithmetic Expressions - Bao gồm các biểu thức số học thông thường về giá trị số và Boolean.
String Comparison Expression - Bao gồm so sánh một giá trị chuỗi với một số giá trị chuỗi không đổi.
Object/Array Creation Expression- Trả về một đối tượng có kiểu giá trị phức hợp hoặc kiểu ẩn danh hoặc một mảng các đối tượng đó. Các giá trị này có thể được lồng vào nhau.
Các nhà khai thác LINQ được hỗ trợ
Đây là danh sách các toán tử LINQ được hỗ trợ trong nhà cung cấp LINQ đi kèm với DocumentDB .NET SDK.
Select - Các phép chiếu dịch sang SQL SELECT bao gồm cả việc xây dựng đối tượng.
Where- Bộ lọc dịch sang SQL WHERE và hỗ trợ dịch giữa &&, || và! cho các toán tử SQL.
SelectMany- Cho phép rút các mảng vào mệnh đề SQL JOIN. Có thể được sử dụng để chuỗi / lồng biểu thức để lọc các phần tử mảng.
OrderBy and OrderByDescending - Dịch sang ORDER BY tăng dần / giảm dần.
CompareTo- Chuyển sang so sánh phạm vi. Thường được sử dụng cho các chuỗi vì chúng không thể so sánh được trong .NET.
Take - Dịch sang SQL TOP để giới hạn kết quả từ một truy vấn.
Math Functions - Hỗ trợ dịch từ Abs, Acos, Asin, Atan, Ceiling, Cos, Exp, Floor, Log, Log10, Pow, Round, Sign, Sin, Sqrt, Tan, Truncate của .NET sang các hàm tích hợp SQL tương đương.
String Functions - Hỗ trợ dịch từ .NET's Concat, Contains, EndsWith, IndexOf, Count, ToLower, TrimStart, Replace, Reverse, TrimEnd, StartsWith, SubString, ToUpper sang các hàm tích hợp SQL tương đương.
Array Functions - Hỗ trợ dịch từ Concat, Contains và Count của .NET sang các hàm tích hợp SQL tương đương.
Geospatial Extension Functions - Hỗ trợ dịch từ các phương thức sơ khai Khoảng cách, Trong vòng, IsValid và IsValidDetailed sang các hàm tích hợp sẵn trong SQL tương đương.
User-Defined Extension Function - Hỗ trợ dịch từ phương thức sơ khai UserDefinedFunctionProvider.Gọi đến chức năng do người dùng định nghĩa tương ứng.
Miscellaneous- Hỗ trợ dịch các toán tử liên kết và có điều kiện. Có thể dịch Chứa thành chuỗi CONTAINS, ARRAY_CONTAINS hoặc SQL IN tùy thuộc vào ngữ cảnh.
Hãy xem một ví dụ mà chúng ta sẽ sử dụng .Net SDK. Sau đây là ba tài liệu mà chúng tôi sẽ xem xét cho ví dụ này.
Khách hàng mới 1
{
"name": "New Customer 1",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}Khách hàng mới 2
{
"name": "New Customer 2",
"address": {
"addressType": "Main Office",
"addressLine1": "678 Main Street",
"location": {
"city": "London",
"stateProvinceName": " London "
},
"postalCode": "11229",
"countryRegionName": "United Kingdom"
},
}Khách hàng mới 3
{
"name": "New Customer 3",
"address": {
"addressType": "Main Office",
"addressLine1": "12 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}Sau đây là đoạn mã mà chúng tôi truy vấn bằng LINQ. Chúng tôi đã xác định một truy vấn LINQ trongq, nhưng nó sẽ không thực thi cho đến khi chúng ta chạy. Danh sách trên đó.
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 sẽ chuyển đổi truy vấn LINQ của chúng tôi thành cú pháp SQL cho DocumentDB, tạo mệnh đề SELECT và WHERE dựa trên cú pháp LINQ của chúng tôi.
Hãy gọi các truy vấn trên từ tác vụ 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);
}
}Khi đoạn mã trên được thực thi, nó sẽ tạo ra kết quả sau.
**** 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: BrooklynNgày nay, JavaScript có mặt ở khắp mọi nơi, không chỉ trong các trình duyệt. DocumentDB bao gồm JavaScript như một loại T-SQL hiện đại và hỗ trợ thực thi giao dịch của logic JavaScript nguyên bản, ngay bên trong công cụ cơ sở dữ liệu. DocumentDB cung cấp một mô hình lập trình để thực thi logic ứng dụng dựa trên JavaScript trực tiếp trên các bộ sưu tập về các thủ tục và trình kích hoạt được lưu trữ.
Hãy xem một ví dụ mà chúng ta tạo một thủ tục cửa hàng đơn giản. Sau đây là các bước -
Step 1 - Tạo một ứng dụng console mới.
Step 2- Thêm SDK .NET từ NuGet. Chúng tôi đang sử dụng .NET SDK ở đây, có nghĩa là chúng tôi sẽ viết một số mã C # để tạo, thực thi và sau đó xóa thủ tục đã lưu trữ của chúng tôi, nhưng bản thân thủ tục được lưu trữ được viết bằng JavaScript.
Step 3 - Nhấp chuột phải vào dự án trong Trình khám phá giải pháp.
Step 4 - Thêm tệp JavaScript mới cho quy trình được lưu trữ và gọi nó là HelloWorldStoreProce.js
Mọi thủ tục được lưu trữ chỉ là một hàm JavaScript vì vậy chúng tôi sẽ tạo một hàm mới và đương nhiên chúng tôi cũng sẽ đặt tên cho hàm này HelloWorldStoreProce. Không quan trọng nếu chúng ta đặt tên cho hàm. DocumentDB sẽ chỉ tham chiếu đến thủ tục được lưu trữ này bởi Id mà chúng tôi cung cấp khi chúng tôi tạo nó.
function HelloWorldStoreProce() {
var context = getContext();
var response = context.getResponse();
response.setBody('Hello, and welcome to DocumentDB!');
}Tất cả các thủ tục được lưu trữ là lấy đối tượng phản hồi từ ngữ cảnh và gọi setBodyđể trả về một chuỗi cho trình gọi. Trong mã C #, chúng tôi sẽ tạo thủ tục được lưu trữ, thực thi nó và sau đó xóa nó.
Các thủ tục đã lưu trữ được xác định phạm vi cho mỗi tập hợp, do đó chúng tôi sẽ cần Liên kết tự liên kết của tập hợp để tạo thủ tục được lưu trữ.
Step 5 - Truy vấn đầu tiên cho myfirstdb cơ sở dữ liệu và sau đó cho MyCollection bộ sưu tập.
Tạo một thủ tục được lưu trữ cũng giống như tạo bất kỳ tài nguyên nào khác trong 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 - Đầu tiên tạo một đối tượng định nghĩa với Id cho tài nguyên mới và sau đó gọi một trong các phương thức Tạo trên DocumentClientvật. Trong trường hợp thủ tục được lưu trữ, định nghĩa bao gồm Id và mã JavaScript thực mà bạn muốn chuyển đến máy chủ.
Step 7 - Gọi File.ReadAllText để giải nén mã thủ tục đã lưu trữ ra khỏi tệp JS.
Step 8 - Gán mã thủ tục đã lưu trữ cho thuộc tính body của đối tượng định nghĩa.
Theo như DocumentDB có liên quan, Id chúng tôi chỉ định ở đây, trong định nghĩa, là tên của thủ tục được lưu trữ, bất kể chúng tôi thực sự đặt tên cho hàm JavaScript là gì.
Tuy nhiên, khi tạo các thủ tục được lưu trữ và các đối tượng phía máy chủ khác, chúng tôi nên đặt tên cho các hàm JavaScript và các tên hàm đó khớp với Id mà chúng tôi đã đặt trong định nghĩa cho DocumentDB.
Step 9 - Gọi CreateStoredProcedureAsync, đi qua SelfLink cho MyCollectiontập hợp và định nghĩa thủ tục được lưu trữ. Điều này tạo ra thủ tục được lưu trữ vàResourceId DocumentDB được gán cho nó.
Step 10 - Gọi thủ tục đã lưu trữ. ExecuteStoredProcedureAsyncnhận một tham số kiểu mà bạn đặt thành kiểu dữ liệu mong đợi của giá trị được trả về bởi thủ tục được lưu trữ, mà bạn có thể chỉ định đơn giản là một đối tượng nếu bạn muốn trả về một đối tượng động. Đó là một đối tượng có thuộc tính sẽ bị ràng buộc tại thời điểm chạy.
Trong ví dụ này, chúng tôi biết rằng thủ tục được lưu trữ của chúng tôi chỉ trả về một chuỗi và vì vậy chúng tôi gọi ExecuteStoredProcedureAsync<string>.
Sau đây là quá trình triển khai hoàn chỉnh của tệp 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);
}
}
}
}Khi đoạn mã trên được thực thi, nó sẽ tạo ra kết quả sau.
Created stored procedure HelloWorldStoreProce (Ic8LAMEUVgACAAAAAAAAgA==)
Executed stored procedure; response = Hello, and welcome to DocumentDB!Như đã thấy trong đầu ra ở trên, thuộc tính phản hồi có "Xin chào và chào mừng bạn đến với DocumentDB!" trả lại bằng thủ tục lưu trữ của chúng tôi.
DocumentDB SQL cung cấp hỗ trợ cho các hàm do người dùng xác định (UDF). UDF chỉ là một loại hàm JavaScript khác mà bạn có thể viết và những hàm này hoạt động khá nhiều như bạn mong đợi. Bạn có thể tạo UDF để mở rộng ngôn ngữ truy vấn với logic nghiệp vụ tùy chỉnh mà bạn có thể tham chiếu trong các truy vấn của mình.
Cú pháp DocumentDB SQL được mở rộng để hỗ trợ logic ứng dụng tùy chỉnh bằng cách sử dụng các UDF này. UDF có thể được đăng ký với DocumentDB và sau đó được tham chiếu như một phần của truy vấn SQL.
Hãy xem xét ba tài liệu sau đây cho ví dụ này.
AndersenFamily tài liệu như sau.
{
"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 tài liệu như sau.
{
"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 tài liệu như sau.
{
"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
}Hãy xem một ví dụ mà chúng ta sẽ tạo một số UDF đơn giản.
Sau đây là việc thực hiện CreateUserDefinedFunctions.
private async static Task CreateUserDefinedFunctions(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create User Defined Functions ****");
Console.WriteLine();
await CreateUserDefinedFunction(client, "udfRegEx");
}Chúng tôi có một udfRegEx và trong CreateUserDefinedFunction, chúng tôi lấy mã JavaScript của nó từ tệp cục bộ của chúng tôi. Chúng tôi xây dựng đối tượng định nghĩa cho UDF mới và gọi CreateUserDefinedFunctionAsync với SelfLink của bộ sưu tập và đối tượng udfDefinition như được hiển thị trong đoạn mã sau.
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;
}Chúng tôi lấy lại UDF mới từ thuộc tính tài nguyên của kết quả và trả lại nó cho người gọi. Để hiển thị UDF hiện có, sau đây là cách triển khaiViewUserDefinedFunctions. Chúng tôi gọiCreateUserDefinedFunctionQuery và lặp lại chúng như bình thường.
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 không cung cấp các hàm tích hợp để tìm kiếm các chuỗi con hoặc các biểu thức chính quy, do đó, một dòng chữ nhỏ sau đây sẽ lấp đầy khoảng trống đó là một hàm JavaScript.
function udfRegEx(input, regex) {
return input.match(regex);
}Đưa ra chuỗi đầu vào trong tham số đầu tiên, hãy sử dụng hỗ trợ biểu thức chính quy được tích hợp sẵn của JavaScript để chuyển chuỗi khớp mẫu trong tham số thứ hai vào.match. Chúng tôi có thể chạy một truy vấn chuỗi con để tìm tất cả các cửa hàng có từ Andersen tronglastName bất động sản.
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);
}
}Lưu ý rằng chúng ta phải đủ điều kiện cho mọi tham chiếu UDF có tiền tố udf. Chúng tôi vừa chuyển SQL tớiCreateDocumentQuerygiống như bất kỳ truy vấn thông thường nào. Cuối cùng, hãy gọi các truy vấn trên từCreateDocumentClient bài tập
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);
}
}Khi đoạn mã trên được thực thi, nó sẽ tạo ra kết quả sau.
**** 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: AndersenComposite Querycho phép bạn kết hợp dữ liệu từ các truy vấn hiện có và sau đó áp dụng các bộ lọc, tổng hợp, v.v. trước khi trình bày kết quả báo cáo, hiển thị tập dữ liệu được kết hợp. Truy vấn tổng hợp truy xuất nhiều cấp độ thông tin liên quan trên các truy vấn hiện có và trình bày dữ liệu kết hợp dưới dạng một kết quả truy vấn đơn và phẳng.
Sử dụng Truy vấn tổng hợp, bạn cũng có tùy chọn để -
Chọn tùy chọn cắt bớt SQL để loại bỏ các bảng và trường không cần thiết dựa trên các lựa chọn thuộc tính của người dùng.
Đặt mệnh đề ORDER BY và GROUP BY.
Đặt mệnh đề WHERE làm bộ lọc trên tập kết quả của một truy vấn tổng hợp.
Các toán tử trên có thể được tạo thành các truy vấn mạnh mẽ hơn. Vì DocumentDB hỗ trợ các bộ sưu tập lồng nhau, thành phần có thể được nối hoặc lồng vào nhau.
Hãy xem xét các tài liệu sau đây cho ví dụ này.
AndersenFamily tài liệu như sau.
{
"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 tài liệu như sau.
{
"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 tài liệu như sau.
{
"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
}Hãy xem một ví dụ về truy vấn nối.
Sau đây là truy vấn sẽ truy xuất id và vị trí của gia đình nơi đứa con đầu tiên givenName là Michelle.
SELECT f.id,f.location
FROM Families f
WHERE f.children[0].givenName = "Michelle"Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"id": "SmithFamily",
"location": {
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
}
}
]Hãy xem xét một ví dụ khác về truy vấn nối.
Sau đây là truy vấn sẽ trả về tất cả các tài liệu có lớp con đầu tiên lớn hơn 3.
SELECT *
FROM Families f
WHERE ({grade: f.children[0].grade}.grade > 3)Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"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/"
}
]Chúng ta hãy nhìn vào một example trong số các truy vấn lồng nhau.
Sau đây là truy vấn sẽ lặp lại tất cả các trang gốc và sau đó trả về tài liệu ở đó familyName là Smith.
SELECT *
FROM p IN Families.parents
WHERE p.familyName = "Smith"Khi truy vấn trên được thực thi, nó tạo ra kết quả sau.
[
{
"familyName": "Smith",
"givenName": "James"
}
]Hãy xem xét another example của truy vấn lồng nhau.
Sau đây là truy vấn sẽ trả về tất cả familyName.
SELECT VALUE p.familyName
FROM Families f
JOIN p IN f.parentsKhi truy vấn trên được thực thi, nó tạo ra kết quả theo sau.
[
"Wakefield",
"Miller",
"Smith",
"Curtis"
]