เขียนคิวรี GQL ทั่วไปใน Microsoft Fabric

บทความนี้แสดงรูปแบบคิวรี GQL ที่ใช้งานได้จริงสําหรับงานกราฟทั่วไปใน Microsoft Fabric: การค้นหาเพื่อนบ้าน การข้ามการเชื่อมต่อแบบมัลติฮอป การระบุการเชื่อมต่อที่ใช้ร่วมกัน การนับความสัมพันธ์ และการค้นหาเอนทิตีที่ไม่มีการเชื่อมต่อ

ตัวอย่างใช้ชุดข้อมูลตัวอย่างเครือข่ายสังคม สําหรับคําอธิบายแบบครบวงจรเกี่ยวกับการไหลของคําสั่งและคําสั่งของคําสั่ง โปรดดูคู่มือภาษา GQL ใช้บทความนี้เมื่อคุณรู้ว่างานกราฟที่คุณต้องการทําคืออะไร สําหรับคําแนะนําอย่างเป็นระบบในการสร้างรูปแบบโหนด ขอบ และเส้นทาง ดูที่ การเขียนคําสั่งค้นหารูปแบบกราฟ สําหรับขั้นตอนการกรองและการรวบรวมข้อมูลโดยละเอียด ดูที่ กรองและรวบรวมข้อมูลกราฟ

ข้อกำหนดเบื้องต้น

• รายการกราฟที่สร้างจากชุดข้อมูลตัวอย่างเครือข่ายสังคม โดยมีประเภทโหนด ประเภทขอบ และคุณสมบัติที่อธิบายไว้ในตัวอย่างสคีมาเครือข่ายสังคม
• ความคุ้นเคยกับพื้นฐาน MATCH และ RETURN แบบสอบถาม ดูคู่มือภาษา GQL

ค้นหาเพื่อนบ้านโดยตรง

ส่งคืนโหนดทั้งหมดที่เชื่อมต่อกับโหนดเริ่มต้นด้วยหนึ่งฮ็อป

ค้นหาทุกคนที่บุคคลใดบุคคลหนึ่งรู้จัก:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:knows]->(friend:Person)
RETURN friend.firstName, friend.lastName

ค้นหาบริษัททั้งหมดที่บุคคลนั้นทํางาน:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:workAt]->(c:Company)
RETURN c.name, c.url

ค้นหาเพื่อนของเพื่อน (มัลติฮอป)

ใช้รูปแบบความยาวตัวแปรเพื่อ {min,max} สํารวจมากกว่าหนึ่งกระโดด

ค้นหาคนที่เข้าถึงได้สองขอบพอดี knows จาก Alice:

MATCH (alice:Person WHERE alice.firstName = 'Alice')-[:knows]->{2,2}(fof:Person)
RETURN DISTINCT fof.firstName, fof.lastName
LIMIT 100

ค้นหาทุกคนที่สามารถเข้าถึงได้ภายในสามองศา:

MATCH (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,3}(dst:Person)
RETURN DISTINCT dst.firstName, dst.lastName
LIMIT 100

ค้นหาเส้นทางที่สั้นที่สุดจากอลิซไปยังแต่ละคนที่สามารถเดินทางถึงได้ภายในสี่ก้าว:

MATCH p = ANY SHORTEST
  (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName, path_length(p) AS hopCount
ORDER BY hopCount, dst.lastName
LIMIT 100

ถ้าเส้นทางที่สั้นที่สุดหลายเส้นทางไปถึงบุคคลเดียวกันในจํานวนครั้งที่เท่ากัน จะ ANY SHORTEST คืนค่าหนึ่งเส้นทางโดยไม่มีการเลือกเสมอแบบกําหนด

พรีดิเคตแบบอินไลน์จํากัดเส้นทางที่มีสิทธิ์สําหรับ ANY SHORTEST. Postfilters จะถูกใช้หลังจากเลือกเส้นทางที่สั้นที่สุด ตัวอย่างเช่น ดูที่ พจน์ Place predicates ก่อนหรือหลังการเลือกเส้นทาง

นับความสัมพันธ์ต่อเอนทิตี

ใช้ GROUP BY with count(*) เพื่อนับจํานวนความสัมพันธ์ที่แต่ละเอนทิตีมี สําหรับการจัดกลุ่มอย่างละเอียด การกรองแบบรวม และรูปแบบการกําหนดเส้นทางแบบมีเงื่อนไข ดูที่ กรองและข้อมูลกราฟรวม

นับจํานวนเพื่อนที่แต่ละคนมี โดยเรียงลําดับจากมากไปน้อย:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
ORDER BY friendCount DESC
LIMIT 20

คํานวณค่าสําหรับแต่ละเอนทิตี

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

คํานวณจํานวนเพื่อนของแต่ละคน:

MATCH (p:Person)
CALL {
  MATCH (p)-[:knows]->(friend:Person)
  RETURN count(*) AS friendCount
}
RETURN p.firstName, p.lastName, friendCount
ORDER BY friendCount DESC

ตัวแปรภายนอกยังคงมีอยู่หลังจาก CALL. จากตัวแปรที่สร้างภายในซับคิวรี จะมีเฉพาะคอลัมน์ที่คืนค่าเท่านั้นที่จะสามารถใช้งานได้ภายนอกซับคิวรี การไม่รวมกลุ่ม count(*) จะคืนค่า 0 เมื่อไม่มีเพื่อนที่ตรงกัน ดังนั้นคําค้นหานี้จะเก็บคนที่ไม่มีเพื่อนไว้

Ordinary CALL จะตัดแถวด้านนอกออกเมื่อซับคิวรีไม่คืนค่าแถว และจะสร้างหนึ่งแถวผลลัพธ์สําหรับแต่ละแถวซับคิวรีเมื่อคืนค่าหลายแถว ใช้ OPTIONAL CALL เมื่อคุณต้องการรักษาแถวนอกที่ไม่มีแถวซับคิวรีที่ตรงกัน

ค้นหาการเชื่อมต่อที่แชร์

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

ค้นหาคู่ของคนที่รู้จักคนเดียวกัน:

MATCH (a:Person)-[:knows]->(mutual:Person)<-[:knows]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, mutual.firstName AS sharedContact
LIMIT 100

ค้นหาคู่คนที่ทํางานในบริษัทเดียวกัน:

MATCH (c:Company)<-[:workAt]-(a:Person), (c)<-[:workAt]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, c.name AS company
LIMIT 100

ค้นหาเอนทิตีที่ไม่มีความสัมพันธ์

ใช้เพื่อ NOT EXISTS ค้นหาโหนดที่มีคําค้นย่อยที่เกี่ยวข้องไม่คืนค่าแถว

ค้นหาคนที่ไม่ได้ทํางานในบริษัทใด ๆ :

MATCH (p:Person)
WHERE NOT EXISTS {
  MATCH (p)-[:workAt]->(c:Company)
  RETURN c
}
RETURN p.firstName, p.lastName
LIMIT 100

ค้นหาโพสต์ที่ไม่มีความคิดเห็น:

MATCH (post:Post)
WHERE NOT EXISTS {
  MATCH (comment:Comment)-[:replyOf]->(post)
  RETURN comment
}
RETURN post.id, post.content
LIMIT 100

ค้นหาเอนทิตีที่มีการเชื่อมต่อจํานวนมาก

รวม GROUP BY และ FILTER เพื่อระบุโหนดที่เชื่อมต่อกันสูง วิธีนี้มีประโยชน์สําหรับการค้นหาฮับหรือค่าผิดปกติ

ค้นหาผู้คนที่มีเพื่อนมากกว่า 10 คน:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
FILTER friendCount > 10
ORDER BY friendCount DESC

เนื้อหาที่เกี่ยวข้อง

• คู่มือภาษา GQL
• รูปแบบกราฟ GQL
• กรองและรวมข้อมูลกราฟ
• ปรับประสิทธิภาพคิวรี GQL ให้เหมาะสม