DocumentDB SQL - Panduan Cepat
DocumentDB adalah platform database dokumen NoSQL terbaru dari Microsoft yang berjalan di Azure. Dalam tutorial ini, kita akan mempelajari semua tentang membuat kueri dokumen menggunakan versi khusus SQL yang didukung oleh DocumentDB.
Database Dokumen NoSQL
DocumentDB adalah database dokumen NoSQL terbaru dari Microsoft, namun, ketika kami mengatakan database dokumen NoSQL, apa tepatnya yang kami maksud dengan NoSQL, dan database dokumen?
SQL berarti Bahasa Kueri Terstruktur yang merupakan bahasa kueri tradisional dari database relasional. SQL sering disamakan dengan database relasional.
Ini benar-benar lebih membantu untuk memikirkan database NoSQL sebagai database non-relasional, jadi NoSQL benar-benar berarti non-relasional.
Ada berbagai jenis database NoSQL yang mencakup penyimpanan nilai kunci seperti -
- Penyimpanan Meja Azure
- Toko berbasis kolom, seperti Cassandra
- Database grafik, seperti NEO4
- Database dokumen, seperti MongoDB dan Azure DocumentDB
Mengapa Sintaks SQL?
Ini mungkin terdengar aneh pada awalnya, tetapi di DocumentDB yang merupakan database NoSQL, kami melakukan kueri menggunakan SQL. Seperti disebutkan di atas, ini adalah versi khusus dari SQL yang di-rooting di semantik JSON dan JavaScript.
SQL hanyalah sebuah bahasa, tetapi juga merupakan bahasa yang sangat populer yang kaya dan ekspresif. Jadi, sepertinya ide yang bagus untuk menggunakan beberapa dialek SQL daripada menemukan cara baru untuk mengekspresikan kueri yang perlu kita pelajari jika Anda ingin mengeluarkan dokumen dari database Anda.
SQL dirancang untuk database relasional, dan DocumentDB adalah database dokumen non-relasional. Tim DocumentDB sebenarnya telah mengadaptasi sintaks SQL untuk dunia database dokumen non-relasional, dan inilah yang dimaksud dengan rooting SQL di JSON dan JavaScript.
Bahasanya masih terbaca sebagai SQL yang sudah dikenal, tetapi semantik semuanya didasarkan pada dokumen JSON schemafree daripada tabel relasional. Di DocumentDB, kami akan bekerja dengan tipe data JavaScript daripada tipe data SQL. Kita akan terbiasa dengan SELECT, FROM, WHERE, dan seterusnya, tetapi dengan tipe JavaScript, yang dibatasi pada angka dan string, objek, array, Boolean, dan null jauh lebih sedikit daripada berbagai tipe data SQL.
Demikian pula, ekspresi dievaluasi sebagai ekspresi JavaScript daripada beberapa bentuk T-SQL. Misalnya, dalam dunia data yang dinormalisasi, kita tidak berurusan dengan baris dan kolom, tetapi dokumen bebas skema dengan struktur hierarki yang berisi larik dan objek bertingkat.
Bagaimana cara kerja SQL?
Tim DocumentDB telah menjawab pertanyaan ini dengan beberapa cara inovatif. Beberapa dari mereka terdaftar sebagai berikut -
Pertama, dengan asumsi Anda tidak mengubah perilaku default untuk mengindeks setiap properti secara otomatis dalam dokumen, Anda dapat menggunakan notasi titik-titik dalam kueri Anda untuk menavigasi jalur ke properti apa pun tidak peduli seberapa dalam bersarangnya properti itu di dalam dokumen.
Anda juga dapat melakukan gabungan intra-dokumen di mana elemen array bersarang digabungkan dengan elemen induknya dalam dokumen dengan cara yang sangat mirip dengan cara penggabungan dilakukan antara dua tabel di dunia relasional.
Kueri Anda bisa mengembalikan dokumen dari database apa adanya, atau Anda bisa memproyeksikan bentuk JSON kustom apa pun yang Anda inginkan berdasarkan sebanyak atau sesedikit mungkin data dokumen yang Anda inginkan.
SQL di DocumentDB mendukung banyak operator umum termasuk -
Operasi aritmatika dan bitwise
DAN dan ATAU logika
Perbandingan kesetaraan dan jangkauan
Rangkaian string
Bahasa kueri juga mendukung sejumlah fungsi bawaan.
Portal Azure memiliki Penjelajah Kueri yang memungkinkan kami menjalankan kueri SQL apa pun terhadap database DocumentDB kami. Kami akan menggunakan Penjelajah Kueri untuk mendemonstrasikan berbagai kemampuan dan fitur bahasa kueri yang dimulai dengan kueri sesederhana mungkin.
Step 1 - Buka Azure Portal, dan di bilah database, klik bilah Penjelajah Kueri.
Ingatlah bahwa kueri dijalankan dalam lingkup koleksi, sehingga Penjelajah Kueri memungkinkan kita memilih koleksi di tarik-turun ini. Kami akan membiarkannya disetel ke koleksi Keluarga kami yang berisi tiga dokumen. Mari pertimbangkan ketiga dokumen ini dalam contoh ini.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Query Explorer terbuka dengan query sederhana ini SELECT * FROM c, yang hanya mengambil semua dokumen dari koleksi. Meskipun sederhana, ini masih sangat berbeda dari kueri yang setara dalam database relasional.
Step 2- Dalam database relasional, SELECT * berarti mengembalikan semua kolom saat berada di DocumentDB. Ini berarti Anda ingin setiap dokumen dalam hasil Anda dikembalikan persis seperti yang disimpan dalam database.
Tetapi ketika Anda memilih properti dan ekspresi tertentu daripada hanya mengeluarkan SELECT *, maka Anda memproyeksikan bentuk baru yang Anda inginkan untuk setiap dokumen dalam hasil.
Step 3 - Klik 'Jalankan' untuk menjalankan kueri dan membuka bilah Hasil.
Seperti yang dapat dilihat, WakefieldFamily, SmithFamily, dan AndersonFamily diambil.
Berikut adalah tiga dokumen yang diperoleh sebagai hasil dari SELECT * FROM c pertanyaan.
[
{
"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/"
}
]Namun, hasil ini juga menyertakan properti yang dihasilkan sistem yang semuanya diawali dengan karakter garis bawah.
Dalam bab ini, kita akan membahas klausa FROM, yang tidak berfungsi seperti klausa FROM standar dalam SQL biasa.
Kueri selalu berjalan dalam konteks koleksi tertentu dan tidak dapat digabungkan di seluruh dokumen dalam koleksi, yang membuat kami bertanya-tanya mengapa kami membutuhkan klausa FROM. Faktanya, kami tidak melakukannya, tetapi jika kami tidak memasukkannya, maka kami tidak akan meminta dokumen dalam koleksi.
Tujuan dari klausul ini adalah untuk menentukan sumber data yang harus dioperasikan kueri. Biasanya seluruh koleksi adalah sumbernya, tetapi sebagai gantinya kita dapat menentukan subset dari koleksi. Klausa FROM <from_specification> bersifat opsional kecuali jika sumber difilter atau diproyeksikan nanti dalam kueri.
Mari kita lihat contoh yang sama lagi. Berikut ini adalahAndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}
Dalam kueri di atas, "SELECT * FROM c”Menunjukkan bahwa seluruh koleksi Keluarga adalah sumber yang akan dicacah.
Sub-dokumen
Sumber juga dapat dikurangi menjadi subset yang lebih kecil. Saat kami ingin mengambil hanya subpohon di setiap dokumen, sub-root dapat menjadi sumber, seperti yang ditunjukkan pada contoh berikut.
Saat kami menjalankan kueri berikut -
SELECT * FROM Families.parentsSub-dokumen berikut akan diambil.
[
[
{
"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"
}
]
]Sebagai hasil dari query ini, kita dapat melihat bahwa hanya sub-dokumen orang tua yang diambil.
Dalam bab ini, kita akan membahas klausa WHERE, yang juga opsional seperti klausa FROM. Ini digunakan untuk menentukan kondisi saat mengambil data dalam bentuk dokumen JSON yang disediakan oleh sumber. Setiap dokumen JSON harus mengevaluasi kondisi yang ditentukan menjadi "benar" agar dipertimbangkan untuk hasil. Jika kondisi yang diberikan terpenuhi, baru kemudian mengembalikan data tertentu dalam bentuk dokumen JSON. Kita dapat menggunakan klausa WHERE untuk memfilter catatan dan hanya mengambil catatan yang diperlukan.
Kami akan mempertimbangkan tiga dokumen yang sama dalam contoh ini. Berikut ini adalahAndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh sederhana di mana klausa WHERE digunakan.
Dalam kueri ini, di klausa WHERE, kondisi (WHERE f.id = "WakefieldFamily") ditentukan.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Ketika kueri di atas dijalankan, itu akan mengembalikan dokumen JSON lengkap untuk WakefieldFamily seperti yang ditunjukkan pada output berikut.
[
{
"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/"
}
]Operator adalah kata atau karakter khusus yang digunakan terutama dalam klausa SQL WHERE untuk melakukan operasi, seperti perbandingan dan operasi aritmatika. DocumentDB SQL juga mendukung berbagai ekspresi skalar. Yang paling umum digunakan adalahbinary and unary expressions.
Operator SQL berikut saat ini didukung dan dapat digunakan dalam kueri.
Operator Perbandingan SQL
Berikut ini adalah daftar semua operator perbandingan yang tersedia dalam tata bahasa SQL DocumentDB.
| S.No. | Operator & Deskripsi |
|---|---|
| 1 | = Memeriksa apakah nilai dari dua operan sama atau tidak. Jika ya, maka kondisinya menjadi benar. |
| 2 | != Memeriksa apakah nilai dari dua operan sama atau tidak. Jika nilai tidak sama maka kondisi menjadi benar. |
| 3 | <> Memeriksa apakah nilai dari dua operan sama atau tidak. Jika nilai tidak sama maka kondisi menjadi benar. |
| 4 | > Memeriksa apakah nilai operan kiri lebih besar dari nilai operan kanan. Jika ya, maka kondisinya menjadi benar. |
| 5 | < Memeriksa apakah nilai operan kiri kurang dari nilai operan kanan. Jika ya, maka kondisinya menjadi benar. |
| 6 | >= Memeriksa apakah nilai operan kiri lebih besar dari atau sama dengan nilai operan kanan. Jika ya, maka kondisinya menjadi benar. |
| 7 | <= Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanan. Jika ya, maka kondisinya menjadi benar. |
Operator Logika SQL
Berikut adalah daftar semua operator logika yang tersedia dalam tata bahasa SQL DocumentDB.
| S.No. | Operator & Deskripsi |
|---|---|
| 1 | AND Operator AND memungkinkan adanya beberapa kondisi dalam klausa WHERE pernyataan SQL. |
| 2 | BETWEEN Operator BETWEEN digunakan untuk mencari nilai yang ada di dalam satu set nilai, dengan mempertimbangkan nilai minimum dan nilai maksimum. |
| 3 | IN Operator IN digunakan untuk membandingkan nilai dengan daftar nilai literal yang telah ditentukan. |
| 4 | OR Operator OR digunakan untuk menggabungkan beberapa kondisi dalam klausa WHERE pernyataan SQL. |
| 5 | NOT Operator NOT membalikkan arti dari operator logika yang digunakannya. Misalnya TIDAK ADA, TIDAK ANTARA, TIDAK DI, dll. Ini adalah operator negate. |
Operator Aritmatika SQL
Berikut ini adalah daftar semua operator aritmatika yang tersedia dalam tata bahasa SQL DocumentDB.
| S.No. | Operator & Deskripsi |
|---|---|
| 1 | + Addition - Menambahkan nilai di kedua sisi operator. |
| 2 | - Subtraction - Mengurangi operan tangan kanan dari operan tangan kiri. |
| 3 | * Multiplication - Mengalikan nilai di kedua sisi operator. |
| 4 | / Division - Membagi operan tangan kiri dengan operan tangan kanan. |
| 5 | % Modulus - Membagi operan tangan kiri dengan operan tangan kanan dan mengembalikan sisanya. |
Kami akan mempertimbangkan dokumen yang sama dalam contoh ini juga. Berikut ini adalahAndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh sederhana di mana operator perbandingan digunakan dalam klausa WHERE.
Dalam kueri ini, di klausa WHERE, kondisi (WHERE f.id = "WakefieldFamily") ditentukan, dan ini akan mengambil dokumen yang idnya sama dengan WakefieldFamily.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Ketika kueri di atas dijalankan, itu akan mengembalikan dokumen JSON lengkap untuk WakefieldFamily seperti yang ditunjukkan pada output berikut.
[
{
"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/"
}
]Mari kita lihat contoh lain di mana kueri akan mengambil data anak yang nilainya lebih dari 5.
SELECT *
FROM Families.children[0] c
WHERE (c.grade > 5)Ketika query di atas dijalankan, sub dokumen berikut akan diambil seperti yang ditunjukkan pada output.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]Kata kunci BETWEEN digunakan untuk mengekspresikan kueri terhadap rentang nilai seperti di SQL. BETWEEN dapat digunakan melawan string atau angka. Perbedaan utama antara menggunakan BETWEEN di DocumentDB dan ANSI SQL adalah Anda dapat mengekspresikan kueri rentang terhadap properti tipe campuran.
Misalnya, di beberapa dokumen ada kemungkinan Anda memiliki "nilai" sebagai angka dan di dokumen lain mungkin berupa string. Dalam kasus ini, perbandingan antara dua jenis hasil "tidak ditentukan", dan dokumen akan dilewati.
Mari kita perhatikan tiga dokumen dari contoh sebelumnya. Berikut ini adalahAndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh, di mana kueri mengembalikan semua dokumen keluarga yang nilai anak pertamanya antara 1-5 (keduanya inklusif).
Berikut ini adalah query di mana kata kunci ANTARA digunakan dan kemudian operator logika AND.
SELECT *
FROM Families.children[0] c
WHERE c.grade BETWEEN 1 AND 5Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"givenName": "Michelle",
"gender": "female",
"grade": 1
},
{
"firstName": "Henriette Thaulow",
"gender": "female",
"grade": 5,
"pets": [
{
"givenName": "Fluffy",
"type": "Rabbit"
}
]
}
]Untuk menampilkan nilai di luar rentang contoh sebelumnya, gunakan TIDAK ANTARA seperti yang ditunjukkan dalam kueri berikut.
SELECT *
FROM Families.children[0] c
WHERE c.grade NOT BETWEEN 1 AND 5Saat kueri ini dijalankan. Ini menghasilkan keluaran sebagai berikut.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]Kata kunci IN dapat digunakan untuk memeriksa apakah nilai yang ditentukan cocok dengan nilai apa pun dalam daftar. Operator IN memungkinkan Anda untuk menentukan beberapa nilai dalam klausa WHERE. IN setara dengan merangkai beberapa klausa ATAU.
Ketiga dokumen serupa dianggap seperti yang dilakukan pada contoh sebelumnya. Berikut ini adalahAndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh sederhana.
Berikut adalah kueri yang akan mengambil data yang familyName-nya adalah "Smith" atau Wakefield.
SELECT *
FROM Families.parents[0] f
WHERE f.familyName IN ('Smith', 'Wakefield')Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"familyName": "Wakefield",
"givenName": "Robin"
},
{
"familyName": "Smith",
"givenName": "James"
}
]Mari pertimbangkan contoh sederhana lainnya di mana semua dokumen keluarga akan diambil dengan salah satu id dari "SmithFamily" atau "AndersenFamily". Berikut adalah pertanyaannya.
SELECT *
FROM Families
WHERE Families.id IN ('SmithFamily', 'AndersenFamily')Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"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/"
}
]Bila Anda tahu Anda hanya mengembalikan satu nilai, maka kata kunci VALUE dapat membantu menghasilkan rangkaian hasil yang lebih ramping dengan menghindari overhead pembuatan objek yang lengkap. Kata kunci VALUE memberikan cara untuk mengembalikan nilai JSON.
Mari kita lihat contoh sederhana.
Berikut adalah kueri dengan VALUE kata kunci.
SELECT VALUE "Hello World, this is DocumentDB SQL Tutorial"Ketika kueri ini dijalankan, ia mengembalikan skalar "Halo Dunia, ini adalah Tutorial SQL DocumentDB".
[
"Hello World, this is DocumentDB SQL Tutorial"
]Dalam contoh lain, mari pertimbangkan tiga dokumen dari contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Berikut adalah pertanyaannya.
SELECT VALUE f.location
FROM Families fKetika kueri ini dijalankan, itu mengembalikan alamat tanpa label lokasi.
[
{
"state": "NY",
"county": "Manhattan",
"city": "NY"
},
{
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
},
{
"state": "WA",
"county": "King",
"city": "Seattle"
}
]Jika sekarang kita menentukan kueri yang sama tanpa VALUE Kata Kunci, maka itu akan mengembalikan alamat dengan label lokasi. Berikut adalah pertanyaannya.
SELECT f.location
FROM Families fKetika kueri ini dijalankan, itu menghasilkan keluaran berikut.
[
{
"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 mendukung dokumen kueri menggunakan SQL melalui dokumen JSON. Anda dapat mengurutkan dokumen dalam koleksi pada angka dan string menggunakan klausa ORDER BY dalam kueri Anda. Klausa dapat menyertakan argumen ASC / DESC opsional untuk menentukan urutan pengambilan hasil.
Kami akan mempertimbangkan dokumen yang sama seperti pada contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh sederhana.
Berikut adalah query yang berisi kata kunci ORDER BY.
SELECT f.id, f.children[0].givenName,f.children[0].grade
FROM Families f
ORDER BY f.children[0].gradeKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"id": "SmithFamily",
"givenName": "Michelle",
"grade": 1
},
{
"id": "AndersenFamily",
"grade": 5
},
{
"id": "WakefieldFamily",
"givenName": "Jesse",
"grade": 6
}
]Mari pertimbangkan contoh sederhana lainnya.
Berikut adalah kueri yang berisi kata kunci ORDER BY dan kata kunci opsional DESC.
SELECT f.id, f.parents[0].familyName
FROM Families f
ORDER BY f.parents[0].familyName DESCKetika query di atas dijalankan, maka akan menghasilkan keluaran sebagai berikut.
[
{
"id": "WakefieldFamily",
"familyName": "Wakefield"
},
{
"id": "SmithFamily",
"familyName": "Smith"
},
{
"id": "AndersenFamily"
}
]Di DocumentDB SQL, Microsoft telah menambahkan konstruksi baru yang dapat digunakan dengan kata kunci IN untuk memberikan dukungan untuk iterasi melalui array JSON. Dukungan untuk iterasi disediakan di klausa FROM.
Kami akan mempertimbangkan lagi tiga dokumen serupa dari contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh sederhana tanpa kata kunci IN di klausa FROM.
Berikut adalah kueri yang akan mengembalikan semua orang tua dari koleksi Keluarga.
SELECT *
FROM Families.parentsKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
[
{
"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"
}
]
]Seperti yang dapat dilihat pada keluaran di atas, orang tua dari setiap keluarga ditampilkan dalam larik JSON terpisah.
Mari kita lihat contoh yang sama, namun kali ini kita akan menggunakan kata kunci IN di klausa FROM.
Berikut adalah query yang berisi kata kunci IN.
SELECT *
FROM c IN Families.parentsKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"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
}
]Pada contoh di atas, terlihat bahwa dengan iterasi, query yang melakukan iterasi terhadap parent dalam collection memiliki larik keluaran yang berbeda. Karenanya, semua orang tua dari setiap keluarga ditambahkan ke dalam satu larik.
Dalam database relasional, klausa Gabungan digunakan untuk menggabungkan rekaman dari dua atau lebih tabel dalam database, dan kebutuhan untuk menggabungkan seluruh tabel sangat penting saat mendesain skema yang dinormalisasi. Karena DocumentDB berurusan dengan model data dokumen bebas skema yang dinormalisasi, GABUNG di DocumentDB SQL adalah padanan logis dari "selfjoin".
Mari pertimbangkan ketiga dokumen seperti pada contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh untuk memahami cara kerja klausa JOIN.
Berikut adalah query yang akan menggabungkan sub dokumen root to children.
SELECT f.id
FROM Families f
JOIN c IN f.childrenKetika query di atas dijalankan, maka akan menghasilkan keluaran sebagai berikut.
[
{
"id": "WakefieldFamily"
},
{
"id": "WakefieldFamily"
},
{
"id": "SmithFamily"
},
{
"id": "SmithFamily"
},
{
"id": "AndersenFamily"
}
]Dalam contoh di atas, gabungannya adalah antara root dokumen dan sub-root turunan yang membuat produk silang antara dua objek JSON. Berikut adalah beberapa hal yang perlu diperhatikan -
Di klausa FROM, klausa JOIN adalah iterator.
Dua dokumen pertama WakefieldFamily dan SmithFamily berisi dua anak, sehingga kumpulan hasil juga berisi produk silang yang menghasilkan objek terpisah untuk setiap anak.
Dokumen ketiga AndersenFamily hanya berisi satu anak, oleh karena itu hanya ada satu objek yang sesuai dengan dokumen ini.
Mari kita lihat contoh yang sama, namun kali ini kita mengambil nama anak juga untuk pemahaman yang lebih baik tentang klausa JOIN.
Berikut adalah query yang akan menggabungkan sub dokumen root to children.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]Dalam database relasional, alias SQL digunakan untuk sementara mengganti nama tabel atau judul kolom. Demikian pula, di DocumentDB, alias digunakan untuk mengganti nama sementara dokumen JSON, sub-dokumen, objek, atau bidang apa pun.
Penggantian nama adalah perubahan sementara dan dokumen sebenarnya tidak berubah. Pada dasarnya, alias dibuat agar nama bidang / dokumen lebih mudah dibaca. Untuk aliasing, digunakan kata kunci AS yang bersifat opsional.
Mari pertimbangkan tiga dokumen serupa dari yang digunakan dalam contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contoh untuk membahas alias.
Berikut adalah query yang akan menggabungkan sub dokumen root to children. Kami memiliki alias seperti f.id AS familyName, c.givenName AS childGivenName, dan c.firstName AS childFirstName.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]Keluaran di atas menunjukkan bahwa nama-nama yang diajukan berubah, tetapi ini adalah perubahan sementara dan dokumen asli tidak diubah.
Di DocumentDB SQL, Microsoft telah menambahkan fitur kunci dengan bantuan yang kita dapat dengan mudah membuat array. Artinya ketika kita menjalankan query, maka sebagai hasilnya akan dibuat sebuah array dari koleksi yang mirip dengan objek JSON hasil query.
Mari pertimbangkan dokumen yang sama seperti pada contoh sebelumnya.
Berikut ini adalah AndersenFamily dokumen.
{
"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
}Berikut ini adalah SmithFamily dokumen.
{
"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
}Berikut ini adalah WakefieldFamily dokumen.
{
"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
}Mari kita lihat contohnya.
Berikut ini adalah pertanyaan yang akan mengembalikan nama keluarga dan alamat masing-masing keluarga.
SELECT f.id AS FamilyName,
[f.location.city, f.location.county, f.location.state] AS Address
FROM Families fSeperti yang dapat dilihat, bidang kota, kabupaten dan negara bagian diapit dalam tanda kurung siku, yang akan membuat larik dan larik ini diberi nama Alamat. Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"FamilyName": "WakefieldFamily",
"Address": [
"NY",
"Manhattan",
"NY"
]
},
{
"FamilyName": "SmithFamily",
"Address": [
"Forest Hills",
"Queens",
"NY"
]
},
{
"FamilyName": "AndersenFamily",
"Address": [
"Seattle",
"King",
"WA"
]
}
]Informasi kota, kabupaten, dan negara bagian ditambahkan dalam larik Alamat pada keluaran di atas.
Dalam DocumentDB SQL, klausa SELECT juga mendukung ekspresi skalar seperti konstanta, ekspresi aritmatika, ekspresi logika, dll. Biasanya, kueri skalar jarang digunakan, karena mereka sebenarnya tidak meminta dokumen dalam koleksi, mereka hanya mengevaluasi ekspresi. Tapi masih berguna untuk menggunakan kueri ekspresi skalar untuk mempelajari dasar-dasarnya, cara menggunakan ekspresi dan bentuk JSON dalam kueri, dan konsep ini berlaku langsung ke kueri sebenarnya yang akan Anda jalankan terhadap dokumen dalam koleksi.
Mari kita lihat contoh yang berisi beberapa kueri skalar.
Di Penjelajah Kueri, pilih hanya teks yang akan dieksekusi dan klik 'Jalankan'. Mari kita jalankan yang pertama ini.
SELECT "Hello"Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"$1": "Hello"
}
]Output ini mungkin terlihat agak membingungkan, jadi mari kita hancurkan.
Pertama, seperti yang kita lihat di demo terakhir, hasil kueri selalu dimuat dalam tanda kurung siku karena dikembalikan sebagai larik JSON, bahkan hasil dari kueri ekspresi skalar seperti ini yang hanya mengembalikan satu dokumen.
Kami memiliki array dengan satu dokumen di dalamnya, dan dokumen itu memiliki satu properti di dalamnya untuk ekspresi tunggal dalam pernyataan SELECT.
Pernyataan SELECT tidak memberikan nama untuk properti ini, oleh karena itu DocumentDB otomatis membuatnya menggunakan $ 1.
Ini biasanya bukan yang kita inginkan, itulah sebabnya kita bisa menggunakan AS untuk membuat alias ekspresi dalam kueri, yang menyetel nama properti dalam dokumen yang dihasilkan seperti yang Anda inginkan, kata, dalam contoh ini.
SELECT "Hello" AS wordKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"word": "Hello"
}
]Demikian pula, berikut ini adalah kueri sederhana lainnya.
SELECT ((2 + 11 % 7)-2)/3Kueri mengambil keluaran berikut.
[
{
"$1": 1.3333333333333333
}
]Mari kita lihat contoh lain dalam membentuk array bersarang dan objek yang disematkan.
SELECT
{
"words1":
["Hello", "World"],
"words2":
["How", "Are", "You?"]
} AS allWordsKetika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"allWords": {
"words1": [
"Hello",
"World"
],
"words2": [
"How",
"Are",
"You?"
]
}
}
]Dalam database relasional, kueri berparameter adalah kueri tempat placeholder digunakan untuk parameter dan nilai parameter diberikan pada waktu eksekusi. DocumentDB juga mendukung kueri berparameter, dan parameter dalam kueri berparameter dapat diekspresikan dengan notasi @ yang sudah dikenal. Alasan terpenting untuk menggunakan kueri berparameter adalah untuk menghindari serangan injeksi SQL. Ini juga dapat memberikan penanganan yang kuat dan melarikan diri dari input pengguna.
Mari kita lihat contoh di mana kita akan menggunakan .Net SDK. Berikut adalah kode yang akan menghapus koleksi tersebut.
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);
}Konstruksi kueri berparameter adalah sebagai berikut.
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection { new SqlParameter { Name =
"@id", Value = collectionId } }
};Kami tidak melakukan hardcode collectionId sehingga metode ini dapat digunakan untuk menghapus koleksi apa pun. Kita dapat menggunakan simbol '@' untuk mengawali nama parameter, mirip dengan SQL Server.
Dalam contoh di atas, kami meminta koleksi tertentu berdasarkan Id di mana parameter Id didefinisikan dalam SqlParameterCollection ini yang ditetapkan ke properti parameter SqlQuerySpec ini. SDK kemudian melakukan pekerjaan membangun string kueri akhir untuk DocumentDB dengan collectionId yang disematkan di dalamnya. Kami menjalankan kueri dan kemudian menggunakan SelfLink untuk menghapus koleksi.
Berikut ini adalah implementasi tugas 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");
}
}Ketika kode dijalankan, itu menghasilkan keluaran sebagai berikut.
**** Delete Collection MyCollection1 in mydb ****
Deleted collection MyCollection1 from database myfirstdb
**** Delete Collection MyCollection2 in mydb ****
Deleted collection MyCollection2 from database myfirstdbMari kita lihat contoh lainnya. Kita dapat menulis kueri yang mengambil nama belakang dan status alamat sebagai parameter, dan kemudian mengeksekusinya untuk berbagai nilai nama belakang dan lokasi.state berdasarkan masukan pengguna.
SELECT *
FROM Families f
WHERE f.lastName = @lastName AND f.location.state = @addressStatePermintaan ini kemudian dapat dikirim ke DocumentDB sebagai kueri JSON berparameter seperti yang ditunjukkan pada kode berikut.
{
"query": "SELECT * FROM Families f WHERE f.lastName = @lastName AND
f.location.state = @addressState",
"parameters": [
{"name": "@lastName", "value": "Wakefield"},
{"name": "@addressState", "value": "NY"},
]
}DocumentDB mendukung sejumlah fungsi bawaan untuk operasi umum yang dapat digunakan di dalam kueri. Ada banyak fungsi untuk melakukan penghitungan matematika, dan juga fungsi pemeriksaan tipe yang sangat berguna saat bekerja dengan berbagai skema. Fungsi-fungsi ini dapat menguji apakah ada properti tertentu dan apakah itu ada apakah itu angka atau string, Boolean atau objek.
Kami juga mendapatkan fungsi praktis ini untuk mem-parsing dan memanipulasi string, serta beberapa fungsi untuk bekerja dengan array yang memungkinkan Anda melakukan hal-hal seperti array gabungan dan menguji untuk melihat apakah array berisi elemen tertentu.
Berikut ini adalah berbagai jenis fungsi bawaan -
| S.No. | Fungsi & Deskripsi Bawaan |
|---|---|
| 1 | Fungsi Matematika Fungsi matematika melakukan penghitungan, biasanya berdasarkan nilai input yang diberikan sebagai argumen, dan mengembalikan nilai numerik. |
| 2 | Ketik Memeriksa Fungsi Fungsi pemeriksaan tipe memungkinkan Anda untuk memeriksa tipe ekspresi dalam kueri SQL. |
| 3 | Fungsi String Fungsi string melakukan operasi pada nilai input string dan mengembalikan nilai string, numerik atau Boolean. |
| 4 | Fungsi Array Fungsi array melakukan operasi pada nilai input array dan mengembalikannya dalam bentuk nilai numerik, Boolean atau nilai array. |
| 5 | Fungsi Spasial DocumentDB juga mendukung fungsi built-in Open Geospatial Consortium (OGC) untuk kueri geospasial. |
Di DocumentDB, kami benar-benar menggunakan SQL untuk meminta dokumen. Jika kita melakukan pengembangan .NET, ada juga penyedia LINQ yang dapat digunakan dan yang dapat menghasilkan SQL yang sesuai dari kueri LINQ.
Jenis Data yang Didukung
Di DocumentDB, semua jenis primitif JSON didukung di penyedia LINQ yang disertakan dengan DocumentDB .NET SDK yang adalah sebagai berikut -
- Numeric
- Boolean
- String
- Null
Ekspresi yang Didukung
Ekspresi skalar berikut ini didukung dalam penyedia LINQ yang disertakan dengan DocumentDB .NET SDK.
Constant Values - Termasuk nilai konstan dari tipe data primitif.
Property/Array Index Expressions - Ekspresi mengacu pada properti suatu objek atau elemen array.
Arithmetic Expressions - Termasuk ekspresi aritmatika umum pada nilai numerik dan Boolean.
String Comparison Expression - Termasuk membandingkan nilai string dengan beberapa nilai string konstan.
Object/Array Creation Expression- Mengembalikan objek dari tipe nilai majemuk atau tipe anonim atau larik objek semacam itu. Nilai-nilai ini dapat disarangkan.
Operator LINQ yang Didukung
Berikut adalah daftar operator LINQ yang didukung dalam penyedia LINQ yang disertakan dengan DocumentDB .NET SDK.
Select - Proyeksi diterjemahkan ke SQL SELECT termasuk konstruksi objek.
Where- Filter menerjemahkan ke SQL WHERE, dan mendukung terjemahan antara &&, || dan! ke operator SQL.
SelectMany- Memungkinkan pelepasan array ke klausa SQL JOIN. Dapat digunakan untuk ekspresi rantai / sarang untuk memfilter elemen array.
OrderBy and OrderByDescending - Diterjemahkan menjadi ORDER BY ascending / descending.
CompareTo- Diterjemahkan menjadi perbandingan rentang. Umumnya digunakan untuk string karena tidak sebanding di .NET.
Take - Diterjemahkan ke SQL TOP untuk membatasi hasil dari kueri.
Math Functions - Mendukung terjemahan dari .NET's Abs, Acos, Asin, Atan, Ceiling, Cos, Exp, Floor, Log, Log10, Pow, Round, Sign, Sin, Sqrt, Tan, Truncate ke fungsi SQL built-in yang setara.
String Functions - Mendukung terjemahan dari .NET Concat, Contains, EndsWith, IndexOf, Count, ToLower, TrimStart, Replace, Reverse, TrimEnd, StartsWith, SubString, ToUpper ke fungsi built-in SQL yang setara.
Array Functions - Mendukung terjemahan dari .NET Concat, Contains, dan Count ke fungsi built-in SQL yang setara.
Geospatial Extension Functions - Mendukung terjemahan dari metode rintisan Distance, Within, IsValid, dan IsValidDetailed ke fungsi built-in SQL yang setara.
User-Defined Extension Function - Mendukung terjemahan dari metode rintisan UserDefinedFunctionProvider.Invoke ke fungsi yang ditentukan pengguna terkait.
Miscellaneous- Mendukung terjemahan operator coalesce dan kondisional. Dapat menerjemahkan Berisi ke String CONTAINS, ARRAY_CONTAINS atau SQL IN tergantung pada konteksnya.
Mari kita lihat contoh di mana kita akan menggunakan .Net SDK. Berikut adalah tiga dokumen yang akan kami pertimbangkan untuk contoh ini.
Pelanggan Baru 1
{
"name": "New Customer 1",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}Pelanggan Baru 2
{
"name": "New Customer 2",
"address": {
"addressType": "Main Office",
"addressLine1": "678 Main Street",
"location": {
"city": "London",
"stateProvinceName": " London "
},
"postalCode": "11229",
"countryRegionName": "United Kingdom"
},
}Pelanggan Baru 3
{
"name": "New Customer 3",
"address": {
"addressType": "Main Office",
"addressLine1": "12 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}Berikut ini adalah kode yang kami kueri menggunakan LINQ. Kami telah menetapkan kueri LINQ diq, tetapi tidak akan dijalankan sampai kita menjalankan .ToList di atasnya.
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 akan mengubah kueri LINQ kami menjadi sintaks SQL untuk DocumentDB, menghasilkan klausa SELECT dan WHERE berdasarkan sintaks LINQ kami.
Mari panggil kueri di atas dari tugas 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);
}
}Ketika kode di atas dijalankan, ini menghasilkan keluaran sebagai berikut.
**** 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: BrooklynSaat ini JavaScript ada di mana-mana, dan tidak hanya di browser. DocumentDB merangkul JavaScript sebagai semacam T-SQL modern dan mendukung eksekusi transaksional logika JavaScript secara native, tepat di dalam mesin database. DocumentDB menyediakan model pemrograman untuk mengeksekusi logika aplikasi berbasis JavaScript langsung pada koleksi dalam hal prosedur dan pemicu yang tersimpan.
Mari kita lihat contoh di mana kita membuat prosedur penyimpanan sederhana. Berikut langkah-langkahnya -
Step 1 - Buat aplikasi konsol baru.
Step 2- Tambahkan .NET SDK dari NuGet. Kami menggunakan .NET SDK di sini, yang berarti kami akan menulis beberapa kode C # untuk membuat, mengeksekusi, dan kemudian menghapus prosedur tersimpan kami, tetapi prosedur tersimpan itu sendiri ditulis dalam JavaScript.
Step 3 - Klik kanan pada proyek di penjelajah Solusi.
Step 4 - Tambahkan file JavaScript baru untuk prosedur tersimpan dan beri nama HelloWorldStoreProce.js
Setiap prosedur yang disimpan hanyalah fungsi JavaScript jadi kami akan membuat fungsi baru dan tentu saja kami juga akan memberi nama fungsi ini HelloWorldStoreProce. Tidak masalah jika kita memberi nama pada fungsi tersebut. DocumentDB hanya akan merujuk ke prosedur tersimpan ini dengan Id yang kami berikan saat kami membuatnya.
function HelloWorldStoreProce() {
var context = getContext();
var response = context.getResponse();
response.setBody('Hello, and welcome to DocumentDB!');
}Semua prosedur tersimpan yang dilakukan adalah mendapatkan objek respons dari konteks dan memanggilnya setBodymetode untuk mengembalikan string ke pemanggil. Dalam kode C #, kita akan membuat prosedur tersimpan, menjalankannya, dan kemudian menghapusnya.
Prosedur yang disimpan memiliki cakupan per koleksi, oleh karena itu kita memerlukan Tautan Otomatis koleksi untuk membuat prosedur tersimpan.
Step 5 - Kueri pertama untuk myfirstdb database dan kemudian untuk MyCollection koleksi.
Membuat prosedur tersimpan sama seperti membuat sumber daya lain di 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 - Pertama buat objek definisi dengan Id untuk sumber daya baru dan kemudian panggil salah satu metode Buat di DocumentClientobyek. Dalam kasus prosedur tersimpan, definisi menyertakan Id dan kode JavaScript sebenarnya yang ingin Anda kirimkan ke server.
Step 7 - Panggil File.ReadAllText untuk mengekstrak kode prosedur tersimpan dari file JS.
Step 8 - Tetapkan kode prosedur tersimpan ke properti tubuh objek definisi.
Sejauh menyangkut DocumentDB, Id yang kami tentukan di sini, dalam definisi, adalah nama prosedur tersimpan, terlepas dari apa yang sebenarnya kami beri nama untuk fungsi JavaScript.
Namun demikian, saat membuat prosedur tersimpan dan objek sisi server lainnya, disarankan agar kita memberi nama fungsi JavaScript dan nama fungsi tersebut cocok dengan Id yang telah kita tetapkan dalam definisi untuk DocumentDB.
Step 9 - Panggil CreateStoredProcedureAsync, melewati SelfLink Untuk MyCollectionkoleksi dan definisi prosedur tersimpan. Ini menciptakan prosedur tersimpan danResourceId DocumentDB yang ditugaskan padanya.
Step 10 - Panggil prosedur tersimpan. ExecuteStoredProcedureAsyncmengambil parameter tipe yang Anda setel ke tipe data yang diharapkan dari nilai yang dikembalikan oleh prosedur tersimpan, yang dapat Anda tentukan hanya sebagai objek jika Anda ingin objek dinamis dikembalikan. Itu adalah objek yang propertinya akan terikat pada saat run-time.
Dalam contoh ini kita tahu bahwa prosedur tersimpan kita hanya mengembalikan sebuah string dan kita memanggil ExecuteStoredProcedureAsync<string>.
Berikut implementasi lengkap file 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);
}
}
}
}Ketika kode di atas dijalankan, ini menghasilkan keluaran sebagai berikut.
Created stored procedure HelloWorldStoreProce (Ic8LAMEUVgACAAAAAAAAgA==)
Executed stored procedure; response = Hello, and welcome to DocumentDB!Seperti yang terlihat pada keluaran di atas, properti respons memiliki "Halo, dan selamat datang di DocumentDB!" dikembalikan dengan prosedur tersimpan kami.
DocumentDB SQL menyediakan dukungan untuk User-Defined Functions (UDFs). UDF hanyalah jenis fungsi JavaScript lain yang dapat Anda tulis dan ini berfungsi seperti yang Anda harapkan. Anda bisa membuat UDF untuk memperluas bahasa kueri dengan logika bisnis kustom yang bisa Anda rujuk dalam kueri Anda.
Sintaks SQL DocumentDB diperluas untuk mendukung logika aplikasi kustom menggunakan UDF ini. UDF dapat didaftarkan dengan DocumentDB dan kemudian direferensikan sebagai bagian dari kueri SQL.
Mari pertimbangkan tiga dokumen berikut untuk contoh ini.
AndersenFamily dokumen adalah sebagai berikut.
{
"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 dokumen adalah sebagai berikut.
{
"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 dokumen adalah sebagai berikut.
{
"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
}Mari kita lihat contoh di mana kita akan membuat beberapa UDF sederhana.
Berikut adalah implementasi dari CreateUserDefinedFunctions.
private async static Task CreateUserDefinedFunctions(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create User Defined Functions ****");
Console.WriteLine();
await CreateUserDefinedFunction(client, "udfRegEx");
}Kami memiliki udfRegEx, dan di CreateUserDefinedFunction kami mendapatkan kode JavaScript-nya dari file lokal kami. Kami membuat objek definisi untuk UDF baru, dan memanggil CreateUserDefinedFunctionAsync dengan objek SelfLink dan udfDefinition koleksi seperti yang ditunjukkan pada kode berikut.
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;
}Kami mendapatkan kembali UDF baru dari properti sumber daya hasil dan mengembalikannya ke pemanggil. Untuk menampilkan UDF yang sudah ada berikut ini adalah implementasi dariViewUserDefinedFunctions. Kami memanggilCreateUserDefinedFunctionQuery dan mengulanginya seperti biasa.
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 tidak menyediakan fungsi bawaan untuk mencari substring atau ekspresi reguler, oleh karena itu baris satu kecil berikut mengisi celah itu yang merupakan fungsi JavaScript.
function udfRegEx(input, regex) {
return input.match(regex);
}Dengan mempertimbangkan string masukan di parameter pertama, gunakan dukungan ekspresi reguler bawaan JavaScript yang meneruskan string pencocokan pola di parameter kedua ke.match. Kita dapat menjalankan kueri substring untuk menemukan semua toko dengan kata Andersen di dalamnyalastName Properti.
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);
}
}Perhatikan bahwa kita harus memenuhi syarat setiap referensi UDF dengan awalan udf. Kami baru saja meneruskan SQL keCreateDocumentQueryseperti pertanyaan biasa. Akhirnya, mari kita panggil kueri di atas dariCreateDocumentClient tugas
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);
}
}Ketika kode di atas dijalankan, ini menghasilkan keluaran sebagai berikut.
**** 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 Querymemungkinkan Anda untuk menggabungkan data dari kueri yang ada dan kemudian menerapkan filter, agregat, dan sebagainya sebelum menyajikan hasil laporan, yang menampilkan kumpulan data gabungan. Kueri Komposit mengambil beberapa tingkat informasi terkait pada kueri yang ada dan menyajikan data gabungan sebagai hasil kueri tunggal dan diratakan.
Dengan menggunakan Kueri Komposit, Anda juga memiliki opsi untuk -
Pilih opsi pemangkasan SQL untuk menghapus tabel dan bidang yang tidak diperlukan berdasarkan pilihan atribut pengguna.
Setel klausul ORDER BY dan GROUP BY.
Setel klausa WHERE sebagai filter atas kumpulan hasil kueri gabungan.
Operator di atas dapat disusun untuk membentuk kueri yang lebih kuat. Karena DocumentDB mendukung koleksi bertingkat, komposisi dapat digabungkan atau disarangkan.
Mari pertimbangkan dokumen berikut untuk contoh ini.
AndersenFamily dokumen adalah sebagai berikut.
{
"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 dokumen adalah sebagai berikut.
{
"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 dokumen adalah sebagai berikut.
{
"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
}Mari kita lihat contoh kueri gabungan.
Berikut adalah query yang akan mengambil id dan lokasi keluarga tempat anak pertama givenName adalah Michelle.
SELECT f.id,f.location
FROM Families f
WHERE f.children[0].givenName = "Michelle"Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"id": "SmithFamily",
"location": {
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
}
}
]Mari pertimbangkan contoh lain dari kueri gabungan.
Berikut adalah kueri yang akan mengembalikan semua dokumen di mana nilai anak pertama lebih dari 3.
SELECT *
FROM Families f
WHERE ({grade: f.children[0].grade}.grade > 3)Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"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/"
}
]Mari kita lihat example kueri bertingkat.
Berikut adalah kueri yang akan mengulangi semua orang tua dan kemudian mengembalikan dokumen ke mana familyName adalah Smith.
SELECT *
FROM p IN Families.parents
WHERE p.familyName = "Smith"Ketika query di atas dijalankan, itu menghasilkan keluaran sebagai berikut.
[
{
"familyName": "Smith",
"givenName": "James"
}
]Mari pertimbangkan another example dari kueri bersarang.
Berikut ini adalah kueri yang akan mengembalikan semua familyName.
SELECT VALUE p.familyName
FROM Families f
JOIN p IN f.parentsKetika query di atas dijalankan, ia menghasilkan keluaran berikut.
[
"Wakefield",
"Miller",
"Smith",
"Curtis"
]