DocumentDB SQL - Hızlı Kılavuz
DocumentDB, Microsoft'un Azure üzerinde çalışan en yeni NoSQL belge veritabanı platformudur. Bu eğiticide, DocumentDB tarafından desteklenen özel SQL sürümünü kullanarak belgeleri sorgulama hakkında her şeyi öğreneceğiz.
NoSQL Belge Veritabanı
DocumentDB, Microsoft'un en yeni NoSQL belge veritabanıdır, ancak NoSQL belge veritabanı dediğimizde, NoSQL ve belge veritabanı ile tam olarak neyi kastediyoruz?
SQL, ilişkisel veritabanlarının geleneksel bir sorgu dili olan Yapılandırılmış Sorgu Dili anlamına gelir. SQL genellikle ilişkisel veritabanları ile eşitlenir.
Bir NoSQL veritabanını ilişkisel olmayan bir veritabanı olarak düşünmek gerçekten daha yararlıdır, bu nedenle NoSQL gerçekten ilişkisel olmayan anlamına gelir.
Aşağıdakiler gibi anahtar değer depolarını içeren farklı NoSQL veritabanı türleri vardır:
- Azure Tablo Depolama
- Cassandra gibi sütun tabanlı mağazalar
- NEO4 gibi grafik veritabanları
- MongoDB ve Azure DocumentDB gibi belge veritabanları
Neden SQL Sözdizimi?
Bu ilk başta garip gelebilir, ancak NoSQL veritabanı olan DocumentDB'de SQL kullanarak sorgulama yapıyoruz. Yukarıda belirtildiği gibi, bu, JSON ve JavaScript anlambilimine dayanan özel bir SQL sürümüdür.
SQL sadece bir dildir, ancak aynı zamanda zengin ve etkileyici olan çok popüler bir dildir. Bu nedenle, eğer veritabanınızdan belge almak istiyorsanız öğrenmemiz gereken sorguları ifade etmenin yepyeni bir yolunu bulmak yerine, SQL'in bir lehçesini kullanmak kesinlikle iyi bir fikir gibi görünüyor.
SQL, ilişkisel veritabanları için tasarlanmıştır ve DocumentDB, ilişkisel olmayan bir belge veritabanıdır. DocumentDB ekibi aslında SQL sözdizimini belge veritabanlarının ilişkisel olmayan dünyasına uyarladı ve bu, JSON ve JavaScript'te SQL'in köklendirilmesiyle kastedilen budur.
Dil hala tanıdık SQL olarak okuyor, ancak anlambilimin tümü ilişkisel tablolardan ziyade şema içermeyen JSON belgelerine dayanıyor. DocumentDB'de SQL veri türleri yerine JavaScript veri türleri ile çalışacağız. SELECT, FROM, WHERE ve benzerlerine aşina olacağız, ancak sayılar ve dizelerle sınırlı olan JavaScript türleri, nesneler, diziler, Boolean ve null, geniş kapsamlı SQL veri türleri aralığından çok daha azdır.
Benzer şekilde, ifadeler bir tür T-SQL yerine JavaScript ifadeleri olarak değerlendirilir. Örneğin, normal olmayan veriler dünyasında, satırlar ve sütunlarla değil, iç içe diziler ve nesneler içeren hiyerarşik yapılara sahip şema içermeyen belgeler ile ilgileniyoruz.
SQL nasıl çalışır?
DocumentDB ekibi bu soruyu çeşitli yenilikçi yollarla yanıtladı. Bunlardan birkaçı aşağıdaki gibi listelenmiştir -
İlk olarak, belgedeki her özelliği otomatik olarak indekslemek için varsayılan davranışı değiştirmediğinizi varsayarak, belge içinde ne kadar derinlemesine iç içe geçmiş olursa olsun herhangi bir özelliğe giden yolda gezinmek için sorgularınızda noktalı gösterimi kullanabilirsiniz.
İlişkisel dünyada iki tablo arasında bir birleştirmenin gerçekleştirilmesine çok benzer bir şekilde, iç içe geçmiş dizi öğelerinin bir belge içindeki üst öğeleriyle birleştirildiği bir belge içi birleştirme de gerçekleştirebilirsiniz.
Sorgularınız, belgeleri olduğu gibi veritabanından döndürebilir veya istediğiniz kadar çok veya az belge verisine dayalı olarak istediğiniz herhangi bir özel JSON şeklini yansıtabilirsiniz.
DocumentDB'deki SQL, aşağıdakiler de dahil olmak üzere birçok yaygın operatörü destekler:
Aritmetik ve bitsel işlemler
VE ve VEYA mantığı
Eşitlik ve aralık karşılaştırmaları
Dize birleştirme
Sorgu dili ayrıca bir dizi yerleşik işlevi de destekler.
Azure portal, herhangi bir SQL sorgusunu DocumentDB veritabanımızda çalıştırmamızı sağlayan bir Sorgu Gezgini'ne sahiptir. Mümkün olan en basit sorgudan başlayarak, sorgu dilinin birçok farklı özelliğini ve özelliğini göstermek için Sorgu Gezgini'ni kullanacağız.
Step 1 - Azure Portal'ı açın ve veritabanı dikey penceresinde Sorgu Gezgini dikey penceresine tıklayın.
Sorguların bir koleksiyon kapsamında çalıştığını ve bu nedenle Sorgu Gezgini'nin bu açılır menüden koleksiyonu seçmemize izin verdiğini unutmayın. Üç belgeyi içeren Aileler koleksiyonumuza seti bırakacağız. Bu örnekte bu üç belgeyi ele alalım.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Sorgu Gezgini, koleksiyondaki tüm belgeleri basitçe alan bu basit SELECT * FROM c sorgusuyla açılır. Basit olmasına rağmen, ilişkisel bir veritabanındaki eşdeğer sorgudan hala oldukça farklıdır.
Step 2- İlişkisel veritabanlarında SELECT *, DocumentDB'deyken tüm sütunları döndürmek anlamına gelir. Bu, sonucunuzdaki her belgenin tam olarak veritabanında depolandığı gibi döndürülmesini istediğiniz anlamına gelir.
Ancak, yalnızca bir SELECT * vermek yerine belirli özellikleri ve ifadeleri seçtiğinizde, sonuçtaki her belge için istediğiniz yeni bir şekil yansıtırsınız.
Step 3 - Sorguyu yürütmek ve Sonuçlar dikey penceresini açmak için 'Çalıştır'ı tıklayın.
Görüldüğü gibi WakefieldFamily, SmithFamily ve AndersonFamily geri alındı.
Aşağıda, sonuç olarak alınan üç belge bulunmaktadır. SELECT * FROM c sorgu.
[
{
"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/"
}
]Bununla birlikte, bu sonuçlar, sistem tarafından oluşturulan ve tümü alt çizgi karakteriyle başlayan özellikleri de içerir.
Bu bölümde, normal SQL'deki standart bir FROM yan tümcesi gibi çalışmayan FROM yan tümcesini ele alacağız.
Sorgular her zaman belirli bir koleksiyon bağlamında çalışır ve koleksiyondaki belgeler arasında birleşemez, bu da bizi neden bir FROM yan tümcesine ihtiyacımız olduğunu merak ettirir. Aslında yapmıyoruz, ancak onu dahil etmezsek, koleksiyondaki belgeleri sorgulamayacağız.
Bu maddenin amacı, sorgunun üzerinde çalışması gereken veri kaynağını belirlemektir. Genellikle tüm koleksiyon kaynaktır, ancak bunun yerine koleksiyonun bir alt kümesi belirtilebilir. Kaynak sorguda daha sonra filtrelenmediği veya yansıtılmadığı sürece FROM <from_specification> yan tümcesi isteğe bağlıdır.
Aynı örneğe tekrar bakalım. AşağıdakiAndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}
Yukarıdaki sorguda, "SELECT * FROM c”, Tüm Families koleksiyonunun numaralandırılacak kaynak olduğunu belirtir.
Alt belgeler
Kaynak ayrıca daha küçük bir alt kümeye indirgenebilir. Her belgede yalnızca bir alt ağacı almak istediğimizde, aşağıdaki örnekte gösterildiği gibi alt kök kaynak olabilir.
Aşağıdaki sorguyu çalıştırdığımızda -
SELECT * FROM Families.parentsAşağıdaki alt belgeler alınacaktır.
[
[
{
"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"
}
]
]Bu sorgu sonucunda yalnızca üst alt belgelerin alındığını görebiliriz.
Bu bölümde, FROM cümlesi gibi isteğe bağlı olan WHERE cümlesini de ele alacağız. Kaynak tarafından sağlanan JSON belgeleri şeklinde verileri alırken bir koşul belirtmek için kullanılır. Herhangi bir JSON belgesi, sonuç için dikkate alınması için belirtilen koşulları "doğru" olarak değerlendirmelidir. Belirtilen koşul karşılanırsa, ancak o zaman JSON belgeleri biçiminde belirli verileri döndürür. Kayıtları filtrelemek ve sadece gerekli kayıtları almak için WHERE cümlesini kullanabiliriz.
Bu örnekte aynı üç belgeyi ele alacağız. AşağıdakiAndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"id": "WakefieldFamily",
"parents": [
{ "familyName": "Wakefield", "givenName": "Robin" },
{ "familyName": "Miller", "givenName": "Ben" }
],
"children": [
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{ "givenName": "Charlie Brown", "type": "Dog" },
{ "givenName": "Tiger", "type": "Cat" },
{ "givenName": "Princess", "type": "Cat" }
]
},
{
"familyName": "Miller",
"givenName": "Lisa",
"gender": "female",
"grade": 3,
"pets": [
{ "givenName": "Jake", "type": "Snake" }
]
}
],
"location": { "state": "NY", "county": "Manhattan", "city": "NY" },
"isRegistered": false
}WHERE cümlesinin kullanıldığı basit bir örneğe bakalım.
Bu sorguda, WHERE yan tümcesinde, (WHERE f.id = "WakefieldFamily") koşulu belirtilir.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Yukarıdaki sorgu yürütüldüğünde, aşağıdaki çıktıda gösterildiği gibi WakefieldFamily için eksiksiz JSON belgesini döndürecektir.
[
{
"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/"
}
]Operatör, karşılaştırmalar ve aritmetik işlemler gibi işlemleri gerçekleştirmek için öncelikle bir SQL WHERE yan tümcesinde kullanılan ayrılmış bir kelime veya karakterdir. DocumentDB SQL ayrıca çeşitli skaler ifadeleri destekler. En sık kullanılanlarbinary and unary expressions.
Aşağıdaki SQL operatörleri şu anda desteklenmektedir ve sorgularda kullanılabilir.
SQL Karşılaştırma Operatörleri
Aşağıda, DocumentDB SQL dilbilgisinde bulunan tüm karşılaştırma operatörlerinin bir listesi bulunmaktadır.
| S.No. | Operatörler ve Açıklama |
|---|---|
| 1 | = İki işlenenin değerlerinin eşit olup olmadığını kontrol eder. Evet ise, koşul gerçek olur. |
| 2 | != İki işlenenin değerlerinin eşit olup olmadığını kontrol eder. Değerler eşit değilse, koşul doğru olur. |
| 3 | <> İki işlenenin değerlerinin eşit olup olmadığını kontrol eder. Değerler eşit değilse, koşul doğru olur. |
| 4 | > Sol işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder. Evet ise, koşul gerçek olur. |
| 5 | < Sol işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder. Evet ise, koşul gerçek olur. |
| 6 | >= Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder. Evet ise, koşul gerçek olur. |
| 7 | <= Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder. Evet ise, koşul gerçek olur. |
SQL Mantıksal Operatörler
Aşağıda, DocumentDB SQL dilbilgisinde bulunan tüm mantıksal işleçlerin bir listesi bulunmaktadır.
| S.No. | Operatörler ve Açıklama |
|---|---|
| 1 | AND AND operatörü, bir SQL ifadesinin WHERE tümcesinde birden çok koşulun varlığına izin verir. |
| 2 | BETWEEN BETWEEN operatörü, minimum değer ve maksimum değer verildiğinde, bir değerler kümesi dahilindeki değerleri aramak için kullanılır. |
| 3 | IN IN operatörü, bir değeri belirtilen değişmez değerler listesiyle karşılaştırmak için kullanılır. |
| 4 | OR OR operatörü, bir SQL ifadesinin WHERE yan tümcesinde birden çok koşulu birleştirmek için kullanılır. |
| 5 | NOT NOT operatörü, birlikte kullanıldığı mantıksal operatörün anlamını tersine çevirir. Örneğin, MEVCUT DEĞİL, ARASINDA DEĞİL, İÇİNDE DEĞİL, vb. Bu bir olumsuzlama işlecidir. |
SQL Aritmetik Operatörleri
Aşağıda, DocumentDB SQL gramerinde bulunan tüm aritmetik operatörlerin bir listesi bulunmaktadır.
| S.No. | Operatörler ve Açıklama |
|---|---|
| 1 | + Addition - Operatörün her iki tarafına da değerler ekler. |
| 2 | - Subtraction - Sağ el işleneni sol el işlenenden çıkarır. |
| 3 | * Multiplication - Operatörün her iki tarafındaki değerleri çarpar. |
| 4 | / Division - Sol el işleneni sağ el işlenene böler. |
| 5 | % Modulus - Sol el işleneni sağ el işlenene böler ve kalanı döndürür. |
Bu örnekte de aynı belgeleri ele alacağız. AşağıdakiAndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"id": "WakefieldFamily",
"parents": [
{ "familyName": "Wakefield", "givenName": "Robin" },
{ "familyName": "Miller", "givenName": "Ben" }
],
"children": [
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{ "givenName": "Charlie Brown", "type": "Dog" },
{ "givenName": "Tiger", "type": "Cat" },
{ "givenName": "Princess", "type": "Cat" }
]
},
{
"familyName": "Miller",
"givenName": "Lisa",
"gender": "female",
"grade": 3,
"pets": [
{ "givenName": "Jake", "type": "Snake" }
]
}
],
"location": { "state": "NY", "county": "Manhattan", "city": "NY" },
"isRegistered": false
}WHERE cümlesinde bir karşılaştırma operatörünün kullanıldığı basit bir örneğe bakalım.
Bu sorguda, WHERE yan tümcesinde, (WHERE f.id = "WakefieldFamily") koşulu belirtilir ve kimliği WakefieldFamily'e eşit olan belgeyi alır.
SELECT *
FROM f
WHERE f.id = "WakefieldFamily"Yukarıdaki sorgu yürütüldüğünde, aşağıdaki çıktıda gösterildiği gibi WakefieldFamily için eksiksiz JSON belgesini döndürecektir.
[
{
"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/"
}
]Sorgunun notu 5'ten büyük olan çocuk verilerini alacağı başka bir örneğe bakalım.
SELECT *
FROM Families.children[0] c
WHERE (c.grade > 5)Yukarıdaki sorgu yürütüldüğünde, çıktıda gösterildiği gibi aşağıdaki alt belgeyi alacaktır.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]BETWEEN anahtar sözcüğü, SQL'deki gibi değer aralıklarına karşı sorguları ifade etmek için kullanılır. BETWEEN dizelere veya sayılara karşı kullanılabilir. BETWEEN'i DocumentDB ve ANSI SQL'de kullanmak arasındaki temel fark, aralık sorgularını karışık türlerin özelliklerine göre ifade edebilmenizdir.
Örneğin, bazı belgelerde bir sayı olarak "not" almanız ve diğer belgelerde dizeler olması mümkündür. Bu durumlarda, iki farklı sonuç türü arasında bir karşılaştırma "tanımsız" olur ve belge atlanır.
Önceki örnekteki üç belgeyi ele alalım. AşağıdakiAndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Sorgunun, birinci çocuğun notunun 1-5 (her ikisi de dahil) arasında olduğu tüm aile belgelerini döndürdüğü bir örneğe bakalım.
BETWEEN anahtar kelimesinin kullanıldığı sorgu ve ardından AND mantıksal operatörü aşağıdadır.
SELECT *
FROM Families.children[0] c
WHERE c.grade BETWEEN 1 AND 5Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"givenName": "Michelle",
"gender": "female",
"grade": 1
},
{
"firstName": "Henriette Thaulow",
"gender": "female",
"grade": 5,
"pets": [
{
"givenName": "Fluffy",
"type": "Rabbit"
}
]
}
]Önceki örneğin aralığının dışındaki notları görüntülemek için, aşağıdaki sorguda gösterildiği gibi DEĞİL BETWEEN'i kullanın.
SELECT *
FROM Families.children[0] c
WHERE c.grade NOT BETWEEN 1 AND 5Bu sorgu çalıştırıldığında. Aşağıdaki çıktıyı üretir.
[
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{
"givenName": "Charlie Brown",
"type": "Dog"
},
{
"givenName": "Tiger",
"type": "Cat"
},
{
"givenName": "Princess",
"type": "Cat"
}
]
}
]IN anahtar sözcüğü, belirtilen bir değerin bir listedeki herhangi bir değerle eşleşip eşleşmediğini kontrol etmek için kullanılabilir. IN operatörü, bir WHERE yan tümcesinde birden çok değer belirtmenize izin verir. IN, birden çok OR yan tümcesini zincirlemeye eşdeğerdir.
Benzer üç belgenin önceki örneklerde yapıldığı kabul edilir. AşağıdakiAndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Basit bir örneğe bakalım.
Aşağıda, familyName "Smith" veya Wakefield olan verileri alacak sorgu bulunmaktadır.
SELECT *
FROM Families.parents[0] f
WHERE f.familyName IN ('Smith', 'Wakefield')Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"familyName": "Wakefield",
"givenName": "Robin"
},
{
"familyName": "Smith",
"givenName": "James"
}
]Kimliğin "SmithFamily" veya "AndersenFamily" den biri olduğu durumlarda tüm aile belgelerinin alınacağı başka bir basit örneği ele alalım. Sorgu aşağıdadır.
SELECT *
FROM Families
WHERE Families.id IN ('SmithFamily', 'AndersenFamily')Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"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/"
}
]Yalnızca tek bir değer döndürdüğünüzü bildiğinizde, VALUE anahtar sözcüğü, tam gelişmiş bir nesne oluşturmanın ek yükünden kaçınarak daha yalın bir sonuç kümesi oluşturmanıza yardımcı olabilir. VALUE anahtar sözcüğü, JSON değerini döndürmenin bir yolunu sağlar.
Basit bir örneğe bakalım.
VALUE anahtar kelimeli sorgu aşağıdadır.
SELECT VALUE "Hello World, this is DocumentDB SQL Tutorial"Bu sorgu yürütüldüğünde, "Merhaba Dünya, bu DocumentDB SQL Eğitimi" skalerini döndürür.
[
"Hello World, this is DocumentDB SQL Tutorial"
]Başka bir örnekte, önceki örneklerden üç belgeyi ele alalım.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Sorgu aşağıdadır.
SELECT VALUE f.location
FROM Families fBu sorgu yürütüldüğünde, adresi konum etiketi olmadan döndürür.
[
{
"state": "NY",
"county": "Manhattan",
"city": "NY"
},
{
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
},
{
"state": "WA",
"county": "King",
"city": "Seattle"
}
]Şimdi aynı sorguyu VALUE Anahtar Kelime olmadan belirtirsek, o zaman adres konum etiketli olarak dönecektir. Sorgu aşağıdadır.
SELECT f.location
FROM Families fBu sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"location": {
"state": "NY",
"county": "Manhattan",
"city": "NY"
}
},
{
"location": {
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
}
},
{
"location": {
"state": "WA",
"county": "King",
"city": "Seattle"
}
}
]Microsoft Azure DocumentDB, JSON belgeleri üzerinden SQL kullanarak belgelerin sorgulanmasını destekler. Koleksiyondaki belgeleri, sorgunuzda ORDER BY yan tümcesi kullanarak sayılara ve dizelere göre sıralayabilirsiniz. Yantümce, sonuçların alınması gereken sırayı belirtmek için isteğe bağlı bir ASC / DESC bağımsız değişkeni içerebilir.
Önceki örneklerde olduğu gibi aynı belgeleri ele alacağız.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Basit bir örneğe bakalım.
ORDER BY anahtar sözcüğünü içeren sorgu aşağıdadır.
SELECT f.id, f.children[0].givenName,f.children[0].grade
FROM Families f
ORDER BY f.children[0].gradeYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"id": "SmithFamily",
"givenName": "Michelle",
"grade": 1
},
{
"id": "AndersenFamily",
"grade": 5
},
{
"id": "WakefieldFamily",
"givenName": "Jesse",
"grade": 6
}
]Başka bir basit örneği ele alalım.
Aşağıda, ORDER BY anahtar sözcüğünü ve DESC isteğe bağlı anahtar sözcüğünü içeren sorgu verilmiştir.
SELECT f.id, f.parents[0].familyName
FROM Families f
ORDER BY f.parents[0].familyName DESCYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretecektir.
[
{
"id": "WakefieldFamily",
"familyName": "Wakefield"
},
{
"id": "SmithFamily",
"familyName": "Smith"
},
{
"id": "AndersenFamily"
}
]DocumentDB SQL'de Microsoft, JSON dizileri üzerinde yineleme desteği sağlamak için IN anahtar sözcüğü ile kullanılabilen yeni bir yapı ekledi. Yineleme desteği, FROM yan tümcesinde sağlanır.
Önceki örneklerden benzer üç belgeyi tekrar ele alacağız.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"id": "WakefieldFamily",
"parents": [
{ "familyName": "Wakefield", "givenName": "Robin" },
{ "familyName": "Miller", "givenName": "Ben" }
],
"children": [
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{ "givenName": "Charlie Brown", "type": "Dog" },
{ "givenName": "Tiger", "type": "Cat" },
{ "givenName": "Princess", "type": "Cat" }
]
},
{
"familyName": "Miller",
"givenName": "Lisa",
"gender": "female",
"grade": 3,
"pets": [
{ "givenName": "Jake", "type": "Snake" }
]
}
],
"location": { "state": "NY", "county": "Manhattan", "city": "NY" },
"isRegistered": false
}FROM yan tümcesinde IN anahtar sözcüğü olmayan basit bir örneğe bakalım.
Aile koleksiyonundan tüm ebeveynleri döndürecek sorgu aşağıdadır.
SELECT *
FROM Families.parentsYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
[
{
"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"
}
]
]Yukarıdaki çıktıda görülebileceği gibi, her ailenin ebeveynleri ayrı bir JSON dizisinde görüntülenir.
Aynı örneğe bir göz atalım, ancak bu sefer IN anahtar sözcüğünü FROM yan tümcesinde kullanacağız.
IN anahtar sözcüğünü içeren sorgu aşağıdadır.
SELECT *
FROM c IN Families.parentsYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"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
}
]Yukarıdaki örnekte, yineleme ile, koleksiyondaki üst öğe üzerinde yineleme gerçekleştiren sorgunun farklı çıktı dizisine sahip olduğu görülebilir. Bu nedenle, her aileden tüm ebeveynler tek bir diziye eklenir.
İlişkisel veritabanlarında, Joins yan tümcesi, bir veritabanındaki iki veya daha fazla tablodaki kayıtları birleştirmek için kullanılır ve normalleştirilmiş şemalar tasarlanırken tablolar arasında birleştirme ihtiyacı çok önemlidir. DocumentDB, şemasız belgelerin normalize edilmemiş veri modeliyle ilgilendiğinden, DocumentDB SQL'deki JOIN, "selfjoin" in mantıksal eşdeğeridir.
Üç belgeyi önceki örneklerdeki gibi ele alalım.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"id": "WakefieldFamily",
"parents": [
{ "familyName": "Wakefield", "givenName": "Robin" },
{ "familyName": "Miller", "givenName": "Ben" }
],
"children": [
{
"familyName": "Merriam",
"givenName": "Jesse",
"gender": "female",
"grade": 6,
"pets": [
{ "givenName": "Charlie Brown", "type": "Dog" },
{ "givenName": "Tiger", "type": "Cat" },
{ "givenName": "Princess", "type": "Cat" }
]
},
{
"familyName": "Miller",
"givenName": "Lisa",
"gender": "female",
"grade": 3,
"pets": [
{ "givenName": "Jake", "type": "Snake" }
]
}
],
"location": { "state": "NY", "county": "Manhattan", "city": "NY" },
"isRegistered": false
}JOIN cümlesinin nasıl çalıştığını anlamak için bir örneğe bakalım.
Aşağıda, kökü alt belgeye katacak sorgu yer almaktadır.
SELECT f.id
FROM Families f
JOIN c IN f.childrenYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretecektir.
[
{
"id": "WakefieldFamily"
},
{
"id": "WakefieldFamily"
},
{
"id": "SmithFamily"
},
{
"id": "SmithFamily"
},
{
"id": "AndersenFamily"
}
]Yukarıdaki örnekte, birleştirme, belge kökü ile iki JSON nesnesi arasında bir çapraz ürün oluşturan alt alt kök arasındadır. Aşağıda dikkat edilmesi gereken bazı noktalar verilmiştir -
FROM yan tümcesinde, JOIN yan tümcesi bir yineleyicidir.
İlk iki belge WakefieldFamily ve SmithFamily iki çocuk içerir, dolayısıyla sonuç kümesi ayrıca her çocuk için ayrı bir nesne üreten çapraz çarpımı da içerir.
Üçüncü belge AndersenFamily yalnızca bir çocuk içerir, dolayısıyla bu belgeye karşılık gelen yalnızca tek bir nesne vardır.
Aynı örneğe bir göz atalım, ancak bu sefer JOIN cümlesini daha iyi anlamak için çocuk adını da alıyoruz.
Aşağıda, kökü alt belgeye katacak sorgu yer almaktadır.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]İlişkisel veritabanlarında, bir tabloyu veya sütun başlığını geçici olarak yeniden adlandırmak için SQL takma adları kullanılır. Benzer şekilde, DocumentDB'de takma adlar bir JSON belgesini, alt belgeyi, nesneyi veya herhangi bir alanı geçici olarak yeniden adlandırmak için kullanılır.
Yeniden adlandırma geçici bir değişikliktir ve asıl belge değişmez. Temel olarak, alan / belge adlarını daha okunaklı hale getirmek için takma adlar oluşturulur. Örtüşme için isteğe bağlı olan AS anahtar sözcüğü kullanılır.
Önceki örneklerde kullanılanlardan üç benzer belgeyi ele alalım.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Takma adları tartışmak için bir örneğe bakalım.
Aşağıda, kökü alt belgeye katacak sorgu yer almaktadır. F.id AS familyName, c.givenName AS childGivenName ve c.firstName AS childFirstName gibi takma adlarımız var.
SELECT
f.id AS familyName,
c.givenName AS childGivenName,
c.firstName AS childFirstName
FROM Families f
JOIN c IN f.childrenYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"familyName": "WakefieldFamily",
"childGivenName": "Jesse"
},
{
"familyName": "WakefieldFamily",
"childGivenName": "Lisa"
},
{
"familyName": "SmithFamily",
"childGivenName": "Michelle"
},
{
"familyName": "SmithFamily",
"childGivenName": "John"
},
{
"familyName": "AndersenFamily",
"childFirstName": "Henriette Thaulow"
}
]Yukarıdaki çıktı, dosyalanmış adların değiştirildiğini, ancak bu geçici bir değişiklik olduğunu ve orijinal belgelerin değiştirilmediğini göstermektedir.
DocumentDB SQL'de Microsoft, yardımıyla kolayca bir dizi oluşturabileceğimiz önemli bir özellik ekledi. Bu, bir sorgu çalıştırdığımızda, sonuç olarak sorgu sonucunda JSON nesnesine benzer bir koleksiyon dizisi oluşturacağı anlamına gelir.
Önceki örneklerde olduğu gibi aynı belgeleri ele alalım.
Aşağıdaki AndersenFamily belge.
{
"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
}Aşağıdaki SmithFamily belge.
{
"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
}Aşağıdaki WakefieldFamily belge.
{
"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
}Bir örneğe bakalım.
Her ailenin aile adını ve adresini döndürecek sorgu aşağıdadır.
SELECT f.id AS FamilyName,
[f.location.city, f.location.county, f.location.state] AS Address
FROM Families fGörüldüğü gibi şehir, ilçe ve eyalet alanları köşeli parantez içine alınır ve bu bir dizi oluşturur ve bu dizi Adres olarak adlandırılır. Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"FamilyName": "WakefieldFamily",
"Address": [
"NY",
"Manhattan",
"NY"
]
},
{
"FamilyName": "SmithFamily",
"Address": [
"Forest Hills",
"Queens",
"NY"
]
},
{
"FamilyName": "AndersenFamily",
"Address": [
"Seattle",
"King",
"WA"
]
}
]Şehir, ilçe ve eyalet bilgileri yukarıdaki çıktıdaki Adres dizisine eklenir.
DocumentDB SQL'de SELECT yan tümcesi sabitler, aritmetik ifadeler, mantıksal ifadeler vb. Gibi skaler ifadeleri de destekler. Normalde, skaler sorgular nadiren kullanılır, çünkü koleksiyondaki belgeleri gerçekten sorgulamazlar, sadece ifadeleri değerlendirirler. Ancak, temel bilgileri, ifadelerin nasıl kullanılacağını ve bir sorguda JSON'un nasıl şekillendirileceğini öğrenmek için skaler ifade sorgularını kullanmak yine de yararlıdır ve bu kavramlar, bir koleksiyondaki belgelerde çalıştıracağınız gerçek sorgulara doğrudan uygulanır.
Birden çok skaler sorgu içeren bir örneğe bakalım.
Sorgu Gezgini'nde, yalnızca yürütülecek metni seçin ve 'Çalıştır'ı tıklayın. İlkini çalıştıralım.
SELECT "Hello"Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"$1": "Hello"
}
]Bu çıktı biraz kafa karıştırıcı görünebilir, o yüzden onu parçalayalım.
İlk olarak, son demoda gördüğümüz gibi, sorgu sonuçları her zaman köşeli parantez içinde yer alır çünkü bunlar bir JSON dizisi olarak döndürülür, hatta bunun gibi yalnızca tek bir belge döndüren skaler ifade sorgularından kaynaklanır.
İçinde bir belge bulunan bir dizimiz var ve bu belgenin içinde SELECT deyimindeki tek ifade için tek bir özellik var.
SELECT ifadesi bu özellik için bir ad sağlamaz, bu nedenle DocumentDB $ 1 kullanarak otomatik olarak bir tane oluşturur.
Bu genellikle istediğimiz şey değildir, bu nedenle, sorgudaki ifadeyi takma ad olarak adlandırmak için AS'yi kullanabiliriz, bu da oluşturulan belgedeki özellik adını bu örnekte olmasını istediğiniz şekilde yani word olarak ayarlar.
SELECT "Hello" AS wordYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"word": "Hello"
}
]Benzer şekilde, aşağıdaki başka bir basit sorgudur.
SELECT ((2 + 11 % 7)-2)/3Sorgu aşağıdaki çıktıyı alır.
[
{
"$1": 1.3333333333333333
}
]İç içe dizileri ve gömülü nesneleri şekillendirmenin başka bir örneğine bakalım.
SELECT
{
"words1":
["Hello", "World"],
"words2":
["How", "Are", "You?"]
} AS allWordsYukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"allWords": {
"words1": [
"Hello",
"World"
],
"words2": [
"How",
"Are",
"You?"
]
}
}
]İlişkisel veritabanlarında, parametreli sorgu, parametreler için yer tutucuların kullanıldığı ve parametre değerlerinin yürütme zamanında sağlandığı bir sorgudur. DocumentDB ayrıca parametreleştirilmiş sorguları destekler ve parametreli sorgudaki parametreler, bilinen @ gösterimiyle ifade edilebilir. Parametreli sorguları kullanmanın en önemli nedeni, SQL enjeksiyon saldırılarını önlemektir. Ayrıca, kullanıcı girdisinin sağlam bir şekilde ele alınmasını ve kaçılmasını sağlayabilir.
Net SDK'yı kullanacağımız bir örneğe göz atalım. Koleksiyonu silecek kod aşağıdadır.
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);
}Parametreli bir sorgunun yapısı aşağıdaki gibidir.
var query = new SqlQuerySpec {
QueryText = "SELECT * FROM c WHERE c.id = @id",
Parameters = new SqlParameterCollection { new SqlParameter { Name =
"@id", Value = collectionId } }
};CollectionId'yi kodlamıyoruz, bu nedenle bu yöntem herhangi bir koleksiyonu silmek için kullanılabilir. Parametre adlarının önüne SQL Server'a benzer şekilde '@' sembolünü kullanabiliriz.
Yukarıdaki örnekte, bu SqlQuerySpec parametresinin özelliğine atanan bu SqlParameterCollection içinde Id parametresinin tanımlandığı Id'ye göre belirli bir koleksiyonu sorguluyoruz. SDK daha sonra, içine gömülü koleksiyon kimliği ile DocumentDB için son sorgu dizesini oluşturma işini yapar. Sorguyu çalıştırıyoruz ve ardından koleksiyonu silmek için SelfLink'i kullanıyoruz.
Aşağıdaki CreateDocumentClient görev uygulamasıdır.
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");
}
}Kod yürütüldüğünde, aşağıdaki çıktıyı üretir.
**** Delete Collection MyCollection1 in mydb ****
Deleted collection MyCollection1 from database myfirstdb
**** Delete Collection MyCollection2 in mydb ****
Deleted collection MyCollection2 from database myfirstdbBaşka bir örneğe bakalım. Soyadı ve adres durumunu parametre olarak alan bir sorgu yazabilir ve ardından bunu kullanıcı girdisine bağlı olarak çeşitli soyad ve konum.state değerleri için çalıştırabiliriz.
SELECT *
FROM Families f
WHERE f.lastName = @lastName AND f.location.state = @addressStateBu istek daha sonra aşağıdaki kodda gösterildiği gibi DocumentDB'ye parametreli JSON sorgusu olarak gönderilebilir.
{
"query": "SELECT * FROM Families f WHERE f.lastName = @lastName AND
f.location.state = @addressState",
"parameters": [
{"name": "@lastName", "value": "Wakefield"},
{"name": "@addressState", "value": "NY"},
]
}DocumentDB, sorgular içinde kullanılabilen yaygın işlemler için bir dizi yerleşik işlevi destekler. Matematiksel hesaplamaları gerçekleştirmek için bir dizi işlev ve ayrıca çeşitli şemalarla çalışırken son derece yararlı olan tür kontrol işlevleri vardır. Bu işlevler, belirli bir özelliğin var olup olmadığını ve bir sayı mı yoksa dize, Boole veya nesne mi olduğunu test edebilir.
Dizeleri ayrıştırmak ve işlemek için bu kullanışlı işlevlerin yanı sıra dizileri birleştirmek ve bir dizinin belirli bir öğe içerip içermediğini test etmek gibi şeyler yapmanıza olanak tanıyan dizilerle çalışmak için çeşitli işlevler de alıyoruz.
Aşağıda farklı yerleşik işlev türleri verilmiştir -
| S.No. | Yerleşik İşlevler ve Açıklama |
|---|---|
| 1 | Matematiksel Fonksiyonlar Matematiksel işlevler, genellikle bağımsız değişken olarak sağlanan giriş değerlerine dayalı olarak bir hesaplama gerçekleştirir ve sayısal bir değer döndürür. |
| 2 | Tip Kontrol Fonksiyonları Tür denetimi işlevleri, SQL sorguları içindeki bir ifadenin türünü kontrol etmenize olanak tanır. |
| 3 | String Fonksiyonları Dize işlevleri, bir dize girdi değeri üzerinde bir işlem gerçekleştirir ve bir dize, sayısal veya Boole değeri döndürür. |
| 4 | Dizi İşlevleri Dizi işlevleri, bir dizi girdi değeri üzerinde bir işlem gerçekleştirir ve sayısal, Boolean veya dizi değeri biçiminde geri döner. |
| 5 | Mekansal Fonksiyonlar DocumentDB ayrıca jeo-uzamsal sorgulama için Açık Jeo-uzamsal Konsorsiyum (OGC) yerleşik işlevlerini de destekler. |
DocumentDB'de, belgeleri sorgulamak için aslında SQL kullanıyoruz. .NET geliştirme yapıyorsak, kullanılabilen ve bir LINQ sorgusundan uygun SQL oluşturabilen bir LINQ sağlayıcısı da vardır.
Desteklenen Veri Türleri
DocumentDB'de, tüm JSON ilkel türleri, aşağıdaki gibi DocumentDB .NET SDK ile birlikte verilen LINQ sağlayıcısında desteklenir -
- Numeric
- Boolean
- String
- Null
Desteklenen İfade
Aşağıdaki skaler ifadeler, DocumentDB .NET SDK ile birlikte gelen LINQ sağlayıcısında desteklenir.
Constant Values - İlkel veri türlerinin sabit değerlerini içerir.
Property/Array Index Expressions - İfadeler, bir nesnenin veya bir dizi öğesinin özelliğine atıfta bulunur.
Arithmetic Expressions - Sayısal ve Boole değerlerinde yaygın aritmetik ifadeler içerir.
String Comparison Expression - Bir dize değerinin bazı sabit dize değerleriyle karşılaştırılmasını içerir.
Object/Array Creation Expression- Bileşik değer türünde veya anonim türde bir nesne veya bu tür nesnelerden oluşan bir dizi döndürür. Bu değerler yuvalanabilir.
Desteklenen LINQ Operatörleri
DocumentDB .NET SDK ile birlikte verilen LINQ sağlayıcısında desteklenen LINQ operatörlerinin bir listesi aşağıda verilmiştir.
Select - Projeksiyonlar, nesne yapımı dahil olmak üzere SQL SELECT'e çevrilir.
Where- Filtreler WHERE SQL'e çevrilir ve &&, || arasında çeviriyi destekler. ve ! SQL operatörlerine.
SelectMany- Dizilerin SQL JOIN yan tümcesine çözülmesine izin verir. Dizi öğelerini filtrelemek için ifadeleri zincirlemek / iç içe yerleştirmek için kullanılabilir.
OrderBy and OrderByDescending - Artan / azalan SİPARİŞ olarak çevirir.
CompareTo- Aralık karşılaştırmalarına çevirir. .NET ile karşılaştırılamadıkları için genellikle dizeler için kullanılır.
Take - Bir sorgudan alınan sonuçları sınırlandırmak için SQL TOP'a çevirir.
Math Functions - .NET'in Abs, Acos, Asin, Atan, Ceiling, Cos, Exp, Floor, Log, Log10, Pow, Round, Sign, Sin, Sqrt, Tan, Truncate'den eşdeğer SQL yerleşik işlevlerine çeviriyi destekler.
String Functions - .NET'in Concat, Contains, EndsWith, IndexOf, Count, ToLower, TrimStart, Replace, Reverse, TrimEnd, StartsWith, SubString, ToUpper'dan eşdeğer SQL yerleşik işlevlerine çeviriyi destekler.
Array Functions - .NET'in Concat, Contains ve Count'tan eşdeğer SQL yerleşik işlevlerine çeviriyi destekler.
Geospatial Extension Functions - Mesafe, Within, IsValid ve IsValidDetailed gibi saplama yöntemlerinden eşdeğer SQL yerleşik işlevlerine çeviriyi destekler.
User-Defined Extension Function - UserDefinedFunctionProvider.Invoke saplama yönteminden ilgili kullanıcı tanımlı işleve çeviriyi destekler.
Miscellaneous- Birleştirme ve koşullu operatörlerin çevirisini destekler. İçeriği, bağlama bağlı olarak Dize CONTAINS, ARRAY_CONTAINS veya SQL IN'e çevirebilir.
Net SDK'yı kullanacağımız bir örneğe göz atalım. Bu örnek için ele alacağımız üç belge aşağıdadır.
Yeni Müşteri 1
{
"name": "New Customer 1",
"address": {
"addressType": "Main Office",
"addressLine1": "123 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}Yeni Müşteri 2
{
"name": "New Customer 2",
"address": {
"addressType": "Main Office",
"addressLine1": "678 Main Street",
"location": {
"city": "London",
"stateProvinceName": " London "
},
"postalCode": "11229",
"countryRegionName": "United Kingdom"
},
}Yeni Müşteri 3
{
"name": "New Customer 3",
"address": {
"addressType": "Main Office",
"addressLine1": "12 Main Street",
"location": {
"city": "Brooklyn",
"stateProvinceName": "New York"
},
"postalCode": "11229",
"countryRegionName": "United States"
},
}LINQ kullanarak sorguladığımız kod aşağıdadır. Bir LINQ sorgusu tanımladıkq, ancak biz .ToList'i çalıştırana kadar çalıştırılmayacak.
private static void QueryDocumentsWithLinq(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Query Documents (LINQ) ****");
Console.WriteLine();
Console.WriteLine("Quering for US customers (LINQ)");
var q =
from d in client.CreateDocumentQuery<Customer>(collection.DocumentsLink)
where d.Address.CountryRegionName == "United States"
select new {
Id = d.Id,
Name = d.Name,
City = d.Address.Location.City
};
var documents = q.ToList();
Console.WriteLine("Found {0} US customers", documents.Count);
foreach (var document in documents) {
var d = document as dynamic;
Console.WriteLine(" Id: {0}; Name: {1}; City: {2}", d.Id, d.Name, d.City);
}
Console.WriteLine();
}SDK, LINQ sorgumuzu DocumentDB için SQL sözdizimine dönüştürecek ve LINQ sözdizimimize göre bir SELECT ve WHERE yan tümcesi oluşturacaktır.
Yukarıdaki sorguları CreateDocumentClient görevinden çağıralım.
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);
}
}Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı üretir.
**** 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: BrooklynBugünlerde JavaScript her yerde ve sadece tarayıcılarda değil. DocumentDB, JavaScript'i modern bir T-SQL türü olarak benimser ve doğrudan veritabanı motorunun içinde yerel olarak JavaScript mantığının işlemsel yürütülmesini destekler. DocumentDB, JavaScript tabanlı uygulama mantığını, saklı yordamlar ve tetikleyiciler açısından doğrudan koleksiyonlar üzerinde yürütmek için bir programlama modeli sağlar.
Basit bir mağaza prosedürü oluşturduğumuz bir örneğe bakalım. Adımlar aşağıdadır -
Step 1 - Yeni bir konsol uygulamaları oluşturun.
Step 2- NuGet'ten .NET SDK'yı ekleyin. Burada .NET SDK kullanıyoruz; bu, depolanan yordamımızı oluşturmak, yürütmek ve sonra silmek için bazı C # kodları yazacağımız anlamına gelir, ancak saklı yordamın kendisi JavaScript'te yazılır.
Step 3 - Solution explorer'da projeye sağ tıklayın.
Step 4 - Depolanan prosedür için yeni bir JavaScript dosyası ekleyin ve buna HelloWorldStoreProce.js adını verin
Her saklı yordam yalnızca bir JavaScript işlevidir, bu nedenle yeni bir işlev oluşturacağız ve doğal olarak bu işlevi de adlandıracağız. HelloWorldStoreProce. İşleve bir ad vermemiz önemli değil. DocumentDB bu saklı yordama yalnızca, onu oluşturduğumuzda verdiğimiz kimlik ile başvurur.
function HelloWorldStoreProce() {
var context = getContext();
var response = context.getResponse();
response.setBody('Hello, and welcome to DocumentDB!');
}Tüm saklı yordamın yaptığı, yanıt nesnesini bağlamdan almak ve setBodyarayana bir dize döndürme yöntemi. C # kodunda, saklı yordamı oluşturacağız, çalıştıracağız ve sonra sileceğiz.
Depolanan prosedürler koleksiyon başına kapsamlıdır, bu nedenle saklı prosedürü oluşturmak için koleksiyonun SelfLink'ine ihtiyacımız olacaktır.
Step 5 - için ilk sorgu myfirstdb veritabanı ve ardından MyCollection Toplamak.
Depolanan bir yordam oluşturmak, DocumentDB'de başka herhangi bir kaynak oluşturmak gibidir.
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 - İlk önce yeni kaynağın Id'siyle bir tanım nesnesi oluşturun ve ardından üzerindeki Create yöntemlerinden birini çağırın. DocumentClientnesne. Depolanan yordam durumunda, tanım, kimliği ve sunucuya göndermek istediğiniz gerçek JavaScript kodunu içerir.
Step 7 - Çağrı File.ReadAllText JS dosyasından saklı yordam kodunu ayıklamak için.
Step 8 - Depolanan yordam kodunu, tanım nesnesinin body özelliğine atayın.
DocumentDB söz konusu olduğunda, tanımda burada belirttiğimiz kimlik, JavaScript işlevini gerçekte ne adlandırdığımıza bakılmaksızın saklı yordamın adıdır.
Bununla birlikte, saklı yordamları ve diğer sunucu tarafı nesneleri oluştururken, JavaScript işlevlerini adlandırmamız ve bu işlev adlarının DocumentDB tanımında belirlediğimiz kimlik ile eşleşmemesi önerilir.
Step 9 - Çağrı CreateStoredProcedureAsyncgeçerken SelfLink için MyCollectiontoplama ve saklı yordam tanımı. Bu, saklı yordamı oluşturur veResourceId DocumentDB'nin kendisine atandığı.
Step 10 - Saklanan prosedürü arayın. ExecuteStoredProcedureAsync, dinamik bir nesnenin döndürülmesini istiyorsanız basitçe bir nesne olarak belirtebileceğiniz, saklı yordam tarafından döndürülen değerin beklenen veri türüne ayarladığınız bir tür parametresini alır. Bu, özellikleri çalışma zamanında bağlanacak bir nesnedir.
Bu örnekte, saklı yordamımızın yalnızca bir dizge döndürdüğünü biliyoruz ve bu nedenle ExecuteStoredProcedureAsync<string>.
Aşağıda Program.cs dosyasının tam uygulaması verilmiştir.
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);
}
}
}
}Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı üretir.
Created stored procedure HelloWorldStoreProce (Ic8LAMEUVgACAAAAAAAAgA==)
Executed stored procedure; response = Hello, and welcome to DocumentDB!Yukarıdaki çıktıda görüldüğü gibi, yanıt özelliği "Merhaba, DocumentDB'ye hoş geldiniz!" saklı yordamımız tarafından iade edildi.
DocumentDB SQL, Kullanıcı Tanımlı İşlevler (UDF'ler) için destek sağlar. UDF'ler, yazabileceğiniz başka bir tür JavaScript işlevidir ve bunlar, beklediğiniz gibi çalışır. Sorgu dilini, sorgularınızda başvurabileceğiniz özel iş mantığı ile genişletmek için UDF'ler oluşturabilirsiniz.
DocumentDB SQL sözdizimi, bu UDF'leri kullanarak özel uygulama mantığını desteklemek için genişletilmiştir. UDF'ler DocumentDB ile kaydedilebilir ve ardından bir SQL sorgusunun parçası olarak referans gösterilebilir.
Bu örnek için aşağıdaki üç belgeyi ele alalım.
AndersenFamily belge aşağıdaki gibidir.
{
"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 belge aşağıdaki gibidir.
{
"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 belge aşağıdaki gibidir.
{
"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
}Bazı basit UDF'ler oluşturacağımız bir örneğe bakalım.
Aşağıdaki uygulamasıdır CreateUserDefinedFunctions.
private async static Task CreateUserDefinedFunctions(DocumentClient client) {
Console.WriteLine();
Console.WriteLine("**** Create User Defined Functions ****");
Console.WriteLine();
await CreateUserDefinedFunction(client, "udfRegEx");
}Bir udfRegEx'imiz var ve CreateUserDefinedFunction'da JavaScript kodunu yerel dosyamızdan alıyoruz. Yeni UDF için tanım nesnesini oluşturuyoruz ve aşağıdaki kodda gösterildiği gibi koleksiyonun SelfLink ve udfDefinition nesnesiyle CreateUserDefinedFunctionAsync çağırıyoruz.
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;
}Yeni UDF'yi sonucun resource özelliğinden geri alırız ve onu arayana geri göndeririz. Mevcut UDF'yi görüntülemek için, aşağıdakilerin uygulanmasıViewUserDefinedFunctions. Biz ararızCreateUserDefinedFunctionQuery ve her zamanki gibi bunların üzerinden geçin.
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 alt dizeleri veya normal ifadeleri aramak için yerleşik işlevler sağlamaz, bu nedenle aşağıdaki küçük tek satırlık bir JavaScript işlevi olan bu boşluğu doldurur.
function udfRegEx(input, regex) {
return input.match(regex);
}İlk parametrede girdi dizesi verildiğinde, JavaScript'in yerleşik normal ifade desteğini ikinci parametrede kalıp eşleştirme dizesini içine geçirmeyi kullanın.match. İçinde Andersen yazan tüm mağazaları bulmak için bir alt dize sorgusu çalıştırabiliriz.lastName Emlak.
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);
}
}Her UDF referansını önek ile nitelendirmemiz gerektiğini unutmayın udf. SQL'i şimdi geçtikCreateDocumentQuerysıradan bir sorgu gibi. Son olarak, yukarıdaki sorgularıCreateDocumentClient görev
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);
}
}Yukarıdaki kod çalıştırıldığında, aşağıdaki çıktıyı üretir.
**** 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 Query, birleştirilmiş veri kümesini gösteren rapor sonuçlarını sunmadan önce mevcut sorgulardan verileri birleştirmenizi ve ardından filtreler, toplamalar vb. uygulamanızı sağlar. Bileşik Sorgu, mevcut sorgularla ilgili birden çok bilgi düzeyini alır ve birleştirilmiş verileri tek ve düzleştirilmiş bir sorgu sonucu olarak sunar.
Bileşik Sorguyu kullanarak, şu seçeneğe de sahipsiniz:
Kullanıcıların öznitelik seçimlerine göre gerekli olmayan tabloları ve alanları kaldırmak için SQL budama seçeneğini seçin.
ORDER BY ve GROUP BY yan tümcelerini ayarlayın.
WHERE yan tümcesini bir bileşik sorgunun sonuç kümesi üzerinde bir filtre olarak ayarlayın.
Yukarıdaki operatörler, daha güçlü sorgular oluşturmak için oluşturulabilir. DocumentDB iç içe geçmiş koleksiyonları desteklediğinden, kompozisyon birleştirilebilir veya iç içe olabilir.
Bu örnek için aşağıdaki belgeleri ele alalım.
AndersenFamily belge aşağıdaki gibidir.
{
"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 belge aşağıdaki gibidir.
{
"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 belge aşağıdaki gibidir.
{
"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
}Birleştirilmiş sorgu örneğine bir göz atalım.
Aşağıda, ilk çocuğun bulunduğu ailenin kimliğini ve konumunu alacak olan sorgu yer almaktadır. givenName Michelle.
SELECT f.id,f.location
FROM Families f
WHERE f.children[0].givenName = "Michelle"Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"id": "SmithFamily",
"location": {
"state": "NY",
"county": "Queens",
"city": "Forest Hills"
}
}
]Birleştirilmiş sorguya başka bir örnek verelim.
Aşağıda, birinci çocuk notunun 3'ten büyük olduğu tüm belgeleri döndürecek sorgu yer almaktadır.
SELECT *
FROM Families f
WHERE ({grade: f.children[0].grade}.grade > 3)Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"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/"
}
]Bir göz atalım example iç içe geçmiş sorgular.
Aşağıda, tüm üst öğeleri yineleyecek ve ardından belgeyi nereye iade edecek familyName Smith.
SELECT *
FROM p IN Families.parents
WHERE p.familyName = "Smith"Yukarıdaki sorgu yürütüldüğünde aşağıdaki çıktıyı üretir.
[
{
"familyName": "Smith",
"givenName": "James"
}
]Hadi düşünelim another example iç içe geçmiş sorgu.
Aşağıdakilerin tümünü döndürecek sorgu familyName.
SELECT VALUE p.familyName
FROM Families f
JOIN p IN f.parentsYukarıdaki sorgu yürütüldüğünde, aşağıdaki çıktıyı üretir.
[
"Wakefield",
"Miller",
"Smith",
"Curtis"
]