DocumentDB SQL - คู่มือฉบับย่อ

DocumentDB เป็นแพลตฟอร์มฐานข้อมูลเอกสาร NoSQL ใหม่ล่าสุดของ Microsoft ที่ทำงานบน Azure ในบทช่วยสอนนี้เราจะเรียนรู้ทั้งหมดเกี่ยวกับการสืบค้นเอกสารโดยใช้ SQL เวอร์ชันพิเศษที่ DocumentDB สนับสนุน

ฐานข้อมูลเอกสาร NoSQL

DocumentDB เป็นฐานข้อมูลเอกสาร NoSQL ใหม่ล่าสุดของ Microsoft อย่างไรก็ตามเมื่อเราพูดว่าฐานข้อมูลเอกสาร NoSQL NoSQL และฐานข้อมูลเอกสารหมายถึงอะไร?

  • SQL หมายถึง Structured Query Language ซึ่งเป็นภาษาแบบสอบถามแบบดั้งเดิมของฐานข้อมูลเชิงสัมพันธ์ SQL มักจะเทียบเท่ากับฐานข้อมูลเชิงสัมพันธ์

  • การคิดว่าฐานข้อมูล NoSQL เป็นฐานข้อมูลที่ไม่ใช่เชิงสัมพันธ์นั้นมีประโยชน์มากกว่าดังนั้น NoSQL จึงหมายถึงการไม่สัมพันธ์กันจริงๆ

มีฐานข้อมูล NoSQL ประเภทต่างๆซึ่งรวมถึงที่เก็บค่าคีย์เช่น -

  • Azure Table Storage
  • ร้านค้าตามคอลัมน์เช่น Cassandra
  • ฐานข้อมูลกราฟเช่น NEO4
  • ฐานข้อมูลเอกสารเช่น MongoDB และ Azure DocumentDB

ทำไมต้องเป็น SQL Syntax

ตอนแรกอาจฟังดูแปลก ๆ แต่ใน DocumentDB ซึ่งเป็นฐานข้อมูล NoSQL เราจะสอบถามโดยใช้ SQL ดังที่ได้กล่าวไว้ข้างต้นนี่เป็นเวอร์ชันพิเศษของ SQL ที่รูทด้วยความหมาย JSON และ JavaScript

  • SQL เป็นเพียงภาษาหนึ่ง แต่ยังเป็นภาษายอดนิยมที่มีความหลากหลายและแสดงออกได้ ดังนั้นจึงเป็นความคิดที่ดีที่จะใช้ภาษาถิ่นของ SQL แทนที่จะใช้วิธีใหม่ในการแสดงข้อความค้นหาที่เราจำเป็นต้องเรียนรู้หากคุณต้องการดึงเอกสารออกจากฐานข้อมูลของคุณ

  • SQL ได้รับการออกแบบมาสำหรับฐานข้อมูลเชิงสัมพันธ์และ DocumentDB เป็นฐานข้อมูลเอกสารที่ไม่ใช่เชิงสัมพันธ์ ทีม DocumentDB ได้ปรับไวยากรณ์ SQL สำหรับโลกฐานข้อมูลเอกสารที่ไม่ใช่เชิงสัมพันธ์และนี่คือความหมายของการรูท SQL ใน JSON และ JavaScript

  • ภาษายังคงอ่านเป็น SQL ที่คุ้นเคย แต่ความหมายทั้งหมดขึ้นอยู่กับเอกสาร JSON แบบ schemafree แทนที่จะเป็นตารางเชิงสัมพันธ์ ใน DocumentDB เราจะทำงานกับชนิดข้อมูล JavaScript แทนประเภทข้อมูล SQL เราจะคุ้นเคยกับ SELECT, FROM, WHERE และอื่น ๆ แต่ประเภทของ JavaScript ซึ่ง จำกัด ไว้ที่ตัวเลขและสตริงอ็อบเจ็กต์อาร์เรย์บูลีนและ null นั้นน้อยกว่าประเภทข้อมูล SQL ที่หลากหลายมาก

  • ในทำนองเดียวกันนิพจน์จะถูกประเมินเป็นนิพจน์ JavaScript แทนที่จะเป็น T-SQL บางรูปแบบ ตัวอย่างเช่นในโลกของข้อมูลที่ถูกทำให้ผิดปกติเราไม่ได้จัดการกับแถวและคอลัมน์ แต่เป็นเอกสารที่ไม่มีสคีมาพร้อมโครงสร้างลำดับชั้นที่มีอาร์เรย์และวัตถุที่ซ้อนกัน

SQL ทำงานอย่างไร

ทีม DocumentDB ได้ตอบคำถามนี้ด้วยวิธีใหม่ ๆ มีอยู่ไม่กี่รายการดังต่อไปนี้ -

  • ขั้นแรกสมมติว่าคุณไม่ได้เปลี่ยนลักษณะการทำงานเริ่มต้นเพื่อจัดทำดัชนีทุกคุณสมบัติในเอกสารโดยอัตโนมัติคุณสามารถใช้สัญลักษณ์จุดในการสืบค้นของคุณเพื่อนำทางเส้นทางไปยังคุณสมบัติใด ๆ ไม่ว่าเอกสารนั้นจะซ้อนกันลึกเพียงใดก็ตาม

  • คุณยังสามารถทำการรวมภายในเอกสารซึ่งองค์ประกอบอาร์เรย์ที่ซ้อนกันจะถูกรวมเข้ากับองค์ประกอบหลักภายในเอกสารในลักษณะที่คล้ายกันมากกับวิธีการรวมระหว่างสองตารางในโลกเชิงสัมพันธ์

  • แบบสอบถามของคุณสามารถส่งคืนเอกสารจากฐานข้อมูลได้ตามที่เป็นอยู่หรือคุณสามารถฉายรูปร่าง JSON ที่กำหนดเองใด ๆ ที่คุณต้องการโดยยึดตามข้อมูลเอกสารที่คุณต้องการมากหรือน้อยก็ได้

  • SQL ใน DocumentDB สนับสนุนตัวดำเนินการทั่วไปหลายตัว ได้แก่ -

    • การคำนวณทางคณิตศาสตร์และบิต

    • ตรรกะ AND และ OR

    • การเปรียบเทียบความเท่าเทียมและช่วง

    • การต่อสายอักขระ

  • ภาษาแบบสอบถามยังสนับสนุนโฮสต์ของฟังก์ชันในตัว

พอร์ทัล Azure มี Query Explorer ที่ให้เราเรียกใช้แบบสอบถาม SQL กับฐานข้อมูล DocumentDB ของเรา เราจะใช้ Query Explorer เพื่อแสดงให้เห็นถึงความสามารถและคุณสมบัติที่แตกต่างกันมากมายของภาษาแบบสอบถามโดยเริ่มจากการสืบค้นที่ง่ายที่สุด

Step 1 - เปิด Azure Portal และในใบมีดฐานข้อมูลให้คลิกใบมีด Query Explorer

โปรดจำไว้ว่าการสืบค้นทำงานภายในขอบเขตของคอลเล็กชันดังนั้น Query Explorer จึงให้เราเลือกคอลเล็กชันในเมนูแบบเลื่อนลงนี้ เราจะปล่อยให้มันเป็นคอลเล็กชันครอบครัวของเราที่มีเอกสารทั้งสามชุด ลองพิจารณาเอกสารทั้งสามนี้ในตัวอย่างนี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

Query Explorer จะเปิดขึ้นด้วยการสืบค้นง่ายๆนี้ SELECT * FROM c ซึ่งจะดึงเอกสารทั้งหมดจากคอลเล็กชัน แม้ว่าจะง่าย แต่ก็ยังค่อนข้างแตกต่างจากแบบสอบถามที่เทียบเท่าในฐานข้อมูลเชิงสัมพันธ์

Step 2- ในฐานข้อมูลเชิงสัมพันธ์ SELECT * หมายถึงส่งคืนคอลัมน์ทั้งหมดขณะอยู่ใน DocumentDB หมายความว่าคุณต้องการให้เอกสารแต่ละรายการในผลลัพธ์ของคุณส่งคืนตรงตามที่เก็บไว้ในฐานข้อมูล

แต่เมื่อคุณเลือกคุณสมบัติและนิพจน์เฉพาะแทนที่จะออกเพียงแค่ SELECT * แสดงว่าคุณกำลังฉายรูปร่างใหม่ที่คุณต้องการสำหรับแต่ละเอกสารในผลลัพธ์

Step 3 - คลิก 'เรียกใช้' เพื่อดำเนินการค้นหาและเปิดใบมีดผลลัพธ์

ดังจะเห็นได้ว่า WakefieldFamily, SmithFamily และ AndersonFamily ถูกเรียกคืน

ต่อไปนี้เป็นเอกสารสามฉบับที่ดึงมาจากไฟล์ SELECT * FROM c แบบสอบถาม

[ 
   { 
      "id": "WakefieldFamily",
      "parents": [ 
         { 
            "familyName": "Wakefield", 
            "givenName": "Robin" 
         }, 
		
         { 
            "familyName": "Miller", 
            "givenName": "Ben" 
         } 
      ],
	  
      "children": [ 
         { 
            "familyName": "Merriam", 
            "givenName": "Jesse", 
            "gender": "female", 
            "grade": 6, 
			
            "pets": [ 
               { 
                  "givenName": "Charlie Brown", 
                  "type": "Dog" 
               },
			
               { 
                  "givenName": "Tiger", 
                  "type": "Cat" 
               },
			
               { 
                  "givenName": "Princess", 
                  "type": "Cat" 
               } 
            ] 
         }, 
		
         { 
            "familyName": "Miller", 
            "givenName": "Lisa", 
            "gender": "female", 
            "grade": 3, 
			
            "pets": [ 
               { 
                  "givenName": "Jake",
                  "type": "Snake" 
               } 
            ] 
         } 
      ], 
		
      "location": { 
         "state": "NY", 
         "county": "Manhattan", 
         "city": "NY" 
      }, 
		
      "isRegistered": false, 
      "_rid": "Ic8LAJFujgECAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgECAAAAAAAAAA==/", 
      "_etag": "\"00000500-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   }, 
	
   { 
      "id": "SmithFamily", 
      "parents": [ 
         { 
            "familyName": "Smith", 
            "givenName": "James" 
         }, 
		
         { 
            "familyName": "Curtis", 
            "givenName": "Helen" 
         } 
      ], 
		
      "children": [ 
         { 
            "givenName": "Michelle", 
            "gender": "female", 
            "grade": 1 
         }, 
		
         { 
            "givenName": "John", 
            "gender": "male", 
            "grade": 7,
			
            "pets": [ 
               { 
                  "givenName": "Tweetie", 
                  "type": "Bird" 
               } 
            ] 
         } 
      ],
		
      "location": { 
         "state": "NY", 
         "county": "Queens", 
         "city": "Forest Hills" 
      }, 
		
      "isRegistered": true, 
      "_rid": "Ic8LAJFujgEDAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEDAAAAAAAAAA==/", 
      "_etag": "\"00000600-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   }, 
	
   { 
      "id": "AndersenFamily", 
      "lastName": "Andersen", 
		
      "parents": [ 
         { 
            "firstName": "Thomas", 
            "relationship": "father" 
         },
		
         { 
            "firstName": "Mary Kay", 
            "relationship": "mother" 
         } 
      ], 
		
      "children": [ 
         { 
            "firstName": "Henriette Thaulow", 
            "gender": "female", 
            "grade": 5, 
			
            "pets": [  
               "givenName": "Fluffy", 
               "type": "Rabbit" 
            ] 
         } 
      ],
		
      "location": { 
         "state": "WA", 
         "county": "King", 
         "city": "Seattle" 
      },
		
      "isRegistered": true, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   }
]

อย่างไรก็ตามผลลัพธ์เหล่านี้ยังรวมถึงคุณสมบัติที่ระบบสร้างขึ้นซึ่งทั้งหมดขึ้นต้นด้วยอักขระขีดล่าง

ในบทนี้เราจะกล่าวถึงคำสั่ง FROM ซึ่งใช้งานไม่เหมือนกับคำสั่ง FROM มาตรฐานใน SQL ปกติ

การสืบค้นจะทำงานภายในบริบทของคอลเล็กชันเฉพาะเสมอและไม่สามารถรวมเอกสารภายในคอลเล็กชันได้ซึ่งทำให้เราสงสัยว่าทำไมเราจึงต้องมีคำสั่ง FROM ในความเป็นจริงเราไม่ได้ แต่ถ้าเราไม่รวมไว้เราก็จะไม่ค้นหาเอกสารในคอลเล็กชัน

วัตถุประสงค์ของประโยคนี้คือการระบุแหล่งข้อมูลที่แบบสอบถามต้องดำเนินการ โดยทั่วไปคอลเลกชันทั้งหมดเป็นแหล่งที่มา แต่สามารถระบุชุดย่อยของคอลเล็กชันแทนได้ ส่วนคำสั่ง FROM <from_specification> เป็นทางเลือกเว้นแต่ว่าแหล่งที่มาจะถูกกรองหรือฉายในคิวรีในภายหลัง

ลองมาดูตัวอย่างเดียวกันอีกครั้ง ต่อไปนี้คือไฟล์AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ในข้อความค้นหาด้านบน“SELECT * FROM c” บ่งชี้ว่าคอลเล็กชัน Families ทั้งหมดเป็นแหล่งที่จะแจกแจง

เอกสารย่อย

แหล่งที่มายังสามารถลดลงเป็นส่วนย่อยที่เล็กกว่าได้ เมื่อเราต้องการดึงเฉพาะแผนผังย่อยในแต่ละเอกสารรูทย่อยอาจกลายเป็นซอร์สได้ดังที่แสดงในตัวอย่างต่อไปนี้

เมื่อเราเรียกใช้แบบสอบถามต่อไปนี้ -

SELECT * FROM Families.parents

จะมีการดึงเอกสารย่อยต่อไปนี้

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

จากการสืบค้นนี้เราจะเห็นว่ามีการดึงเฉพาะเอกสารย่อยของพาเรนต์เท่านั้น

ในบทนี้เราจะกล่าวถึง WHERE clause ซึ่งเป็นทางเลือกเช่น FROM clause ใช้เพื่อระบุเงื่อนไขขณะดึงข้อมูลในรูปแบบของเอกสาร JSON ที่มาจากแหล่งที่มา เอกสาร JSON ใด ๆ ต้องประเมินเงื่อนไขที่ระบุให้เป็น "จริง" เพื่อพิจารณาผลลัพธ์ หากเป็นไปตามเงื่อนไขที่กำหนดระบบจะส่งคืนข้อมูลเฉพาะในรูปแบบของเอกสาร JSON เท่านั้น เราสามารถใช้ WHERE clause เพื่อกรองระเบียนและดึงเฉพาะระเบียนที่จำเป็น

เราจะพิจารณาเอกสารสามฉบับที่เหมือนกันในตัวอย่างนี้ ต่อไปนี้คือไฟล์AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

{ 
   "id": "WakefieldFamily", 
	
   "parents": [ 
      { "familyName": "Wakefield", "givenName": "Robin" }, 
      { "familyName": "Miller", "givenName": "Ben" } 
   ], 

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

ลองมาดูตัวอย่างง่ายๆที่ใช้ WHERE clause

ในแบบสอบถามนี้ในส่วนคำสั่ง WHERE จะระบุเงื่อนไข (WHERE f.id = "WakefieldFamily")

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

เมื่อดำเนินการค้นหาข้างต้นจะส่งคืนเอกสาร JSON ที่สมบูรณ์สำหรับ WakefieldFamily ดังที่แสดงในผลลัพธ์ต่อไปนี้

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

ตัวดำเนินการคือคำสงวนหรืออักขระที่ใช้เป็นหลักในส่วนคำสั่ง SQL WHERE เพื่อดำเนินการเช่นการเปรียบเทียบและการคำนวณทางคณิตศาสตร์ DocumentDB SQL ยังรองรับนิพจน์สเกลาร์ที่หลากหลาย ที่ใช้กันมากที่สุดคือbinary and unary expressions.

ขณะนี้ตัวดำเนินการ SQL ต่อไปนี้ได้รับการสนับสนุนและสามารถใช้ในแบบสอบถามได้

ตัวดำเนินการเปรียบเทียบ SQL

ต่อไปนี้เป็นรายการของตัวดำเนินการเปรียบเทียบทั้งหมดที่มีอยู่ในไวยากรณ์ SQL ของ DocumentDB

ส. ตัวดำเนินการและคำอธิบาย
1

=

ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง

2

!=

ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ หากค่าไม่เท่ากันเงื่อนไขจะเป็นจริง

3

<>

ตรวจสอบว่าค่าของตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ หากค่าไม่เท่ากันเงื่อนไขจะเป็นจริง

4

>

ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง

5

<

ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง

6

>=

ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง

7

<=

ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ ถ้าใช่เงื่อนไขจะกลายเป็นจริง

ตัวดำเนินการตรรกะ SQL

ต่อไปนี้เป็นรายการของตัวดำเนินการทางตรรกะทั้งหมดที่มีอยู่ในไวยากรณ์ SQL ของ DocumentDB

ส. ตัวดำเนินการและคำอธิบาย
1

AND

ตัวดำเนินการ AND อนุญาตให้มีหลายเงื่อนไขในส่วนคำสั่ง WHERE ของคำสั่ง SQL

2

BETWEEN

ตัวดำเนินการ BETWEEN ใช้เพื่อค้นหาค่าที่อยู่ในชุดของค่ากำหนดค่าต่ำสุดและค่าสูงสุด

3

IN

ตัวดำเนินการ IN ใช้เพื่อเปรียบเทียบค่ากับรายการค่าตามตัวอักษรที่ระบุไว้

4

OR

ตัวดำเนินการ OR ใช้เพื่อรวมหลายเงื่อนไขในคำสั่ง WHERE ของคำสั่ง SQL

5

NOT

ตัวดำเนินการ NOT จะกลับความหมายของตัวดำเนินการทางตรรกะที่ใช้ ตัวอย่างเช่น NOT EXISTS, NOT BETWEEN, NOT IN ฯลฯ นี่คือโอเปอเรเตอร์ปฏิเสธ

ตัวดำเนินการทางคณิตศาสตร์ SQL

ต่อไปนี้เป็นรายการของตัวดำเนินการเลขคณิตทั้งหมดที่มีอยู่ในไวยากรณ์ SQL ของ DocumentDB

ส. ตัวดำเนินการและคำอธิบาย
1

+

Addition - เพิ่มค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ

2

-

Subtraction - ลบตัวถูกดำเนินการด้านขวาออกจากตัวถูกดำเนินการด้านซ้าย

3

*

Multiplication - คูณค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ

4

/

Division - แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือ

5

%

Modulus - แบ่งตัวถูกดำเนินการด้านซ้ายด้วยตัวถูกดำเนินการด้านขวาและส่งกลับส่วนที่เหลือ

เราจะพิจารณาเอกสารเดียวกันในตัวอย่างนี้ด้วย ต่อไปนี้คือไฟล์AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

มาดูตัวอย่างง่ายๆที่ใช้ตัวดำเนินการเปรียบเทียบใน WHERE clause

ในแบบสอบถามนี้ในส่วนคำสั่ง WHERE จะมีการระบุเงื่อนไข (WHERE f.id = "WakefieldFamily") และจะดึงข้อมูลเอกสารที่มี id เท่ากับ WakefieldFamily

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

เมื่อดำเนินการค้นหาข้างต้นจะส่งคืนเอกสาร JSON ที่สมบูรณ์สำหรับ WakefieldFamily ดังที่แสดงในผลลัพธ์ต่อไปนี้

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

ลองมาดูอีกตัวอย่างหนึ่งที่แบบสอบถามจะดึงข้อมูลเด็กที่มีเกรดมากกว่า 5

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

เมื่อดำเนินการค้นหาข้างต้นระบบจะดึงเอกสารย่อยต่อไปนี้ดังแสดงในผลลัพธ์

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

คีย์เวิร์ด BETWEEN ใช้เพื่อแสดงคิวรีเทียบกับช่วงของค่าเช่นใน SQL ระหว่างนั้นสามารถใช้กับสตริงหรือตัวเลขได้ ความแตกต่างหลักระหว่างการใช้ BETWEEN ใน DocumentDB และ ANSI SQL คือคุณสามารถแสดงการสืบค้นช่วงเทียบกับคุณสมบัติของชนิดผสมได้

ตัวอย่างเช่นในเอกสารบางฉบับเป็นไปได้ว่าคุณอาจมี "เกรด" เป็นตัวเลขและในเอกสารอื่น ๆ อาจเป็นสตริง ในกรณีเหล่านี้การเปรียบเทียบระหว่างผลลัพธ์สองประเภทที่แตกต่างกันคือ "ไม่ได้กำหนด" และเอกสารจะถูกข้ามไป

ให้เราพิจารณาเอกสารสามฉบับจากตัวอย่างก่อนหน้านี้ ต่อไปนี้คือไฟล์AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ลองมาดูตัวอย่างโดยที่ข้อความค้นหาส่งคืนเอกสารครอบครัวทั้งหมดที่เกรดของเด็กคนแรกอยู่ระหว่าง 1-5 (รวมทั้งสองอย่าง)

ต่อไปนี้เป็นแบบสอบถามที่ใช้คีย์เวิร์ดระหว่างนั้นและตามด้วยตัวดำเนินการเชิงตรรกะ

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

หากต้องการแสดงผลการเรียนนอกช่วงของตัวอย่างก่อนหน้านี้ให้ใช้ NOT BETWEEN ดังที่แสดงในแบบสอบถามต่อไปนี้

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

เมื่อแบบสอบถามนี้ถูกเรียกใช้ มันสร้างผลลัพธ์ต่อไปนี้

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

คำสำคัญ IN สามารถใช้เพื่อตรวจสอบว่าค่าที่ระบุตรงกับค่าใด ๆ ในรายการหรือไม่ ตัวดำเนินการ IN ช่วยให้คุณระบุหลายค่าในส่วนคำสั่ง WHERE IN เทียบเท่ากับการโยงคำสั่ง OR หลายคำ

เอกสารสามฉบับที่คล้ายกันถือว่าเสร็จสิ้นในตัวอย่างก่อนหน้านี้ ต่อไปนี้คือไฟล์AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ลองมาดูตัวอย่างง่ายๆ

ต่อไปนี้เป็นแบบสอบถามที่จะดึงข้อมูลที่มี familyName เป็น "Smith" หรือ Wakefield

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ลองพิจารณาอีกตัวอย่างง่ายๆที่จะเรียกเอกสารครอบครัวทั้งหมดโดยที่ id เป็นหนึ่งใน "SmithFamily" หรือ "AndersenFamily" ต่อไปนี้คือแบบสอบถาม

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

[ 
   { 
      "id": "SmithFamily", 
      "parents": [ 
         { 
            "familyName": "Smith", 
            "givenName": "James" 
         }, 
			
         { 
            "familyName": "Curtis", 
            "givenName": "Helen"
         } 
      ], 
	  
      "children": [ 
         { 
            "givenName": "Michelle", 
            "gender": "female", 
            "grade": 1 
         },
			
         { 
            "givenName": "John", 
            "gender": "male", 
            "grade": 7,
				
            "pets": [ 
               { 
                  "givenName": "Tweetie", 
                  "type": "Bird" 
               }  
            ] 
         } 
      ], 
	  
      "location": { 
         "state": "NY", 
         "county": "Queens", 
         "city": "Forest Hills" 
      },
	  
      "isRegistered": true, 
      "_rid": "Ic8LAJFujgEDAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEDAAAAAAAAAA==/", 
      "_etag": "\"00000600-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   },
	
   { 
      "id": "AndersenFamily", 
      "lastName": "Andersen", 
		
      "parents": [ 
         { 
            "firstName": "Thomas", 
            "relationship": "father"
         },
			
         { 
            "firstName": "Mary Kay", 
            "relationship": "mother" 
         } 
      ],
	  
      "children": [ 
         { 
            "firstName": "Henriette Thaulow", 
            "gender": "female", 
            "grade": 5,
				
            "pets": [ 
               { 
                  "givenName": "Fluffy", 
                  "type": "Rabbit" 
               } 
            ] 
         } 
      ],
	  
      "location": {      
         "state": "WA", 
         "county": "King", 
         "city": "Seattle"    
      },
	  
      "isRegistered": true, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   }
]

เมื่อคุณรู้ว่าคุณส่งคืนค่าเดียวเท่านั้นคำหลัก VALUE สามารถช่วยสร้างผลลัพธ์ที่น้อยกว่าโดยหลีกเลี่ยงค่าใช้จ่ายในการสร้างวัตถุที่เต็มไปด้วย คีย์เวิร์ด VALUE มีวิธีส่งคืนค่า JSON

ลองมาดูตัวอย่างง่ายๆ

ต่อไปนี้คือข้อความค้นหาที่มีคำหลัก VALUE คำ

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

เมื่อเรียกใช้แบบสอบถามนี้จะส่งกลับสเกลาร์ "Hello World นี่คือ DocumentDB SQL Tutorial"

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

ในอีกตัวอย่างหนึ่งลองพิจารณาเอกสารสามฉบับจากตัวอย่างก่อนหน้านี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ต่อไปนี้คือแบบสอบถาม

SELECT VALUE f.location 
FROM Families f

เมื่อเรียกใช้แบบสอบถามนี้จะส่งคืนที่อยู่โดยไม่มีป้ายกำกับตำแหน่ง

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

หากตอนนี้เราระบุคำค้นหาเดียวกันโดยไม่มีคำหลัก VALUE คำค้นหาจะส่งคืนที่อยู่พร้อมป้ายกำกับสถานที่ ต่อไปนี้คือแบบสอบถาม

SELECT f.location 
FROM Families f

เมื่อเรียกใช้แบบสอบถามนี้จะสร้างผลลัพธ์ต่อไปนี้

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

Microsoft Azure DocumentDB รองรับการสืบค้นเอกสารโดยใช้ SQL ผ่านเอกสาร JSON คุณสามารถจัดเรียงเอกสารในคอลเลกชันด้วยตัวเลขและสตริงโดยใช้คำสั่ง ORDER BY ในแบบสอบถามของคุณ อนุประโยคสามารถรวมอาร์กิวเมนต์ ASC / DESC ที่เป็นทางเลือกเพื่อระบุลำดับที่จะต้องดึงผลลัพธ์

เราจะพิจารณาเอกสารเดียวกันกับในตัวอย่างก่อนหน้านี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ลองมาดูตัวอย่างง่ายๆ

ต่อไปนี้คือข้อความค้นหาที่มีคำหลัก ORDER BY

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ลองพิจารณาอีกตัวอย่างง่ายๆ

ต่อไปนี้เป็นคำค้นหาที่มีคำหลัก ORDER BY และคำหลักที่เป็นทางเลือกของ DESC

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

เมื่อดำเนินการค้นหาข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้

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

ใน DocumentDB SQL Microsoft ได้เพิ่มโครงสร้างใหม่ซึ่งสามารถใช้กับคีย์เวิร์ด IN เพื่อให้การสนับสนุนการทำซ้ำบนอาร์เรย์ JSON การสนับสนุนสำหรับการทำซ้ำมีให้ในส่วนคำสั่ง FROM

เราจะพิจารณาเอกสารสามฉบับที่คล้ายกันจากตัวอย่างก่อนหน้านี้อีกครั้ง

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

มาดูตัวอย่างง่ายๆโดยไม่ต้องใช้คำหลักในประโยค FROM

ต่อไปนี้คือข้อความค้นหาที่จะส่งคืนผู้ปกครองทั้งหมดจากคอลเล็กชันครอบครัว

SELECT *  
FROM Families.parents

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ดังที่เห็นได้จากผลลัพธ์ด้านบนผู้ปกครองของแต่ละตระกูลจะแสดงในอาร์เรย์ JSON แยกกัน

ลองมาดูตัวอย่างเดียวกัน แต่คราวนี้เราจะใช้คำหลัก IN ในส่วนคำสั่ง FROM

ต่อไปนี้เป็นแบบสอบถามที่มีคำหลัก IN

SELECT *  
FROM c IN Families.parents

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ในตัวอย่างข้างต้นจะเห็นได้ว่าเมื่อใช้การวนซ้ำคิวรีที่ทำซ้ำบนพาเรนต์ในคอลเล็กชันจะมีอาร์เรย์เอาต์พุตที่แตกต่างกัน ดังนั้นพ่อแม่ทุกคนจากแต่ละครอบครัวจะถูกเพิ่มเข้าไปในอาร์เรย์เดียว

ในฐานข้อมูลเชิงสัมพันธ์ Joins clause ใช้เพื่อรวมเร็กคอร์ดจากสองตารางขึ้นไปในฐานข้อมูลและความจำเป็นในการรวมข้ามตารางเป็นสิ่งสำคัญมากในขณะที่ออกแบบสกีมาที่เป็นมาตรฐาน เนื่องจาก DocumentDB เกี่ยวข้องกับโมเดลข้อมูลที่ไม่เป็นมาตรฐานของเอกสารที่ไม่มีสคีมา JOIN ใน DocumentDB SQL จึงเทียบเท่าตรรกะของ "selfjoin"

ลองพิจารณาเอกสารสามฉบับดังตัวอย่างก่อนหน้านี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

มาดูตัวอย่างเพื่อทำความเข้าใจว่าคำสั่ง JOIN ทำงานอย่างไร

ต่อไปนี้เป็นคิวรีที่จะรวมเอกสารย่อย root กับ children

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

เมื่อดำเนินการค้นหาข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้

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

ในตัวอย่างข้างต้นการรวมอยู่ระหว่างรูทเอกสารและรูทย่อยของเด็กซึ่งสร้างผลิตภัณฑ์ข้ามระหว่างออบเจ็กต์ JSON สองรายการ ต่อไปนี้เป็นประเด็นที่ควรทราบ -

  • ในส่วนคำสั่ง FROM ส่วนคำสั่ง JOIN คือตัวทำซ้ำ

  • เอกสารสองชุดแรก WakefieldFamily และ SmithFamily มีลูกสองคนด้วยเหตุนี้ชุดผลลัพธ์จึงประกอบด้วยผลิตภัณฑ์ข้ามผลิตภัณฑ์ซึ่งสร้างวัตถุแยกกันสำหรับเด็กแต่ละคน

  • เอกสารฉบับที่สาม AndersenFamily มีลูกเพียงคนเดียวดังนั้นจึงมีเพียงวัตถุเดียวที่ตรงกับเอกสารนี้

ลองมาดูตัวอย่างเดียวกัน แต่คราวนี้เราดึงชื่อลูกด้วยเพื่อความเข้าใจที่ดีขึ้นของคำสั่ง JOIN

ต่อไปนี้เป็นคิวรีที่จะรวมเอกสารย่อย root กับ children

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ในฐานข้อมูลเชิงสัมพันธ์นามแฝง SQL ใช้เพื่อเปลี่ยนชื่อตารางหรือส่วนหัวของคอลัมน์ชั่วคราว ในทำนองเดียวกันใน DocumentDB นามแฝงใช้เพื่อเปลี่ยนชื่อเอกสาร JSON เอกสารย่อยวัตถุหรือฟิลด์ใด ๆ ชั่วคราว

การเปลี่ยนชื่อเป็นการเปลี่ยนแปลงชั่วคราวและเอกสารจริงจะไม่เปลี่ยนแปลง โดยทั่วไปแล้วนามแฝงถูกสร้างขึ้นเพื่อให้ชื่อฟิลด์ / เอกสารอ่านได้ง่ายขึ้น สำหรับนามแฝงจะใช้คีย์เวิร์ด AS ซึ่งเป็นทางเลือก

ลองพิจารณาเอกสารที่คล้ายกันสามฉบับจากเอกสารที่ใช้ในตัวอย่างก่อนหน้านี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

มาดูตัวอย่างเพื่อหารือเกี่ยวกับนามแฝง

ต่อไปนี้เป็นคิวรีที่จะรวมเอกสารย่อย root กับ children เรามีนามแฝงเช่น f.id AS familyName, c.givenName AS childGivenName และ c.firstName AS childFirstName

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ผลลัพธ์ข้างต้นแสดงให้เห็นว่าชื่อที่ยื่นมีการเปลี่ยนแปลง แต่เป็นการเปลี่ยนแปลงชั่วคราวและไม่มีการแก้ไขเอกสารต้นฉบับ

ใน DocumentDB SQL Microsoft ได้เพิ่มคุณสมบัติหลักด้วยความช่วยเหลือซึ่งเราสามารถสร้างอาร์เรย์ได้อย่างง่ายดาย หมายความว่าเมื่อเราเรียกใช้แบบสอบถามจากนั้นผลลัพธ์จะสร้างอาร์เรย์ของคอลเลกชันที่คล้ายกับออบเจ็กต์ JSON อันเป็นผลมาจากการสืบค้น

ลองพิจารณาเอกสารเดียวกันกับในตัวอย่างก่อนหน้านี้

ต่อไปนี้คือไฟล์ AndersenFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ SmithFamily เอกสาร.

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

ต่อไปนี้คือไฟล์ WakefieldFamily เอกสาร.

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

ลองมาดูตัวอย่าง

ต่อไปนี้เป็นคำถามที่จะส่งคืนชื่อสกุลและที่อยู่ของแต่ละครอบครัว

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

ดังที่เห็นได้เขตข้อมูลเมืองเขตและรัฐอยู่ในวงเล็บเหลี่ยมซึ่งจะสร้างอาร์เรย์และอาร์เรย์นี้มีชื่อว่า Address เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ข้อมูลเมืองเขตและรัฐจะถูกเพิ่มในอาร์เรย์ที่อยู่ในเอาต์พุตด้านบน

ใน DocumentDB SQL อนุประโยค SELECT ยังรองรับนิพจน์สเกลาร์เช่นค่าคงที่นิพจน์เลขคณิตนิพจน์ตรรกะ ฯลฯ โดยปกติแล้วคิวรีแบบสเกลาร์จะไม่ค่อยใช้เนื่องจากไม่ได้ค้นหาเอกสารในคอลเล็กชันจริง ๆ เพียงแค่ประเมินนิพจน์เท่านั้น แต่ยังคงเป็นประโยชน์ในการใช้คิวรีนิพจน์สเกลาร์เพื่อเรียนรู้พื้นฐานวิธีใช้นิพจน์และกำหนดรูปแบบ JSON ในแบบสอบถามและแนวคิดเหล่านี้จะนำไปใช้โดยตรงกับแบบสอบถามจริงที่คุณจะใช้กับเอกสารในคอลเล็กชัน

มาดูตัวอย่างที่มีแบบสอบถามสเกลาร์หลายรายการ

ใน Query Explorer ให้เลือกเฉพาะข้อความที่จะดำเนินการแล้วคลิก 'เรียกใช้' มาเรียกใช้อันแรก

SELECT "Hello"

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ผลลัพธ์นี้อาจดูสับสนเล็กน้อยดังนั้นเรามาดูรายละเอียดกัน

  • อันดับแรกอย่างที่เราเห็นในการสาธิตครั้งล่าสุดผลลัพธ์ของคิวรีจะอยู่ในวงเล็บเหลี่ยมเสมอเนื่องจากจะถูกส่งคืนเป็นอาร์เรย์ JSON แม้กระทั่งผลลัพธ์จากคิวรีนิพจน์สเกลาร์เช่นเดียวกับที่ส่งกลับเอกสารเดียวเท่านั้น

  • เรามีอาร์เรย์ที่มีเอกสารหนึ่งชุดและเอกสารนั้นมีคุณสมบัติเดียวสำหรับนิพจน์เดียวในคำสั่ง SELECT

  • คำสั่ง SELECT ไม่ได้ระบุชื่อสำหรับคุณสมบัตินี้ดังนั้น DocumentDB จะสร้างโดยอัตโนมัติโดยใช้ $ 1

  • นี่ไม่ใช่สิ่งที่เราต้องการซึ่งเป็นเหตุผลว่าทำไมเราจึงสามารถใช้ AS แทนนิพจน์ในแบบสอบถามซึ่งตั้งชื่อคุณสมบัติในเอกสารที่สร้างขึ้นในแบบที่คุณต้องการให้เป็นคำในตัวอย่างนี้

SELECT "Hello" AS word

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

[ 
   { 
      "word": "Hello" 
   } 
]

ในทำนองเดียวกันต่อไปนี้เป็นอีกหนึ่งแบบสอบถามง่ายๆ

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

แบบสอบถามดึงผลลัพธ์ต่อไปนี้

[ 
   { 
      "$1": 1.3333333333333333 
   } 
]

ลองดูตัวอย่างอื่นของการสร้างอาร์เรย์ที่ซ้อนกันและวัตถุฝังตัว

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ในฐานข้อมูลเชิงสัมพันธ์แบบสอบถามแบบกำหนดพารามิเตอร์คือแบบสอบถามที่ใช้ตัวยึดตำแหน่งสำหรับพารามิเตอร์และให้ค่าพารามิเตอร์ในเวลาดำเนินการ นอกจากนี้ DocumentDB ยังรองรับเคียวรีที่กำหนดพารามิเตอร์และพารามิเตอร์ในเคียวรีที่กำหนดพารามิเตอร์สามารถแสดงด้วยสัญกรณ์ @ ที่คุ้นเคย เหตุผลที่สำคัญที่สุดในการใช้การสืบค้นแบบกำหนดพารามิเตอร์คือการหลีกเลี่ยงการโจมตีด้วยการแทรก SQL นอกจากนี้ยังสามารถให้การจัดการที่มีประสิทธิภาพและการหลีกเลี่ยงการป้อนข้อมูลของผู้ใช้

ลองมาดูตัวอย่างที่เราจะใช้. Net SDK ต่อไปนี้เป็นรหัสที่จะลบคอลเล็กชัน

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

การสร้างแบบสอบถามแบบกำหนดพารามิเตอร์มีดังนี้

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

เราไม่ได้ฮาร์ดโค้ด collectionId ดังนั้นจึงสามารถใช้วิธีนี้เพื่อลบคอลเล็กชันใดก็ได้ เราสามารถใช้สัญลักษณ์ '@' เพื่อนำหน้าชื่อพารามิเตอร์คล้ายกับ SQL Server

ในตัวอย่างข้างต้นเรากำลังค้นหาคอลเล็กชันเฉพาะโดย Id โดยที่พารามิเตอร์ Id ถูกกำหนดใน SqlParameterCollection นี้กำหนดให้กับคุณสมบัติของพารามิเตอร์ของ SqlQuerySpec นี้ จากนั้น SDK จะทำงานในการสร้างสตริงเคียวรีสุดท้ายสำหรับ DocumentDB โดยมี collectionId ฝังอยู่ภายใน เราเรียกใช้แบบสอบถามจากนั้นใช้ SelfLink เพื่อลบคอลเล็กชัน

ต่อไปนี้คือการนำงาน CreateDocumentClient ไปใช้งาน

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

เมื่อรหัสถูกเรียกใช้งานจะสร้างผลลัพธ์ต่อไปนี้

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

ลองมาดูตัวอย่างอื่น เราสามารถเขียนแบบสอบถามที่ใช้นามสกุลและสถานะที่อยู่เป็นพารามิเตอร์จากนั้นเรียกใช้งานสำหรับค่าต่างๆของนามสกุลและตำแหน่งที่ตั้งโดยยึดตามข้อมูลที่ผู้ใช้ป้อน

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

จากนั้นสามารถส่งคำขอนี้ไปยัง DocumentDB เป็นคิวรี JSON ที่กำหนดพารามิเตอร์ดังที่แสดงในโค้ดต่อไปนี้

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

DocumentDB สนับสนุนโฮสต์ของฟังก์ชันในตัวสำหรับการดำเนินการทั่วไปที่สามารถใช้ภายในคิวรี มีฟังก์ชันมากมายสำหรับการคำนวณทางคณิตศาสตร์และยังพิมพ์ฟังก์ชันการตรวจสอบที่มีประโยชน์อย่างยิ่งในขณะที่ทำงานกับสคีมาที่แตกต่างกัน ฟังก์ชันเหล่านี้สามารถทดสอบได้ว่าคุณสมบัติบางอย่างมีอยู่จริงหรือไม่และไม่ว่าจะเป็นตัวเลขหรือสตริงบูลีนหรือวัตถุ

นอกจากนี้เรายังมีฟังก์ชันที่มีประโยชน์เหล่านี้สำหรับการแยกวิเคราะห์และจัดการสตริงรวมถึงฟังก์ชันต่างๆสำหรับการทำงานกับอาร์เรย์ที่ช่วยให้คุณสามารถทำสิ่งต่างๆเช่นอาร์เรย์แบบเรียงต่อกันและทดสอบเพื่อดูว่าอาร์เรย์มีองค์ประกอบเฉพาะหรือไม่

ต่อไปนี้เป็นฟังก์ชันในตัวประเภทต่างๆ -

ส. ฟังก์ชั่นและคำอธิบายในตัว
1 ฟังก์ชันทางคณิตศาสตร์

ฟังก์ชันทางคณิตศาสตร์ทำการคำนวณโดยปกติจะขึ้นอยู่กับค่าอินพุตที่ระบุเป็นอาร์กิวเมนต์และส่งคืนค่าตัวเลข

2 พิมพ์ฟังก์ชันการตรวจสอบ

ฟังก์ชันการตรวจสอบชนิดช่วยให้คุณตรวจสอบประเภทของนิพจน์ภายในแบบสอบถาม SQL

3 ฟังก์ชันสตริง

ฟังก์ชันสตริงดำเนินการกับค่าอินพุตสตริงและส่งคืนสตริงตัวเลขหรือค่าบูลีน

4 ฟังก์ชันอาร์เรย์

ฟังก์ชันอาร์เรย์ดำเนินการกับค่าอินพุตอาร์เรย์และส่งคืนในรูปแบบของค่าตัวเลขบูลีนหรืออาร์เรย์

5 ฟังก์ชันเชิงพื้นที่

DocumentDB ยังสนับสนุนฟังก์ชันในตัว Open Geospatial Consortium (OGC) สำหรับการสืบค้นข้อมูลเชิงพื้นที่

ใน DocumentDB เราใช้ SQL ในการสืบค้นเอกสาร หากเรากำลังทำการพัฒนา. NET นอกจากนี้ยังมีผู้ให้บริการ LINQ ที่สามารถใช้งานได้และสามารถสร้าง SQL ที่เหมาะสมจากแบบสอบถาม LINQ

ประเภทข้อมูลที่รองรับ

ใน DocumentDB ประเภทพื้นฐาน JSON ทั้งหมดได้รับการสนับสนุนในตัวให้บริการ LINQ ที่มาพร้อมกับ DocumentDB .NET SDK ซึ่งมีดังต่อไปนี้ -

  • Numeric
  • Boolean
  • String
  • Null

นิพจน์ที่รองรับ

นิพจน์สเกลาร์ต่อไปนี้ได้รับการสนับสนุนในตัวให้บริการ LINQ ที่รวมอยู่ใน DocumentDB .NET SDK

  • Constant Values - รวมค่าคงที่ของประเภทข้อมูลดั้งเดิม

  • Property/Array Index Expressions - นิพจน์อ้างถึงคุณสมบัติของวัตถุหรือองค์ประกอบอาร์เรย์

  • Arithmetic Expressions - รวมนิพจน์เลขคณิตทั่วไปเกี่ยวกับค่าตัวเลขและค่าบูลีน

  • String Comparison Expression - รวมถึงการเปรียบเทียบค่าสตริงกับค่าสตริงคงที่

  • Object/Array Creation Expression- ส่งคืนวัตถุประเภทค่าผสมหรือชนิดที่ไม่ระบุตัวตนหรืออาร์เรย์ของวัตถุดังกล่าว ค่าเหล่านี้สามารถซ้อนกันได้

ตัวดำเนินการ LINQ ที่รองรับ

นี่คือรายการของตัวดำเนินการ LINQ ที่สนับสนุนในตัวให้บริการ LINQ ที่มาพร้อมกับ DocumentDB .NET SDK

  • Select - ประมาณการแปลเป็น SQL SELECT รวมถึงการสร้างวัตถุ

  • Where- ตัวกรองแปลเป็น SQL WHERE และรองรับการแปลระหว่าง &&, || และ! ไปยังตัวดำเนินการ SQL

  • SelectMany- อนุญาตให้คลายอาร์เรย์ของส่วนคำสั่ง SQL JOIN สามารถใช้เพื่อเชื่อมโยงนิพจน์ / รังเพื่อกรององค์ประกอบอาร์เรย์

  • OrderBy and OrderByDescending - แปลเป็นคำสั่งซื้อโดยขึ้น / ลง

  • CompareTo- แปลเป็นการเปรียบเทียบช่วง ใช้กันทั่วไปสำหรับสตริงเนื่องจากไม่สามารถเทียบเคียงได้ใน. NET

  • Take - แปลเป็น SQL TOP เพื่อ จำกัด ผลลัพธ์จากแบบสอบถาม

  • Math Functions - รองรับการแปลจาก. NET's Abs, Acos, Asin, Atan, Ceiling, Cos, Exp, Floor, Log, Log10, Pow, Round, Sign, Sin, Sqrt, Tan, Truncate ให้เทียบเท่ากับฟังก์ชันในตัวของ SQL

  • String Functions - รองรับการแปลจาก. NET's Concat, ประกอบด้วย, EndsWith, IndexOf, Count, ToLower, TrimStart, Replace, Reverse, TrimEnd, StartsWith, SubString, ToUpper เป็นฟังก์ชันในตัวของ SQL ที่เทียบเท่า

  • Array Functions - รองรับการแปลจาก. NET's Concat, ประกอบด้วยและนับเป็นฟังก์ชันในตัวของ SQL ที่เทียบเท่า

  • Geospatial Extension Functions - รองรับการแปลจากวิธีการต้นขั้ว Distance, Within, IsValid และ IsValidDetailed เป็นฟังก์ชันในตัวของ SQL ที่เทียบเท่า

  • User-Defined Extension Function - รองรับการแปลจากวิธีต้นขั้ว UserDefinedFunctionProvider เรียกใช้ฟังก์ชันที่ผู้ใช้กำหนดที่เกี่ยวข้อง

  • Miscellaneous- รองรับการแปลตัวดำเนินการรวมกันและเงื่อนไข สามารถแปลมีเป็นสตริง CONTAINS, ARRAY_CONTAINS หรือ SQL IN ขึ้นอยู่กับบริบท

ลองมาดูตัวอย่างที่เราจะใช้. Net SDK ต่อไปนี้เป็นเอกสารสามฉบับที่เราจะพิจารณาเป็นตัวอย่างนี้

ลูกค้าใหม่ 1

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

ลูกค้าใหม่ 2

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

ลูกค้าใหม่ 3

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

ต่อไปนี้เป็นรหัสที่เราค้นหาโดยใช้ LINQ เราได้กำหนดแบบสอบถาม LINQ ในqแต่มันจะไม่ทำงานจนกว่าเราจะเรียกใช้. ToList กับมัน

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

SDK จะแปลงแบบสอบถาม LINQ ของเราเป็นไวยากรณ์ SQL สำหรับ DocumentDB โดยสร้างคำสั่ง SELECT และ WHERE ตามไวยากรณ์ LINQ ของเรา

เรียกแบบสอบถามข้างต้นจากงาน CreateDocumentClient

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

เมื่อดำเนินการโค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้

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

ทุกวันนี้ JavaScript มีอยู่ทั่วไปไม่ใช่แค่ในเบราว์เซอร์เท่านั้น DocumentDB รวบรวม JavaScript เป็นประเภทหนึ่งของ T-SQL ในยุคปัจจุบันและสนับสนุนการดำเนินการตามธุรกรรมของลอจิก JavaScript ภายในเครื่องฐานข้อมูล DocumentDB จัดเตรียมรูปแบบการเขียนโปรแกรมสำหรับการเรียกใช้ตรรกะของแอปพลิเคชันที่ใช้ JavaScript โดยตรงบนคอลเลกชันในแง่ของโพรซีเดอร์และทริกเกอร์ที่จัดเก็บไว้

มาดูตัวอย่างที่เราสร้างขั้นตอนการจัดเก็บง่ายๆ ต่อไปนี้เป็นขั้นตอน -

Step 1 - สร้างแอปพลิเคชันคอนโซลใหม่

Step 2- เพิ่มใน. NET SDK จาก NuGet เรากำลังใช้. NET SDK ที่นี่ซึ่งหมายความว่าเราจะเขียนโค้ด C # บางส่วนเพื่อสร้างรันและลบโพรซีเดอร์ที่จัดเก็บของเรา แต่โพรซีเดอร์ที่จัดเก็บเองจะถูกเขียนด้วย JavaScript

Step 3 - คลิกขวาที่โครงการใน Solution explorer

Step 4 - เพิ่มไฟล์ JavaScript ใหม่สำหรับขั้นตอนการจัดเก็บและเรียกมันว่า HelloWorldStoreProce.js

ทุกกระบวนงานที่จัดเก็บเป็นเพียงฟังก์ชัน JavaScript ดังนั้นเราจะสร้างฟังก์ชันใหม่และโดยปกติแล้วเราจะตั้งชื่อฟังก์ชันนี้ด้วย HelloWorldStoreProce. ไม่สำคัญว่าเราจะตั้งชื่อให้กับฟังก์ชันเลยหรือไม่ DocumentDB จะอ้างถึงโพรซีเดอร์ที่จัดเก็บนี้โดย Id ที่เราระบุเมื่อสร้างเท่านั้น

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

โพรซีเดอร์ที่เก็บไว้ทั้งหมดคือรับอ็อบเจ็กต์การตอบสนองจากบริบทและเรียกใช้ setBodyวิธีการส่งคืนสตริงให้กับผู้โทร ในรหัส C # เราจะสร้างโพรซีเดอร์ที่เก็บไว้ดำเนินการแล้วลบออก

ขั้นตอนที่จัดเก็บจะถูกกำหนดขอบเขตต่อคอลเลคชันดังนั้นเราจะต้องใช้ SelfLink ของคอลเล็กชันเพื่อสร้างกระบวนงานที่จัดเก็บ

Step 5 - คำถามแรกสำหรับไฟล์ myfirstdb ฐานข้อมูลแล้วสำหรับไฟล์ MyCollection คอลเลกชัน

การสร้างกระบวนงานที่จัดเก็บก็เหมือนกับการสร้างทรัพยากรอื่น ๆ ใน DocumentDB

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

Step 6 - ขั้นแรกให้สร้างออบเจ็กต์คำจำกัดความด้วย Id สำหรับทรัพยากรใหม่จากนั้นเรียกใช้เมธอด Create บนไฟล์ DocumentClientวัตถุ. ในกรณีของกระบวนงานที่เก็บไว้คำจำกัดความจะรวมถึง Id และรหัส JavaScript จริงที่คุณต้องการส่งไปยังเซิร์ฟเวอร์

Step 7 - โทร File.ReadAllText เพื่อแยกรหัสโพรซีเดอร์ที่เก็บไว้ออกจากไฟล์ JS

Step 8 - กำหนดรหัสโพรซีเดอร์ที่เก็บไว้ให้กับคุณสมบัติร่างกายของอ็อบเจ็กต์นิยาม

เท่าที่เกี่ยวข้องกับ DocumentDB Id ที่เราระบุในคำจำกัดความที่นี่คือชื่อของกระบวนงานที่เก็บไว้ไม่ว่าเราจะตั้งชื่อฟังก์ชัน JavaScript ก็ตาม

อย่างไรก็ตามเมื่อสร้างโพรซีเดอร์ที่เก็บไว้และอ็อบเจ็กต์ฝั่งเซิร์ฟเวอร์อื่น ๆ ขอแนะนำให้เราตั้งชื่อฟังก์ชัน JavaScript และชื่อฟังก์ชันเหล่านั้นตรงกับ Id ที่เราตั้งไว้ในนิยามสำหรับ DocumentDB

Step 9 - โทร CreateStoredProcedureAsyncผ่านใน SelfLink สำหรับ MyCollectionการรวบรวมและการกำหนดขั้นตอนการจัดเก็บ สิ่งนี้จะสร้างกระบวนงานที่เก็บไว้และResourceId DocumentDB ที่กำหนดให้

Step 10 - เรียกขั้นตอนที่เก็บไว้ ExecuteStoredProcedureAsyncรับพารามิเตอร์ type ที่คุณตั้งค่าเป็นชนิดข้อมูลที่คาดไว้ของค่าที่ส่งคืนโดยโพรซีเดอร์ที่เก็บไว้ซึ่งคุณสามารถระบุเป็นอ็อบเจ็กต์หากคุณต้องการให้อ็อบเจ็กต์ไดนามิกส่งคืน นั่นคือออบเจ็กต์ที่คุณสมบัติจะถูกผูกไว้ที่รันไทม์

ในตัวอย่างนี้เรารู้ว่าขั้นตอนการจัดเก็บของเราเป็นเพียงการส่งคืนสตริงดังนั้นเราจึงเรียก ExecuteStoredProcedureAsync<string>.

ต่อไปนี้คือการนำไฟล์ Program.cs ไปใช้งานอย่างสมบูรณ์

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

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

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

เมื่อดำเนินการโค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้

Created stored procedure HelloWorldStoreProce (Ic8LAMEUVgACAAAAAAAAgA==)

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

ดังที่เห็นในผลลัพธ์ด้านบนคุณสมบัติการตอบกลับมีคำว่า“ สวัสดีและยินดีต้อนรับสู่ DocumentDB!” ส่งคืนโดยขั้นตอนการจัดเก็บของเรา

DocumentDB SQL ให้การสนับสนุนสำหรับ User-Defined Functions (UDFs) UDF เป็นเพียงฟังก์ชัน JavaScript อีกประเภทหนึ่งที่คุณสามารถเขียนได้และสิ่งเหล่านี้ทำงานได้ดีอย่างที่คุณคาดหวัง คุณสามารถสร้าง UDF เพื่อขยายภาษาแบบสอบถามด้วยตรรกะทางธุรกิจแบบกำหนดเองที่คุณสามารถอ้างอิงในแบบสอบถามของคุณได้

ไวยากรณ์ DocumentDB SQL ถูกขยายเพื่อรองรับตรรกะของแอปพลิเคชันแบบกำหนดเองโดยใช้ UDF เหล่านี้ สามารถลงทะเบียน UDF กับ DocumentDB จากนั้นอ้างอิงเป็นส่วนหนึ่งของแบบสอบถาม SQL

ลองพิจารณาเอกสารสามชุดต่อไปนี้สำหรับตัวอย่างนี้

AndersenFamily เอกสารมีดังนี้

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

SmithFamily เอกสารมีดังนี้

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

WakefieldFamily เอกสารมีดังนี้

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

มาดูตัวอย่างที่เราจะสร้าง UDF แบบง่ายๆ

ต่อไปนี้คือการใช้งาน CreateUserDefinedFunctions.

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

เรามี udfRegEx และใน CreateUserDefinedFunction เราได้รับรหัส JavaScript จากไฟล์ในเครื่องของเรา เราสร้างอ็อบเจ็กต์นิยามสำหรับ UDF ใหม่และเรียก CreateUserDefinedFunctionAsync ด้วย SelfLink ของคอลเลคชันและอ็อบเจ็กต์ udfDefinition ดังแสดงในโค้ดต่อไปนี้

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

เราได้รับ UDF ใหม่คืนจากคุณสมบัติทรัพยากรของผลลัพธ์และส่งคืนกลับไปยังผู้เรียก ในการแสดง UDF ที่มีอยู่ต่อไปนี้คือการนำไปใช้ViewUserDefinedFunctions. เราโทรCreateUserDefinedFunctionQuery และวนซ้ำตามปกติ

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

DocumentDB SQL ไม่มีฟังก์ชันในตัวเพื่อค้นหาสตริงย่อยหรือสำหรับนิพจน์ทั่วไปด้วยเหตุนี้หนึ่งซับเล็ก ๆ ต่อไปนี้จึงเติมช่องว่างซึ่งเป็นฟังก์ชัน JavaScript

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

กำหนดสตริงอินพุตในพารามิเตอร์แรกให้ใช้การสนับสนุนนิพจน์ทั่วไปในตัวของ JavaScript ที่ส่งผ่านสตริงการจับคู่รูปแบบในพารามิเตอร์ที่สองเข้าไปmatch. เราสามารถเรียกใช้แบบสอบถามสตริงย่อยเพื่อค้นหาร้านค้าทั้งหมดที่มีคำว่า Andersen อยู่ในไฟล์lastName ทรัพย์สิน.

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

โปรดทราบว่าเราต้องมีคุณสมบัติตามการอ้างอิง UDF ทุกรายการที่มีคำนำหน้า udf. เราเพิ่งส่ง SQL ไปให้CreateDocumentQueryเช่นเดียวกับข้อความค้นหาทั่วไป ในที่สุดเราจะเรียกคำถามข้างต้นจากไฟล์CreateDocumentClient งาน

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

เมื่อดำเนินการโค้ดด้านบนจะสร้างผลลัพธ์ต่อไปนี้

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

Composite Queryช่วยให้คุณสามารถรวมข้อมูลจากการสืบค้นที่มีอยู่แล้วใช้ตัวกรองการรวมและอื่น ๆ ก่อนที่จะนำเสนอผลลัพธ์ของรายงานซึ่งจะแสดงชุดข้อมูลที่รวมกัน แบบสอบถามแบบผสมจะดึงข้อมูลที่เกี่ยวข้องหลายระดับในการสืบค้นที่มีอยู่และนำเสนอข้อมูลที่รวมกันเป็นผลการสืบค้นเดียวและแบบแบน

เมื่อใช้แบบสอบถามแบบผสมคุณยังมีตัวเลือกในการ -

  • เลือกตัวเลือกการตัด SQL เพื่อลบตารางและฟิลด์ที่ไม่ต้องการโดยอิงตามการเลือกแอตทริบิวต์ของผู้ใช้

  • ตั้งค่าคำสั่ง ORDER BY และ GROUP BY

  • ตั้งค่าคำสั่ง WHERE เป็นตัวกรองเหนือชุดผลลัพธ์ของแบบสอบถามแบบผสม

ตัวดำเนินการข้างต้นสามารถประกอบขึ้นเพื่อสร้างแบบสอบถามที่มีประสิทธิภาพมากขึ้น เนื่องจาก DocumentDB สนับสนุนคอลเลกชันที่ซ้อนกันองค์ประกอบจึงสามารถเชื่อมต่อกันหรือซ้อนกันได้

ลองพิจารณาเอกสารต่อไปนี้สำหรับตัวอย่างนี้

AndersenFamily เอกสารมีดังนี้

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

SmithFamily เอกสารมีดังนี้

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

WakefieldFamily เอกสารมีดังนี้

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

มาดูตัวอย่างของการสืบค้นที่ต่อกัน

ต่อไปนี้เป็นแบบสอบถามที่จะดึงรหัสและที่ตั้งของครอบครัวที่ลูกคนแรก givenName คือมิเชล

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ลองพิจารณาอีกตัวอย่างหนึ่งของข้อความค้นหาแบบเรียงต่อกัน

ต่อไปนี้คือคำค้นหาที่จะส่งคืนเอกสารทั้งหมดที่เด็กคนแรกเกรดมากกว่า 3

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

[ 
   { 
      "id": "WakefieldFamily", 
      "parents": [ 
         { 
            "familyName": "Wakefield", 
            "givenName": "Robin" 
         },
		
         { 
            "familyName": "Miller", 
            "givenName": "Ben"
         } 
      ],
	  
      "children": [ 
         { 
            "familyName": "Merriam", 
            "givenName": "Jesse", 
            "gender": "female", 
            "grade": 6,
				
            "pets": [ 
               { 
                  "givenName": "Charlie Brown", 
                  "type": "Dog" 
               },
				
               { 
                  "givenName": "Tiger", 
                  "type": "Cat" 
               },
				
               { 
                  "givenName": "Princess", 
                  "type": "Cat" 
               } 
            ] 
         }, 
			
         { 
            "familyName": "Miller", 
            "givenName": "Lisa", 
            "gender": "female", 
            "grade": 3,
				
            "pets": [ 
               { 
                  "givenName": "Jake", 
                  "type": "Snake" 
               } 
            ] 
         } 
      ],
	  
      "location": { 
         "state": "NY", 
         "county": "Manhattan",
         "city": "NY" 
      },
	  
      "isRegistered": false, 
      "_rid": "Ic8LAJFujgECAAAAAAAAAA==", 
      "_ts": 1450541623, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgECAAAAAAAAAA==/", 
      "_etag": "\"00000500-0000-0000-0000-567582370000\"", 
      "_attachments": "attachments/" 
   },
	
   { 
      "id": "AndersenFamily", 
      "lastName": "Andersen",
		
      "parents": [ 
         { 
            "firstName": "Thomas", 
            "relationship": "father" 
         },
			
         { 
            "firstName": "Mary Kay", 
            "relationship": "mother" 
         } 
      ],
	  
      "children": [ 
         { 
            "firstName": "Henriette Thaulow", 
            "gender": "female", 
            "grade": 5,
				
            "pets": [ 
               { 
                  "givenName": "Fluffy", 
                  "type": "Rabbit" 
               } 
            ] 
         } 
      ],
	  
      "location": { 
         "state": "WA", 
         "county": "King", 
         "city": "Seattle"
      },
   
      "isRegistered": true, 
      "_rid": "Ic8LAJFujgEEAAAAAAAAAA==", 
      "_ts": 1450541624, 
      "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/", 
      "_etag": "\"00000700-0000-0000-0000-567582380000\"", 
      "_attachments": "attachments/" 
   } 
]

ลองมาดูไฟล์ example ของแบบสอบถามที่ซ้อนกัน

ต่อไปนี้เป็นแบบสอบถามที่จะย้ำผู้ปกครองทั้งหมดแล้วส่งคืนเอกสารที่ familyName คือ Smith

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ต่อไปนี้

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

ลองพิจารณาดู another example ของแบบสอบถามที่ซ้อนกัน

ต่อไปนี้คือแบบสอบถามที่จะส่งคืนไฟล์ familyName.

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

เมื่อดำเนินการค้นหาข้างต้นจะสร้างผลลัพธ์ตามมา

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