9 ประเภทของ Mongodb Operators ที่คุณต้องรู้

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

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

บทความนี้จะให้ความกระจ่างเกี่ยวกับตัวดำเนินการที่ใช้ในซอฟต์แวร์ฐานข้อมูล MongoDB

ตัวดำเนินการ MongoDB คืออะไร?

MongoDB เป็นซอฟต์แวร์ฐานข้อมูล NoSQL ที่จัดการข้อมูลเชิงเอกสาร

หนึ่งในคุณสมบัติหลักของ MongoDB คือความเร็ว ในการส่งคืนแบบสอบถามเร็วขึ้น MongoDB อาจใช้ตัวดำเนินการเพื่อทำหน้าที่เฉพาะ

ตัวดำเนินการเป็นสัญลักษณ์พิเศษที่ช่วยให้คอมไพเลอร์ทำงานทางคณิตศาสตร์หรือตรรกะ MongoDB มีโอเปอเรเตอร์หลายประเภทในการโต้ตอบกับฐานข้อมูล

ประเภทตัวดำเนินการ MongoDB

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

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

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

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

ด้านล่างนี้คือตัวดำเนินการเชิงตรรกะบางส่วนที่คุณสามารถใช้ได้:

$และ

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

นี่คือไวยากรณ์มาตรฐานสำหรับ $and นิพจน์:

 { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } ตัวอย่างเช่น หากเราต้องการเลือกเอกสารที่มีราคา $10 และปริมาณน้อยกว่า 15 เราสามารถป้อนแบบสอบถามต่อไปนี้:

 db.inventory.find( { $and: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

$หรือ

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

นี่คือไวยากรณ์มาตรฐานสำหรับนิพจน์ $or :

 { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }.

ตัวอย่างเช่น ถ้าเราต้องการเลือกเอกสารที่มีราคา $10 หรือปริมาณน้อยกว่า 15 เราสามารถป้อนแบบสอบถามต่อไปนี้:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 } ] } )

เราไม่จำเป็นต้องจำกัดนิพจน์ให้เหลือเพียงสองเกณฑ์ — เราสามารถเพิ่มได้อีก ตัวอย่างเช่น แบบสอบถามด้านล่างจะเลือกเอกสารที่ราคาเท่ากับ $10 ปริมาณต่ำกว่า 15 หรือแท็กอยู่กับที่:

 db.inventory.find( { $or: [ { quantity: { $lt: 15 } }, { price: 10 }, { tag: stationary }] } )

เมื่อรันส่วนคำสั่งเหล่านี้ MongoDB จะทำการสแกนคอลเลกชั่นหรือการสแกนดัชนี หากดัชนีทั้งหมดรองรับอนุประโยค MongoDB จะใช้ดัชนีเพื่อตรวจสอบ $or นิพจน์ มิเช่นนั้นจะใช้การสแกนคอลเลคชันแทน

แต่ถ้าคุณต้องการทดสอบเกณฑ์ในฟิลด์เดียวกัน คุณอาจต้องการใช้ตัวดำเนินการ $in แทนตัวดำเนินการ $or ตัวอย่างเช่น ถ้าคุณต้องการคอลเลกชันของเอกสารที่มีปริมาณเป็น 10 หรือ 20 คุณอาจต้องเรียกใช้แบบสอบถาม $in ด้านล่างแทน:

 db.inventory.find ( { quantity: { $in: [20, 50] } } )

เราจะอธิบายเพิ่มเติมเกี่ยวกับตัวดำเนินการ $in ภายหลัง

$หรือ

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

นี่คือไวยากรณ์ทั่วไป:

 { $nor: [ { <expression1> }, { <expression2> }, ... { <expressionN> } ] }

ลองพิจารณาแบบสอบถามต่อไปนี้:

 db.inventory.find( { $nor: [ { price: 3.99 }, { sale: true } ] } )

แบบสอบถามนี้เลือกเอกสารที่มี:

• ค่าฟิลด์ราคาไม่เท่ากับ $3.99 และมูลค่าการขายไม่เท่ากับจริง หรือ
• ค่าฟิลด์ราคาไม่เท่ากับ $3.99 และฟิลด์การขายที่ว่างเปล่าหรือไม่มีอยู่ หรือ
• ไม่มีช่องราคา และช่องขายไม่เท่ากับจริง หรือ
• ฟิลด์ราคาหรือฟิลด์การขายไม่ได้เติมหรือแสดง

$ไม่

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

นี่คือไวยากรณ์ทั่วไป:

 { field: { $not: { <operator-expression> } } }

ตัวอย่างเช่น ใช้แบบสอบถามต่อไปนี้:

 db.inventory.find( { price: { $not: { $lt: 3.99 } } } )

แบบสอบถามนี้จะเลือกเอกสารที่มี:

• ฟิลด์ราคาที่มีค่ามากกว่าหรือเท่ากับ $3.99; และ
• ฟิลด์ราคาจะไม่มีการเติมหรือไม่มีอยู่

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

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

ด้านล่างนี้คือตัวอย่างโค้ดของการรวบรวมสินค้าคงคลังอย่างง่ายสำหรับร้านซุปเปอร์มาร์เก็ต:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

เราจะใช้ตัวอย่างนี้ในขณะที่ให้รายละเอียดตัวดำเนินการเปรียบเทียบแต่ละตัวในลำดับต่อไป

เท่ากับ ($eq)

ตัวดำเนินการนี้ตรงกับค่าที่เท่ากับค่าที่กำหนด:

 { <field>: { $eq: <value> } }

ตัวอย่างเช่น หากเราต้องการดึงเอกสารเฉพาะจากคอลเลกชันสินค้าคงคลังที่มีค่าปริมาณที่แน่นอน "20" เราจะป้อนคำสั่งต่อไปนี้:

 db.inventory.find( { qty: { $eq: 20 } } )

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

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

มากกว่า ($gt)

โอเปอเรเตอร์นี้จับคู่ถ้าค่ามากกว่าค่าที่กำหนด:

 { field: { $gt: value } }

ในตัวอย่างนี้ เราเรียกเอกสารที่มีปริมาณมากกว่า 15:

 db.inventory.find({"qty": { $gt: 15}})

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

 { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

น้อยกว่า ($lt)

โอเปอเรเตอร์นี้จับคู่ถ้าค่าน้อยกว่าค่าที่ระบุ:

 { field: { $lt: value } }

มาหาเอกสารที่มีจำนวนน้อยกว่า 25:

 db.inventory.find({"qty": { $lt: 25}})

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

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

มากกว่าหรือเท่ากับ ($gte)

โอเปอเรเตอร์นี้จับคู่เมื่อค่ามากกว่าหรือเท่ากับค่าที่กำหนด:

 { field: { $gte: value } }

ในตัวอย่างนี้ เราเรียกเอกสารที่มีปริมาณมากกว่าหรือเท่ากับ 25:

 db.inventory.find({"qty": { $gte: 25}})

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

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

น้อยกว่าหรือเท่ากับ ($lte)

โอเปอเรเตอร์นี้จับคู่เฉพาะเมื่อค่าน้อยกว่าหรือเท่ากับค่าที่กำหนด:

 { field: { $lte: value } }

ให้หาเอกสารที่มีปริมาณน้อยกว่าหรือเท่ากับ 25 กัน

 db.inventory.find({"qty": { $lte: 25}})

เราสามารถคาดหวังให้ข้อความค้นหานี้ส่งคืนสิ่งต่อไปนี้:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }

ใน ($ใน)

โอเปอเรเตอร์นี้ส่งคืนเอกสารที่ตรงกับค่าที่ระบุ:

 { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

ค่าของฟิลด์เท่ากับค่าใดๆ ในอาร์เรย์ที่ระบุ ในการดึงเอกสารที่มีค่า “30” และ “15” ในคอลเลกชันสินค้าคงคลัง ให้ทำดังนี้:

 db.collection.find({ "qty": { $in: [30, 15]}})

ผลลัพธ์จะเป็น:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }

ไม่อยู่ใน ($nin)

โอเปอเรเตอร์นี้ส่งคืนเอกสารที่ไม่ตรงกับค่าที่กำหนด นี่คือไวยากรณ์พื้นฐานของตัวดำเนินการ $nin :

 { field: { $nin: [ <value1>, <value2> ... <valueN> ]

$nin เลือกเอกสารที่:

• ค่าฟิลด์ไม่อยู่ในอาร์เรย์ที่ระบุ หรือ
• ไม่มีฟิลด์นี้

หากฟิลด์มีอาร์เรย์ ฟิลด์จะเลือกอาร์เรย์ที่ไม่มีองค์ประกอบที่ระบุในส่วนค่า ตัวอย่างเช่น เราต้องการเลือกเอกสารที่มีปริมาณไม่เท่ากับ 20 หรือ 15

นอกจากนี้ ยังจับคู่เอกสารที่ไม่มีฟิลด์ปริมาณ:

 db.collection.find({ "qty": { $nin: [ 20, 15 ]}}, {_id: 0})

ผลลัพธ์จะเป็น:

 { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

ไม่เท่ากัน ($ne)

ตัวดำเนินการ $ne ส่งคืนเอกสารที่ค่าที่ระบุไม่เท่ากัน:

 { $ne: value } }

ตัวอย่างเช่น สมมติว่าเราต้องการเลือกเอกสารทั้งหมดที่มีปริมาณไม่เท่ากับ 20:

 db.inventory.find( { qty: { $ne: 20 } } )

ผลลัพธ์จะเป็น:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] } { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] } { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] } { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

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

ตัวดำเนินการองค์ประกอบ

ตัวดำเนินการแบบสอบถามองค์ประกอบสามารถระบุเอกสารโดยใช้ฟิลด์ของเอกสาร ตัวดำเนินการองค์ประกอบประกอบด้วย $exist และ $type

$exists

ตัวดำเนินการนี้ตรงกับเอกสารที่มีฟิลด์ที่ระบุ โอเปอเรเตอร์นี้มีค่าบูลีนที่สามารถเป็น true หรือ false

หากระบุว่าเป็น true จะตรงกับเอกสารที่มีฟิลด์นั้น รวมถึงเอกสารที่ค่าฟิลด์เป็น null หาก <boolean> เป็น false เคียวรีจะส่งกลับเฉพาะเอกสารที่ไม่มีฟิลด์

นี่คือไวยากรณ์มาตรฐาน:

 { field: { $exists: <boolean> } }

มาดูตัวอย่างที่เราได้รวบรวมข้อมูลสำหรับอาร์เรย์ชื่อ “bagofmarbles” โดยที่ถุงแต่ละใบมีลายหินอ่อนสีต่างกัน:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 } { green: 2, blue: 4 } { green: 2 } { blue: 6 }

สมมติว่าเราต้องการคำค้นหาที่จะส่งคืนเฉพาะถุงที่มีลูกหินสีแดงเท่านั้น ซึ่งหมายความว่าเราต้องป้อนค่าบูลีนเป็น true ลองดู:

 db.bagofmarbles.find( { red: { $exists: true } } )

ผลลัพธ์จะประกอบด้วยเอกสารที่มีฟิลด์ "สีแดง" แม้ว่าค่าจะเป็น null อย่างไรก็ตาม จะไม่ประกอบด้วยเอกสารที่ไม่มีฟิลด์ "สีแดง" ด้วยซ้ำ:

 { red: 5, green: 5, blue: null } { red: 3, green: null, blue: 8 } { red: null, green: 3, blue: 9 } { red: 1, green: 2, blue: 3 } { red: 2, blue: 5 } { red: 3, green: 2 } { red: 4 }

หากเราต้องการเพียงกระเป๋าที่ไม่มีลูกหินสีแดงเป็นฟิลด์ เราสามารถป้อนแบบสอบถามด้านล่าง:

 db.bagofmarbles.find( { red: { $exists: false} }

ผลลัพธ์จะประกอบด้วยเอกสารเหล่านั้นที่ไม่มีฟิลด์ "สีแดง":

 { green: 2, blue: 4 } { green: 2 } { blue: 6 }

$type

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

นี่คือไวยากรณ์ทั่วไปสำหรับ $type :

 { field: { $type: <BSON type> } }

สมมติว่าเรามีสมุดที่อยู่ซึ่งมีเอกสารดังต่อไปนี้:

 db={ addressBook: [ { "_id": 1, address: "2100 Jupiter Spot", zipCode: "9036325" }, { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) }, { "_id": 5, address: "1044 Venus Lane", zipCode: [ "99883637232", "73488976234" ] } ] }

จากการดูเอกสารข้างต้น รหัสไปรษณีย์มีประเภทข้อมูลต่างกัน ซึ่งรวมถึงค่ายาว คู่ จำนวนเต็ม และสตริง

หากเราต้องการเฉพาะเอกสารที่มีประเภทข้อมูลที่ระบุเป็นรหัสไปรษณีย์ — ลองใช้สตริงสำหรับอินสแตนซ์นี้ — เราต้องป้อนข้อความค้นหาต่อไปนี้ในคอมไพเลอร์:

 db.addressBook.find({ "zipCode": { $type: "string" } })

ซึ่งจะส่งคืนเอกสารต่อไปนี้:

 [ { "_id": 1, "address": "2100 Jupiter Spot", "zipCode": "9036325" }, { "_id": 5, "address": "1044 Venus Lane", "zipCode": [ "99883637232", "73488976234" ] } ]

นอกจากนี้ยังมีประเภท "ตัวเลข" ซึ่งรวมถึงค่ายาว จำนวนเต็ม หรือคู่ทั้งหมดเป็นอาร์เรย์ที่มีองค์ประกอบของประเภทที่ระบุ:

 db.addressBook.find( { "zipCode" : { $type : "number" } } )

เอาท์พุท:

 [ { "_id": 2, address: "25 Moon Place", zipCode: 26237 }, { "_id": 3, address: "2324 Neptune Ring", zipCode: NumberLong(77622222) }, { "_id": 4, address: "33 Saturns Moon", zipCode: NumberInt(117) } ]

หากเอกสารมีประเภทฟิลด์อาร์เรย์ ตัวดำเนินการ $type จะส่งกลับเอกสารที่มีองค์ประกอบอาร์เรย์อย่างน้อยหนึ่งรายการตรงกับประเภทที่ส่งผ่านไปยังโอเปอเรเตอร์

ตัวดำเนินการอาร์เรย์

MongoDB ยังประกอบด้วยตัวดำเนินการอาร์เรย์ เพื่อสืบค้นเอกสารที่มีอาร์เรย์

มีโอเปอเรเตอร์หลักสามตัว: $all , $elemMatch และ $size เราจะพูดถึงรายละเอียดแต่ละรายการด้านล่าง

$all

ตัวดำเนินการ $all จะเลือกเอกสารที่ค่าของฟิลด์เป็นอาร์เรย์ที่มีองค์ประกอบที่ระบุ:

 { : { $all: [ <value1> , <value2> ... ] } }

ตัวอย่างเช่น สมมติว่าเรามีชุดเอกสารสำหรับร้านขายเสื้อผ้า โดยมีรายการต่อไปนี้อยู่ในคลัง

 { _id: ObjectId("5234cc89687ea597eabee675"), code: "shirt", tags: [ "sale", "shirt", "button", "y2k", "casual" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 45, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] }, { _id: ObjectId("5234ccb7687ea597eabee677"), code: "pant2", tags: [ "trendy", "shine" ], qty: [ { size: "S", num: 10, color: "blue" }, { size: "M", num: 100, color: "blue" }, { size: "L", num: 100, color: "green" } ] }, { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

เราต้องการดึงเอกสารใดๆ (ในกรณีนี้คือเสื้อผ้า) จากสินค้าคงคลังที่เชื่อมโยงกับแท็ก "ทันสมัย" และ "y2k" แบบสอบถามด้านล่างใช้ตัวดำเนินการ $all โดยที่ค่าของฟิลด์แท็กคืออาร์เรย์ที่มีองค์ประกอบ "y2k" และ "ทันสมัย":

 db.inventory.find( { tags: { $all: [ "y2k", "trendy" ] } } )

แบบสอบถามด้านบนส่งกลับค่าต่อไปนี้:

 { _id: ObjectId("5234cc8a687ea597eabee676"), code: "pant", tags: [ "y2k", "trendy", "shine" ], qty: [ { size: "6", num: 100, color: "green" }, { size: "6", num: 50, color: "blue" }, { size: "8", num: 100, color: "brown" } ] } { _id: ObjectId("52350353b2eff1353b349de9"), code: "shirt2", tags: [ "y2k", "trendy" ], qty: [ { size: "M", num: 100, color: "green" } ] }

จากตัวอย่างข้างต้น เรายังพบว่าตัวดำเนินการ $all ทำหน้าที่เดียวกับ $and การดำเนินการ

อีกทางหนึ่ง เราสามารถใช้แบบสอบถามด้านล่างซึ่งจะให้ผลลัพธ์ที่คล้ายคลึงกันกับด้านบน:

 db.collection.find({ $and: [ { tags: "y2k" }, { tags: "trendy" } ] })

$elemMatch

ตัวดำเนินการ $elemMatch จับคู่เอกสารที่มีเขตข้อมูลอาร์เรย์ที่มีองค์ประกอบอย่างน้อยหนึ่งองค์ประกอบที่ตรงกับเกณฑ์การสืบค้นที่ระบุทั้งหมด:

 { : { $elemMatch: { <query1>, <query2>, ... } } }

แม้ว่าเราอาจใช้ตัวดำเนินการเปรียบเทียบ เช่น $lte และ $gte หากเราระบุเงื่อนไขการสืบค้นเพียงเงื่อนไขเดียวภายใน $elemMatch และไม่ได้ใช้ตัวดำเนินการ $not หรือ $ne การใช้ $elemMatch สามารถละเว้นได้เนื่องจากการทำงานเป็นหลัก ฟังก์ชั่นเดียวกัน

มีอีกสองสามสิ่งที่ควรคำนึงถึงในขณะที่ใช้โอเปอเรเตอร์นี้ ส่วนใหญ่:

• คุณไม่สามารถระบุนิพจน์ $ $where ในการดำเนินการ $elemMatch
• คุณไม่สามารถระบุนิพจน์คิวรี $ $text ในการดำเนินการ $elemMatch

ตัวอย่างเช่น เรามีเอกสารต่อไปนี้ในคอลเล็กชันผลการเรียนของนักเรียน:

 { _id: 1, results: [ 92, 89, 98 ] } { _id: 2, results: [ 85, 99, 99 ] }

แบบสอบถามต่อไปนี้จะจับคู่เฉพาะเอกสารที่อาร์เรย์ผลลัพธ์มีอย่างน้อยหนึ่งองค์ประกอบที่มากกว่าหรือเท่ากับ 90 และน้อยกว่า 95:

 db.studentresults.find( { results: { $elemMatch: { $gte: 90, $lt: 95 } } })

แบบสอบถามของเราส่งคืนเอกสารต่อไปนี้ เนื่องจากองค์ประกอบ 92 มากกว่าหรือเท่ากับ 90 และน้อยกว่า 95:

 { "_id" : 1, "results" :[ 92, 89, 98 ] }

$ขนาด

ตัวดำเนินการ $size ส่งคืนเอกสารเหล่านั้นโดยที่ขนาดของอาร์เรย์ตรงกับจำนวนขององค์ประกอบที่ระบุในอาร์กิวเมนต์:

 { field: { $size: value } }

นี่คือตัวอย่าง:

 db.collection.find( { field: { $size: 2 } });

สิ่งนี้จะส่งคืนเอกสารทั้งหมดในคอลเล็กชันที่ระบุโดยที่ฟิลด์นั้นเป็นอาร์เรย์ที่มี 2 องค์ประกอบ: { field: [ orange, apple] } และ { field: [ blue, red] } แต่ไม่ใช่ { field: blue} หรือ { field: [ raspberry, lemon, grapefruit ] } .

อย่างไรก็ตาม แม้ว่าเราจะป้อนค่าเฉพาะเป็นขนาดได้ แต่เราไม่สามารถระบุช่วงของค่าเป็นขนาดได้

ตัวดำเนินการเชิงพื้นที่

MongoDB ช่วยให้คุณสามารถจัดเก็บข้อมูลเชิงพื้นที่ในรูปแบบของประเภท GeoJSON GeoJSON เป็นรูปแบบมาตรฐานเปิดโดยยึดตามสัญกรณ์วัตถุ JavaScript ที่สามารถแสดงคุณลักษณะทางภูมิศาสตร์และสนับสนุนแอตทริบิวต์ที่ไม่ใช่เชิงพื้นที่ ตัวดำเนินการเชิงพื้นที่มีสองประเภทที่เราจะพูดถึงในบทความนี้: ตัวระบุเรขาคณิตและตัวเลือกแบบสอบถาม

$เรขาคณิต

โอเปอเรเตอร์นี้กล่าวถึงเรขาคณิต GeoJSON สำหรับใช้กับโอเปอเรเตอร์การค้นหาเชิงพื้นที่ต่อไปนี้: $geoIntersects , $geoWithin , $nearSphere และ $near $geometry ใช้ประโยชน์จาก EPSG:4326 เป็นระบบอ้างอิงพิกัดเริ่มต้น (CRS)

หากต้องการพูดถึงวัตถุ GeoJSON ด้วย CRS เริ่มต้น คุณสามารถใช้ประโยชน์จากข้อมูลโค้ดต่อไปนี้สำหรับ $geometry :

 $geometry: { type: "<GeoJSON object type>", coordinates: [ <coordinates> ] }

หากต้องการพูดถึงรูปหลายเหลี่ยม GeoJSON วงแหวนเดียวที่มี MongoDB CRS ที่ปรับแต่ง คุณสามารถใช้ตัวอย่างต่อไปนี้ (คุณสามารถใช้สิ่งนี้สำหรับ $geoWithin และ $geoIntersects ):

 $geometry: { type: "Polygon", coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } }

$รูปหลายเหลี่ยม

สามารถใช้ตัวดำเนินการ $polygon เพื่อระบุรูปหลายเหลี่ยมสำหรับการสืบค้น geospatial $geoWithin บนคู่พิกัดดั้งเดิม แบบสอบถามนี้จะส่งกลับคู่ที่อยู่ในขอบเขตของรูปหลายเหลี่ยม อย่างไรก็ตาม $polygon จะไม่ค้นหาวัตถุ GeoJSON ใดๆ ในการกำหนดรูปหลายเหลี่ยม คุณต้องระบุอาร์เรย์ของจุดพิกัดดังนี้:

 { : { $geoWithin: { $polygon: [ [ <x1> , <y1> ], [ <x2> , <y2> ], [ <x3> , <y3> ], ... ] } } }

ที่นี่จุดสุดท้ายเชื่อมต่อกับจุดแรกโดยปริยาย คุณสามารถพูดถึงจุดหรือด้านได้มากเท่าที่คุณต้องการ

ตัวอย่างเช่น เคียวรีต่อไปนี้จะส่งคืนเอกสารทั้งหมดที่มีพิกัดอยู่ภายในรูปหลายเหลี่ยมที่กำหนดโดย [0,0], [1,5] และ [3,3]:

 db.places.find( { loc: { $geoWithin: { $polygon: [ [ 0 , 0 ], [ 1 , 5 ], [ 3 , 3 ] ] } } } )

$geoWithin

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

ตัวดำเนินการ $geoWithin จะใช้ประโยชน์จากตัวดำเนินการ $geometry เพื่อกล่าวถึงวัตถุ GeoJSON

หากต้องการพูดถึงหลายเหลี่ยม GeoJSON หรือรูปหลายเหลี่ยมผ่านระบบอ้างอิงพิกัด (CRS) ที่เป็นค่าเริ่มต้น คุณสามารถใช้ไวยากรณ์ที่กล่าวถึงด้านล่าง:

 { : { $geoWithin: { $geometry: { type: <"Polygon" or "MultiPolygon"> , coordinates: [ <coordinates> ] } } } }

สำหรับการสืบค้น $geoWithin ที่กล่าวถึงเรขาคณิต GeoJSON ที่มีพื้นที่ใหญ่กว่าซีกโลกเดียว การใช้ CRS เริ่มต้นจะนำไปสู่การสืบค้นสำหรับเรขาคณิตเสริม

หากต้องการกล่าวถึงรูปหลายเหลี่ยม GeoJSON วงแหวนเดียวที่มี MongoDB CRS ที่กำหนดเอง คุณสามารถใช้ประโยชน์จากต้นแบบที่กล่าวถึงด้านล่างในนิพจน์ $geometry :

 { : { $geoWithin: { $geometry: { type: "Polygon" , coordinates: [ <coordinates> ], crs: { type: "name", properties: { name: "urn:x-mongodb:crs:strictwinding:EPSG:4326" } } } } } }

ตัวอย่างต่อไปนี้จะเลือกข้อมูล loc ทั้งหมดที่มีอยู่ภายในรูปหลายเหลี่ยม GeoJSON โดยสมบูรณ์ พื้นที่ของรูปหลายเหลี่ยมนั้นน้อยกว่าพื้นที่ของซีกโลกเดียว:

 db.places.find( { loc: { $geoWithin: { $geometry: { type : "Polygon" , coordinates: [ [ [ 0, 0 ], [ 3, 6 ], [ 6, 1 ], [ 0, 0 ] ] ] } } } } )

$box

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

ในการใช้ประโยชน์จากตัวดำเนินการ $box คุณต้องพูดถึงมุมบนขวาและล่างซ้ายของสี่เหลี่ยมในวัตถุอาร์เรย์:

 { <location field> : { $geoWithin: { $box: [ [ <bottom left coordinates> ], [ <upper right coordinates> ] ] } } }

แบบสอบถามดังกล่าวจะคำนวณระยะทางโดยใช้เรขาคณิตระนาบ (แบน) แบบสอบถามต่อไปนี้จะส่งคืนเอกสารทั้งหมดที่อยู่ในกล่องโดยมีจุดที่: [0,0], [0,30], [30,0], [30,30]:

 db.places.find ( { loc: { $geoWithin: { $box: [ [ 0,0 ], [ 30,30 ] ] } } } )

$nearSphere

คุณสามารถใช้ $nearSphere เพื่อพูดถึงจุดที่การสืบค้นข้อมูลเชิงพื้นที่ส่งคืนเอกสารจากใกล้ที่สุดไปหาไกลที่สุด

MongoDB ใช้เรขาคณิตทรงกลมเพื่อคำนวณระยะทางสำหรับ $nearSphere มันจะต้องมีดัชนีเชิงพื้นที่ดังต่อไปนี้:

1. ดัชนี 2d สำหรับข้อมูลตำแหน่งที่อธิบายเป็นคู่พิกัดดั้งเดิม ในการใช้ประโยชน์จากดัชนี 2d บนจุด GeoJSON คุณต้องสร้างดัชนีบนฟิลด์พิกัดของวัตถุ GeoJSON
2. ดัชนี 2dsphere สำหรับข้อมูลตำแหน่งที่อธิบายเป็นคะแนน GeoJSON

หากต้องการพูดถึงจุด GeoJSON คุณสามารถใช้ไวยากรณ์ต่อไปนี้:

 { $nearSphere: { $geometry: { type : "Point", coordinates : [ <longitude>, <latitude> ] }, $minDistance: <distance in meters>, $maxDistance: <distance in meters> } }

ที่นี่ $minDistance และ $maxDistance เป็นทางเลือก $minDistance สามารถจำกัดผลลัพธ์ให้อยู่ในเอกสารที่มีระยะห่างจากศูนย์กลางเป็นอย่างน้อย คุณสามารถใช้ $maxDistance สำหรับดัชนีใดก็ได้

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

 db.places.find( { location: { $nearSphere: { $geometry: { type : "Point", coordinates : [ -43.9532, 50.32 ] }, $minDistance: 2000, $maxDistance: 6000 } } } )

$geoIntersects

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

ในการพูดถึงหลายเหลี่ยม GeoJSON หรือรูปหลายเหลี่ยมผ่านระบบอ้างอิงพิกัดเริ่มต้น (CRS) คุณสามารถใช้ไวยากรณ์ต่อไปนี้:

 { <location field>: { $geoIntersects: { $geometry: { type: "<GeoJSON object type>" , coordinates: [ <coordinates> ] } } } }

อินสแตนซ์ต่อไปนี้จะใช้ $geoIntersects เพื่อเลือกข้อมูล loc ทั้งหมดที่ตัดกับรูปหลายเหลี่ยมที่อธิบายโดยอาร์เรย์พิกัด:

 db.places.find( { loc: { $geoIntersects: { $geometry: { type: "Polygon" , coordinates: [ [ [ 0, 0 ], [ 2, 6 ], [ 4, 1 ], [ 0, 0 ] ] ] } } } } )

$center

ตัวดำเนินการ $center กล่าวถึงวงกลมสำหรับแบบสอบถาม $geoWithin ที่ส่งคืนคู่พิกัดดั้งเดิมที่อยู่ภายในขอบเขตของวงกลม

$center ไม่ส่งคืนวัตถุ GeoJSON ในการใช้ประโยชน์จากตัวดำเนินการ $center คุณต้องระบุอาร์เรย์ที่ประกอบด้วย:

1. รัศมีของวงกลมตามที่วัดในหน่วยที่ใช้โดยระบบพิกัด
2. พิกัดกริดของจุดศูนย์กลางของวงกลม

 { <location field> : { $geoWithin: { $center: [ [ <x> , <y> ] , <radius> ] } } }

ตัวอย่างที่กล่าวถึงด้านล่างจะส่งคืนเอกสารทั้งหมดที่มีพิกัดที่สามารถพบได้ภายในวงกลมที่มีศูนย์กลางที่ [2,3] และมีรัศมี 40:

 db.places.find( { loc: { $geoWithin: { $center: [ [2, 3], 40 ] } } } )

ตัวดำเนินการฉายภาพ

คุณสามารถใช้ตัวดำเนินการฉายภาพเพื่อกล่าวถึงฟิลด์ที่ส่งคืนโดยการดำเนินการ ตัวดำเนินการฉายภาพ MongoDB อนุญาตให้ใช้ฟังก์ชัน find() กับอาร์กิวเมนต์การกรองข้อมูล ซึ่งจะช่วยให้ผู้ใช้ดึงเฉพาะฟิลด์ข้อมูลที่จำเป็นจากเอกสาร ดังนั้นจึงทำให้คุณสามารถฉายข้อมูลที่โปร่งใสและรัดกุมได้โดยไม่กระทบต่อประสิทธิภาพการทำงานของฐานข้อมูลโดยรวม

$elemMatch (การฉายภาพ)

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

นี่คือสิ่งที่คุณต้องจำไว้ก่อนที่จะใช้ $elemMatch :

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

คุณควรทราบถึงข้อจำกัดต่อไปนี้ก่อนที่จะใช้โอเปอเรเตอร์ $elemMatch กับข้อมูลของคุณ:

• คุณไม่สามารถพูดถึงนิพจน์แบบสอบถาม $text ภายในตัวดำเนินการ $elemMatch
• db.collection.find() การดำเนินการกับมุมมองไม่สนับสนุนตัวดำเนินการฉาย $elemMatch

ตัวอย่างต่อไปนี้บนตัวดำเนินการฉายภาพ $elemMatch จะถือว่า schools คอลเลกชันมีเอกสารดังต่อไปนี้:

 { _id: 1, zipcode: "63108", students: [ { name: "mark", school: 102, age: 9 }, { name: "geoff", school: 101, age: 13 }, { name: "frank", school: 104, age: 12 } ] } { _id: 2, zipcode: "63110", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 3, zipcode: "63108", students: [ { name: "harry", school: 103, age: 14 }, { name: "george", school: 103, age: 7 }, ] } { _id: 4, zipcode: "63110", students: [ { name: "jim", school: 103, age: 9 }, { name: "michael", school: 103, age: 12 }, ] }

ในตัวอย่างนี้ การดำเนินการ find() สอบถามเอกสารทั้งหมดที่ค่าของฟิลด์รหัสไปรษณีย์คือ 63110 การฉายภาพ $elemMatch จะส่งกลับเฉพาะองค์ประกอบแรกที่ตรงกันของอาร์เรย์ students โดยที่ฟิลด์ของ school มีค่าเท่ากับ 103:

 db.schools.find( { zipcode: "63110" }, { students: { $elemMatch: { school: 103 } } } ) This is what the result would look like: { "_id" : 2, "students" : [ { "name" : "harry", "school" : 103, "age" : 14 } ] } { "_id" : 4, "students" : [ { "name" : "jim", "school" : 103, "age" : 9 } ] }

$slice (ฉาย)

สามารถใช้ตัวดำเนินการฉายภาพ $slice เพื่อระบุจำนวนองค์ประกอบในอาร์เรย์ที่จะส่งคืนในผลลัพธ์การสืบค้น:

 db.collection.find( <query> , { <arrayField> : { $slice: <number> } } );

นอกจากนี้ยังสามารถแสดงออกดังนี้:

 db.collection.find( <query> , { <arrayField> : { $slice: [ <number> , <number> ] } } );

เพื่อแสดงให้เห็นเช่นเดียวกัน คุณสามารถสร้างชุดตัวอย่างทวีตด้วยเอกสารต่อไปนี้:

 db.posts.insertMany([ { _id: 1, title: "Nuts are not blueberries.", comments: [ { comment: "0. true" }, { comment: "1. blueberries aren't nuts."} ] }, { _id: 2, title: "Coffee please.", comments: [ { comment: "0. Indubitably" }, { comment: "1. Cuppa tea please" }, { comment: "2. frappucino" }, { comment: "3. Mocha latte" }, { comment: "4. whatever" } ] } ])

การดำเนินการต่อไปนี้จะใช้ตัวดำเนินการฉายภาพ $slice บนอาร์เรย์ tweets เพื่อส่งคืนอาร์เรย์ด้วยสององค์ประกอบแรก หากอาร์เรย์มีองค์ประกอบน้อยกว่าสององค์ประกอบ ส่วนประกอบทั้งหมดในอาร์เรย์จะถูกส่งกลับ:

 db.posts.find( {}, { comments: { $slice: 2 } } )

การดำเนินการนั้นจะส่งคืนเอกสารต่อไปนี้:

 { "_id" : 1, "title" : "Nuts are not blueberries.", "comments" : [ { "comment" : "0. true" }, { "comment" : "1. blueberries aren't nuts." } ] } { "_id" : 2, "title" : "Coffee please.", "comments" : [ { "comment" : "0. Indubitably" }, { "comment" : "1. Cuppa tea please" } ] }

$ (ฉาย)

ตัวดำเนินการตำแหน่ง $ จำกัดเนื้อหาของอาร์เรย์เพื่อส่งคืนองค์ประกอบแรกที่ตรงกับเงื่อนไขการสืบค้นของอาร์เรย์นั้น คุณสามารถใช้ $ ในเอกสารการฉายภาพของเมธอด find() หรือเมธอด findOne() เมื่อคุณต้องการเพียงหนึ่งองค์ประกอบอาร์เรย์เฉพาะในเอกสารที่เลือก

นี่คือสิ่งที่ไวยากรณ์สำหรับตัวดำเนินการ $ ดูเหมือน:

 db.collection.find( { <array>: <condition> ... }, { "<array>.$": 1 } ) db.collection.find( { <array.field>: <condition> ...}, { "<array>.$": 1 } )

ในตัวอย่างนี้ คอลเล็กชันของ students ประกอบด้วยเอกสารต่อไปนี้:

 { "_id" : 1, "semester" : 2, "grades" : [ 75, 67, 93 ] } { "_id" : 2, "semester" : 2, "grades" : [ 60, 68, 72 ] } { "_id" : 3, "semester" : 2, "grades" : [ 95, 82, 67 ] } { "_id" : 4, "semester" : 3, "grades" : [ 89, 95, 70 ] } { "_id" : 5, "semester" : 3, "grades" : [ 68, 98, 82 ] } { "_id" : 6, "semester" : 3, "grades" : [ 65, 70, 76 ] }

ในแบบสอบถามต่อไปนี้ การฉายภาพ { "grades.$": 1 } จะส่งกลับเฉพาะองค์ประกอบแรกที่มากกว่าหรือเท่ากับ 89 สำหรับฟิลด์ grades :

 db.students.find( { semester: 2, grades: { $gte: 89 } }, { "grades.$": 1 } )

การดำเนินการนี้ส่งคืนเอกสารต่อไปนี้:

 {"_id": 3, "grades": [95] }

เจ้าหน้าที่ประเมินผล

คุณสามารถใช้ตัวดำเนินการประเมินผล MongoDB เพื่อวัดโครงสร้างข้อมูลโดยรวมหรือแต่ละฟิลด์ภายในเอกสารได้

ลองดูตัวดำเนินการประเมิน MongoDB ทั่วไปบางตัว

$mod

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

 { field: { $mod: [ divisor, remainder ] } }

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

 db.cars.find ( { qty: { $mod: [ 250,0 ] } } )

$jsonสคีมา

$jsonSchema ให้คุณจับคู่เอกสารที่ตรงกับสคีมา JSON ที่ระบุ การใช้งาน JSON schema ของ MongoDB รวมถึงการเพิ่ม bsonType ซึ่งช่วยให้คุณใช้ประเภท BSON ทั้งหมดภายในตัวดำเนินการ $jsonSchema

bsonType สามารถยอมรับนามแฝงสตริงเดียวกันกับที่คุณใช้สำหรับตัวดำเนินการ type นี่คือสิ่งที่ไวยากรณ์ของ $jsonSchema จะมีลักษณะดังนี้:

 { $jsonSchema: <JSON Schema object> }

ที่นี่ ออบเจ็กต์สคีมา JSON ถูกจัดรูปแบบตามแบบร่างของมาตรฐานสคีมา JSON 4:

 { <keyword1>: <value1>, ... }

นี่คือตัวอย่างที่แสดงให้เห็นว่า $jsonSchema ทำงานอย่างไร:

 { $jsonSchema: { required: [ "name", "major", "gpa", "address" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, address: { bsonType: "object", required: [ "zipcode" ], properties: { "street": { bsonType: "string" }, "zipcode": { bsonType: "string" } } } } } }

คุณยังสามารถใช้ $jsonSchema ในตัวตรวจสอบเอกสารเพื่อบังคับใช้ schema ที่ระบุในการดำเนินการอัพเดตและแทรก:

 db.createCollection(<collection> , { validator: { $jsonSchema: <schema> } } ) db.runCommand( { collMod: <collection>, validator:{ $jsonSchema: <schema> } } )

โปรดทราบว่ามีหลายสิ่งที่ตัวดำเนินการ $jsonSchema ไม่รองรับ:

1. ประเภทจำนวนเต็ม คุณต้องใช้ประโยชน์จากประเภท BSON แบบยาวหรือแบบ int ด้วยคีย์เวิร์ด bsonType
2. คีย์เวิร์ดที่ไม่รู้จัก
3. การเชื่อมโยงคุณสมบัติและไฮเปอร์มีเดียของสคีมา JSON พร้อมกับการใช้การอ้างอิง JSON และพอยน์เตอร์ JSON

$text

ตัวดำเนินการ $text จะค้นหาข้อความภายในเนื้อหาของฟิลด์ที่ระบุ โดยสร้างดัชนีด้วยดัชนีข้อความ:

 { $text: { $search: <string>, $language: <string>, $caseSensitive: <boolean>, $diacriticSensitive: <boolean> } }

ในกรณีนี้ ข้อมูลโค้ดต่อไปนี้จะลอดผ่านตารางเพื่อกรองรถที่มีข้อความ "Porsche" ออก:

 db.cars.find( { $text: { $search: "Porsche" } } )

$regex

ตัวดำเนินการ $regex มีความสามารถในนิพจน์ทั่วไปในการจัดรูปแบบสตริงที่ตรงกันในการสืบค้น MongoDB ใช้ประโยชน์จากนิพจน์ทั่วไปที่เข้ากันได้กับ Perl:

 {<field> : /pattern/ <options>}

ตัวอย่างต่อไปนี้จะช่วยกรองรถยนต์ทั้งหมดที่มีสตริง “78900” อยู่ในนั้น:

 db.cars.find( { price: { $regex: /$78900/ } } )

$expr

ตัวดำเนินการ $expr ช่วยให้คุณสามารถใช้ประโยชน์จากนิพจน์การรวมภายในภาษาของแบบสอบถาม:

 { $expr: { <expression> } }

คุณยังสามารถใช้ $expr เพื่อสร้างนิพจน์คิวรีที่เปรียบเทียบเขตข้อมูลจากเอกสารเดียวกันในขั้นตอน $match If the $match stage happens to be the part of a $lookup stage, $expr can compare fields with the help of let variables.

$where

You can leverage the $where operator to either pass a string containing a full JavaScript function or a JavaScript expression to the query system. The $where operator provides greater flexibility but needs the database to process the JavaScript function or expression for every document in the collection. You can reference this document in the JavaScript function or expression by using either obj or this .

Here's an example of the syntax:

 { $where: <string|JavaScript Code> }

There are a few key considerations to keep in mind before we dive into an example while using the $where operator:

• You should only use the $where query operator to top-level documents. The $where query operator won't function in a nested document, like in a $elemMatch query.
• Generally, you should use $where only when you cannot express your query via another operator. If you have to use $where , make sure you include at least one other standard query operator to filter the result set. Using $where independently requires a collection scan for proper execution.

Here's an example to illustrate this:

 db.cars.find( { $where: function() { return (hex_md5(this.name)== "9a43e617b50cd379dca1bc6e2a8") } } );

Bitwise Operators

Bitwise operators return data based on bit position conditions. Simply put, they are used to match numeric or binary values in which any bit from a set of bit positions has a value of 1 or 0.

$bitsAllSet

This operator will match all the documents where all of the bit positions provided by the query are set (ie 1) in the field:

{ <field> : { $bitsAllSet: <numeric bitmask> } }

 { <field> : { $bitsAllSet: < BinData bitmask> } }

 { <field> : { $bitsAllSet: [ <position1> , <position2> , ... ] } }

ค่าของฟิลด์ควรเป็นอินสแตนซ์ BinData หรือตัวเลขสำหรับ $bitsAllSet เพื่อให้ตรงกับเอกสารปัจจุบัน

ในกรณีต่อไปนี้ เรากำลังใช้ประโยชน์จากคอลเล็กชันด้วยเอกสารต่อไปนี้:

 db.collection.save({ _id: 1, a: 54, binaryValueofA: "00110110" }) db.collection.save({ _id: 2, a: 20, binaryValueofA: "00010100" }) db.collection.save({ _id: 3, a: 20.0, binaryValueofA: "00010100" }) db.collection.save({ _id: 4, a: BinData(0, "Zg=="), binaryValueofA: "01100110" })

แบบสอบถามที่กล่าวถึงด้านล่างจะใช้ตัวดำเนินการ $bitsAllSet เพื่อทดสอบว่าฟิลด์ a มีบิตที่ตั้งไว้ที่ตำแหน่ง 1 และตำแหน่ง 5 หรือไม่ โดยที่บิตที่มีนัยสำคัญน้อยที่สุดจะอยู่ที่ตำแหน่ง 0:

 db.collection.find( { a: { $bitsAllSet: [ 1, 5 ] } }

แบบสอบถามนี้จะตรงกับเอกสารต่อไปนี้:

 { "_id" : 1, "a" : 54, "binaryValueofA" : "00110110" } { "_id" : 4, "a" : BinData(0,"Zg=="), "binaryValueofA" : "01100110" }

$bitsAllClear

$bitsAllClear โอเปอเรเตอร์จะจับคู่เอกสารในตำแหน่งบิตทั้งหมดที่ระบุโดยแบบสอบถามมีความชัดเจนหรือ 0 :

 { <field> : { $bitsAllClear: <numeric bitmask> } }

 { <field> : { $bitsAllClear: < BinData bitmask> } }

 { <field> : { $bitsAllClear: [ <position1> , <position2> , ... ] } }

เราจะใช้ตัวอย่างที่ใช้สำหรับ $bitsAllSet ที่นี่ เพื่อสาธิตการใช้งาน $bitsAllClear แบบสอบถามต่อไปนี้จะใช้ตัวดำเนินการนี้เพื่อตรวจสอบว่าฟิลด์ a มีบิตที่ชัดเจนที่ตำแหน่ง 1 และ 5:

 db.collection.find( { a: { $bitsAllClear: [ 1, 5 ] } } )

แบบสอบถามนี้จะตรงกับเอกสารต่อไปนี้:

 { "_id" : 2, "a" : 20, "binaryValueofA" : "00010100" } { "_id" : 3, "a" : 20, "binaryValueofA" : "00010100" }

Meta Operators

มีตัวแก้ไขข้อความค้นหาต่างๆ ที่ให้คุณปรับเปลี่ยนการทำงานหรือผลลัพธ์ของข้อความค้นหาใน MongoDB อินเทอร์เฟซของไดรเวอร์อาจมีวิธีเคอร์เซอร์ที่รวมไว้สำหรับการใช้งานของคุณ

$คำใบ้

MongoDB เลิกใช้ $hint ตั้งแต่ v3.2 แต่โอเปอเรเตอร์นี้อาจยังคงใช้ได้สำหรับไดรเวอร์ MongoDB เช่น Go, Java, Scala, Ruby, Swift เป็นต้น มันสามารถบังคับให้เครื่องมือเพิ่มประสิทธิภาพการสืบค้นใช้ประโยชน์จากดัชนีเฉพาะเพื่อเติมเต็มการสืบค้น ซึ่งสามารถกล่าวถึงได้ทั้งในเอกสารหรือโดย ชื่อดัชนี

คุณยังสามารถใช้ตัวดำเนินการ $hint เพื่อทดสอบกลยุทธ์การจัดทำดัชนีและประสิทธิภาพการสืบค้น ตัวอย่างเช่น ใช้การดำเนินการต่อไปนี้:

 db.users.find().hint( { age: 1 } )

การดำเนินการนี้จะส่งคืนเอกสารทั้งหมดภายในคอลเล็กชันที่เรียกว่า users โดยใช้ประโยชน์จากดัชนีในฟิลด์ age

คุณยังสามารถพูดถึงคำใบ้โดยใช้รูปแบบใดรูปแบบหนึ่งต่อไปนี้:

 db.users.find()._addSpecial( "$hint", { age : 1 } ) db.users.find( { $query: {}, $hint: { age : 1 } } )

หากมีตัวกรองดัชนีสำหรับรูปร่างการสืบค้น MongoDB จะเพิกเฉย $hint

$ความคิดเห็น

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

คุณสามารถใช้ประโยชน์จาก $comment ได้ด้วยวิธีใดวิธีหนึ่งจากสามวิธี:

 db.collection.find( { <query> } )._addSpecial( "$comment", <comment> ) db.collection.find( { <query> } ).comment( <comment> ) db.collection.find( { $query: { <query> }, $comment: <comment> } )

หากคุณต้องการแนบความคิดเห็นกับนิพจน์แบบสอบถามในบริบทอื่น เช่น db.collection.update() ให้ใช้ประโยชน์จากตัวดำเนินการแบบสอบถาม $comment แทนตัวดำเนินการเมตา

$max

คุณสามารถระบุค่า $max เพื่อระบุขอบเขตบนเฉพาะสำหรับดัชนีเฉพาะเพื่อจำกัดผลลัพธ์ของ find() ตัวดำเนินการนี้จะระบุขอบเขตบนสำหรับคีย์ทั้งหมดของลำดับที่ระบุในดัชนี

Mongosh ให้วิธีการห่อ max() ต่อไปนี้แก่คุณ:

 db.collection.find( { <query> } ).max( { field1: <max value> , ... fieldN: <max valueN> } )

คุณยังสามารถพูดถึง $max ด้วยสองรูปแบบต่อไปนี้:

 db.collection.find( { <query> } )._addSpecial( "$max", { field1: <max value1> , ... fieldN: <max valueN> } ) db.collection.find( { $query: { <query> }, $max: { field1: <max value1> , ... fieldN: <max valueN> } } )

ตัวอย่างเช่น หากคุณต้องการระบุขอบเขตบนเฉพาะ ให้คำนึงถึงการดำเนินการต่อไปนี้ในคอลเลกชันที่ชื่อคอลเลกชันที่มีดัชนี { age: 1 } :

 db.collection.find( { <query> } ).max( { age: 100 } ).hint( { age: 1 } )

การดำเนินการนี้จะจำกัดการสืบค้นให้อยู่ในเอกสารที่อายุฟิลด์น้อยกว่า 100 และบังคับแผนการสืบค้นที่จะสแกนดัชนี { age: 1 } จาก minKey ถึง 100

$อธิบาย

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

คุณสามารถพูดถึงตัวดำเนินการ $explain ในรูปแบบใดรูปแบบหนึ่งต่อไปนี้:

 db.collection.find()._addSpecial( "$explain", 1 ) db.collection.find( { $query: {}, $explain: 1 } )

แนวทางปฏิบัติที่ดีที่สุดสำหรับตัวดำเนินการ MongoDB

ในส่วนนี้ เราจะมาดูแนวทางปฏิบัติที่ดีที่สุดบางส่วนในขณะที่ใช้ตัวดำเนินการ MongoDB เหล่านี้

การฝังและการอ้างอิง

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

คุณสามารถฝังข้อมูลด้วยความสัมพันธ์แบบ 1:1 ภายในเอกสารเดียว ที่กล่าวว่าข้อมูลที่มีความสัมพันธ์หลายต่อ 1 ซึ่งวัตถุ "หลายรายการ" ปรากฏพร้อมกับเอกสารหลักก็สามารถเป็นตัวเลือกที่ดีได้เช่นกัน

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

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

คุณควรพิจารณาใช้การอ้างอิงสำหรับสถานการณ์ต่อไปนี้:

• เมื่อคุณอัปเดตเซ็กเมนต์เอกสารและมันยาวขึ้นเรื่อยๆ ในขณะที่เอกสารที่เหลือจะคงที่
• เมื่อมีการเข้าถึงเอกสารแต่มีข้อมูลที่ไม่ค่อยได้ใช้ การฝังจะเพิ่มความต้องการในหน่วยความจำเท่านั้น ดังนั้นการอ้างอิงจึงเหมาะสมกว่า
• เมื่อขนาดเอกสารเกินขีดจำกัดเอกสาร 16MB ของ MongoDB สิ่งนี้สามารถเกิดขึ้นได้เมื่อสร้างแบบจำลองความสัมพันธ์หลายแบบ:1 (เช่น Employee:department )

ตรวจสอบโปรไฟล์และรูปแบบการสืบค้น

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

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

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

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

ตรวจสอบการจัดทำดัชนีและการสร้างแบบจำลองข้อมูล

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

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

คุณยังสามารถใช้ MongoDB เพื่อสร้างแบบจำลองต่อไปนี้:

• ข้อมูลเชิงพื้นที่
• โครงสร้างแบบตาราง แบบแบน และแบบเสา
• คู่คีย์-ค่าอย่างง่าย
• ข้อมูลอนุกรมเวลา
• ขอบและโหนดของโครงสร้างข้อมูลกราฟที่เชื่อมต่อและสิ่งที่คล้ายกัน

ตรวจสอบการแบ่งส่วนและการจำลองแบบ

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

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

ตัวอย่างเช่น Kinsta APM สามารถดึงข้อมูลการประทับเวลาเกี่ยวกับการสืบค้นฐานข้อมูล MySQL ของไซต์ WordPress, กระบวนการ PHP, การเรียก HTTP ภายนอก และอื่นๆ อีกมากมาย คุณยังสามารถใช้เครื่องมือฟรีนี้เพื่อดีบัก:

• การเรียก API แบบยาว
• คำขอ URL ภายนอกแบบยาว
• แบบสอบถามฐานข้อมูลช้าเพื่อชื่อไม่กี่

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

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

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

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

กำหนดการใช้หน่วยความจำ

MongoDB ทำงานได้ดีที่สุดเมื่อชุดการทำงานของแอปพลิเคชัน (เช่น ข้อมูลและดัชนีที่เข้าถึงบ่อย) พอดีกับหน่วยความจำโดยไม่มีปัญหา แม้ว่าปัจจัยอื่นๆ จะมีความสำคัญต่อประสิทธิภาพ แต่ขนาด RAM นั้นสำคัญที่สุดสำหรับการปรับขนาดอินสแตนซ์

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

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

วางฟิลด์ Multi-Value ที่ส่วนท้าย

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

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

สรุป

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

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

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