סוגי אינדקסים ב-Cloud Firestore

אינדקסים הם גורם חשוב בביצועים של מסד נתונים. בדומה לאינדקס של ספר שממפה נושאים בספר למספרי עמודים, אינדקס של מסד נתונים ממפה את הפריטים במסד הנתונים למיקומים שלהם במסד הנתונים. כשמריצים שאילתה במסד נתונים, מסד הנתונים יכול להשתמש באינדקס כדי לזהות במהירות את המיקומים של הפריטים שביקשתם.

בדף הזה מתוארים שני סוגי האינדקסים שבהם נעשה שימוש ב-Cloud Firestore: אינדקסים אוטומטיים ואינדקסים ידניים.

הגדרת האינדקס והמבנה שלו

אינדקס מוגדר ברשימה של שדות במסמך נתון, עם מצב אינדקס תואם לכל שדה.

אינדקס מכיל רשומה לכל שדה שמופיע בהגדרת האינדקס. האינדקס כולל את כל המסמכים שיכולים להיות תוצאות של שאילתות שמבוססות על האינדקס. מסמך נכלל באינדקס רק אם מוגדר לו ערך באינדקס לכל שדה שמשמש באינדקס. אם הגדרת האינדקס מתייחסת לשדה שלא הוגדר לו ערך במסמך, המסמך לא יופיע באינדקס. במקרה כזה, המסמך לא יוחזר אף פעם כתוצאה של שאילתה שמבוססת על האינדקס.

האינדקס ממוין לפי ערכי השדות, בסדר שצוין בהגדרת האינדקס.

אינדקס מאחורי כל שאילתה

אם לא קיים אינדקס לשאילתה, רוב מסדי הנתונים סורקים את התוכן שלהם פריט אחר פריט. זה תהליך איטי שמתארך ככל שמסד הנתונים גדל. ‫Cloud Firestore מבטיח ביצועים גבוהים של שאילתות באמצעות שימוש באינדקסים לכל השאילתות. כתוצאה מכך, ביצועי השאילתה תלויים בגודל של קבוצת התוצאות ולא במספר הפריטים במסד הנתונים.

פחות ניהול של אינדקסים, יותר פיתוח אפליקציות

‫Cloud Firestore כולל תכונות שמקצרות את הזמן שצריך להשקיע בניהול האינדקס. האינדקסים שנדרשים לשאילתות הכי בסיסיות נוצרים באופן אוטומטי. במהלך השימוש באפליקציה ובדיקתה, Cloud Firestore עוזר לכם לזהות וליצור אינדקסים נוספים שהאפליקציה צריכה.

סוגי אינדקסים

ב-Cloud Firestore יש שני סוגים של אינדקסים: אוטומטי וידני. ההבדל בין אינדקסים ידניים לאינדקסים אוטומטיים הוא באופן הניהול שלהם.

אינדקסים אוטומטיים

כברירת מחדל, Cloud Firestore יוצר אוטומטית אינדקסים לכל שדה שמופיע במסמכים באוסף. האינדקסים האלה עם שדה יחיד מאפשרים לבצע הרבה שאילתות בסיסיות. כדי לנהל אינדקסים אוטומטיים, צריך להגדיר את ההגדרות של יצירת אינדקס אוטומטית במסד הנתונים ואת הפטורים מיצירת אינדקס.

הגדרות ברירת מחדל אוטומטיות של אינדקס

‫Cloud Firestore משתמש בהגדרות ברירת המחדל הבאות לאינדקסים אוטומטיים:

• לכל שדה שאינו מערך או מיפוי, Cloud Firestore מגדיר שני אינדקסים בהיקף האוסף, אחד במצב עולה ואחד במצב יורד.

• לכל שדה במפה, Cloud Firestore יוצר את הפריטים הבאים:

  • אינדקס אחד בסדר עולה ברמת האוסף לכל שדה משנה שאינו מערך או מפה.
  • אינדקס יורד אחד בהיקף אוסף לכל שדה משנה שאינו מערך או מפה.
  • אינדקס אחד בסדר עולה ברמת האוסף לערך המפה כולו
  • אינדקס יורד בהיקף אוסף לכל ערך המפה
  • אינדקס אחד של array-contains ברמת האוסף לכל שדה משנה של מערך.
  • Cloud Firestore מבצע אינדוקס לכל שדה משנה של מפה באופן רקורסיבי.

• עבור כל שדה מערך במסמך, Cloud Firestore יוצר את הפריטים הבאים:

  • אינדקס עולה בהיקף הקולקציה לכל ערך המערך
  • אינדקס אחד בסדר יורד ברמת האוסף לכל ערך המערך
  • אינדקס אחד מסוג array-contains בהיקף אוסף.

• אינדקסים אוטומטיים עם היקף של קבוצת אוספים לא נשמרים כברירת מחדל.

פטורים אוטומטיים מהוספה לאינדקס

כדי להחריג שדה מהגדרות ההוספה האוטומטית לאינדקס, צריך ליצור החרגה מהוספה לאינדקס. פטור מאינדוקס מבטל את ההגדרות האוטומטיות של האינדקס בכל מסד הנתונים. חריגה יכולה להפעיל אינדקס שהגדרות האינדקס האוטומטי היו משביתות, או להשבית אינדקס שהאינדקס האוטומטי היה מפעיל. במאמר שיטות מומלצות ליצירת אינדקס מפורטים מקרים שבהם יכול להיות שימושי להשתמש בפטורים.

אפשר להשתמש בערך של נתיב השדה * כדי להוסיף חריגים לאינדקס ברמת הקולקציה לכל השדות בקבוצת אוספים. לדוגמה, כדי להתאים את כל השדות בקבוצת האוסף comments ולהשבית את יצירת האינדקס של כל השדות בקבוצת האוסף, מגדירים את נתיב השדה ל-*.comments לאחר מכן תוכלו להוסיף פטורים כדי ליצור אינדקס רק לשדות שנדרשים לשאילתות שלכם. צמצום מספר השדות באינדקס מפחית את עלויות האחסון ויכול לשפר את ביצועי הכתיבה.

אם יוצרים חריגה מהאינדקס לשדה מפה, שדות המשנה של המפה יקבלו בירושה את ההגדרות האלה. עם זאת, אפשר להגדיר חריגים לאינדקס עבור שדות משנה ספציפיים. אם מוחקים החרגה של שדה משנה, שדה המשנה יקבל בירושה את הגדרות ההחרגה של שדה האב שלו, אם הן קיימות, או את ההגדרות של כלל מסד הנתונים אם לא קיימות החרגות של שדה האב.

במאמר ניהול אינדקסים מוסבר איך יוצרים ומנהלים חריגות אוטומטיות באינדקס.

מדדים ידניים

אינדקס ידני מאחסן מיפוי ממוין של כל המסמכים באוסף, על סמך רשימה מסודרת של שדות לאינדקס.

‫Cloud Firestore משתמש באינדקסים ידניים כדי לתמוך בשאילתות שלא נתמכות כבר על ידי אינדקסים אוטומטיים.

כברירת מחדל, Cloud Firestore יוצר באופן אוטומטי אינדקסים של שדה יחיד לכל שדה שקיים באוסף. ‫Cloud Firestore לא יוצר באופן אוטומטי אינדקסים לשילובי שדות בגלל המספר הגדול של שילובי שדות אפשריים. במקום זאת, Cloud Firestore עוזר לכם לזהות וליצור את האינדקסים הנדרשים בזמן שאתם מפתחים את האפליקציה.

בכל פעם שתנסו להריץ שאילתה שלא נתמכת על ידי אינדקס קיים, Cloud Firestore תחזיר הודעת שגיאה עם קישור שאפשר ללחוץ עליו כדי ליצור את האינדקס החסר.

אפשר גם להגדיר ולנהל אינדקסים באופן ידני באמצעות המסוף או באמצעות Firebase CLI. מידע נוסף על יצירה וניהול של אינדקסים ידניים זמין במאמר ניהול אינדקסים.

מצבי אינדקס והיקפי שאילתות

ההגדרה של אינדקסים אוטומטיים וידניים שונה, אבל בשני המקרים צריך להגדיר את מצבי האינדקס ואת היקפי השאילתות של האינדקסים.

מצבי אינדקס

כשמגדירים אינדקס, בוחרים מצב אינדקס לכל שדה באינדקס. כל שדה תומך בסעיפי שאילתה ספציפיים בשדה הזה, בהתאם למצב האינדקס שלו. אפשר לבחור מבין מצבי האינדקס הבאים:

היקפי שאילתות

כל אינדקס מוגבל להיקף של אוסף או קבוצת אוספים. האזור הזה נקרא היקף השאילתה של האינדקס:

היקף האיסוף

‫

Cloud Firestore יוצרת אינדקסים עם היקף אוסף כברירת מחדל. האינדקסים האלה תומכים בשאילתות שמחזירות תוצאות מאוסף יחיד.

היקף קבוצת האוספים

קבוצת אוספים כוללת את כל האוספים עם אותו מזהה אוסף. כדי להריץ שאילתה של קבוצת אוספים שמחזירה תוצאות מסוננות או מסודרות מקבוצת אוספים, צריך ליצור אינדקס תואם עם היקף של קבוצת אוספים.

סדר ברירת המחדל והשדה __name__

בנוסף למיון המסמכים לפי מצבי האינדקס שצוינו לכל שדה (סדר עולה או יורד) , האינדקסים מבצעים מיון סופי לפי השדה __name__ של כל מסמך. הערך של השדה __name__ הוא הנתיב המלא של המסמך. כלומר, מסמכים בערכת התוצאות עם אותם ערכי שדות ממוינים לפי נתיב המסמך.

כברירת מחדל, השדה __name__ ממוין באותו כיוון של השדה האחרון שמוין בהגדרת האינדקס. לדוגמה:

כדי למיין את התוצאות לפי __name__ הכיוון שאינו ברירת המחדל, צריך ליצור את האינדקס הזה.

מאפייני האינדקס

אינדקס שמאפשר להריץ את השאילתה בצורה הכי יעילה מוגדר על ידי המאפיינים הבאים:

• שדות שמשמשים במסנני שוויון
• שדות שמשמשים למיון הזמנות
• שדות שמשמשים במסננים של טווחים ואי-שוויון (שלא נכללים כבר בסדר המיון)
• שדות שמשמשים לצבירה (שלא נכללים כבר בסדר מיון ובמסנני טווח ואי-שוויון)

הכלי Cloud Firestore מחשב את תוצאות השאילתות באופן הבא:

1. מזהה את האינדקס שמתאים לאוסף, למאפייני המסנן, לאופרטורים של המסנן ולסדר המיון של השאילתה.
2. מזהה את מיקום האינדקס שממנו מתחילה הסריקה. נקודת ההתחלה מתחילה עם מסנני השוויון של השאילתה ומסתיימת עם מסנני הטווח והאי-שוויון בשדה הראשון orderBy.
3. מתחיל לסרוק את האינדקס, ומחזיר כל מסמך שעומד בכל המסננים, עד שתהליך הסריקה מבצע אחת מהפעולות הבאות:
   • הכלי נתקל במסמך שלא עומד בתנאי הסינון, ומוודא שאף מסמך בהמשך לא יעמוד בתנאי הסינון באופן מלא.
   • ההגעה לסוף האינדקס.
   • הפונקציה אוספת את המספר המקסימלי של תוצאות שנדרשו בשאילתה.

דוגמה להוספה לאינדקס

Cloud Firestore יוצרת בשבילכם באופן אוטומטי אינדקסים של שדה יחיד, וכך האפליקציה יכולה לתמוך במהירות בשאילתות בסיסיות ביותר במסד הנתונים. אינדקסים של שדה יחיד מאפשרים לבצע שאילתות פשוטות על סמך ערכי שדות והאופרטורים להשוואה <,‏ <=,‏ ==,‏ >=,‏ > ו-in. בשדות של מערכים, אפשר לבצע שאילתות array-contains ו-array-contains-any.

כדי להמחיש זאת, נבחן את הדוגמאות הבאות מנקודת המבט של יצירת אינדקס. קטע הקוד הבא יוצר כמה מסמכי city באוסף cities ומגדיר את השדות name,‏ state,‏ country,‏ capital,‏ population ו-tags לכל מסמך:

var citiesRef = db.collection("cities");

citiesRef.doc("SF").set({
    name: "San Francisco", state: "CA", country: "USA",
    capital: false, population: 860000,
    regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
    name: "Los Angeles", state: "CA", country: "USA",
    capital: false, population: 3900000,
    regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
    name: "Washington, D.C.", state: null, country: "USA",
    capital: true, population: 680000,
    regions: ["east_coast"] });
citiesRef.doc("TOK").set({
    name: "Tokyo", state: null, country: "Japan",
    capital: true, population: 9000000,
    regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
    name: "Beijing", state: null, country: "China",
    capital: true, population: 21500000,
    regions: ["jingjinji", "hebei"] });
test.firestore.js

בהנחה שהגדרות ברירת המחדל של יצירת אינדקס אוטומטית מופעלות, Cloud Firestore מעדכן אינדקס אחד עולה של שדה יחיד לכל שדה, אינדקס אחד יורד של שדה יחיד לכל שדה ואינדקס אחד של שדה יחיד עם array-contains לשדה המערך. כל שורה בטבלה הבאה מייצגת רשומה באינדקס של שדה יחיד:

שאילתות שנתמכות על ידי אינדקסים של שדה יחיד

בעזרת האינדקסים האלה של שדה יחיד שנוצרו באופן אוטומטי, אפשר להריץ שאילתות פשוטות כמו:

const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
test.firestore.js

אפשר גם ליצור שאילתות של in ושל שוויון מורכב (==):

citiesRef.where('country', 'in', ["USA", "Japan", "China"])

// Compound equality queries
citiesRef.where("state", "==", "CO").where("name", "==", "Denver")
citiesRef.where("country", "==", "USA")
         .where("capital", "==", false)
         .where("state", "==", "CA")
         .where("population", "==", 860000)

אם אתם צריכים להריץ שאילתה מורכבת שמשתמשת בהשוואה של טווח (<,‏ <=,‏ > או >=) או אם אתם צריכים למיין לפי שדה אחר, אתם צריכים ליצור אינדקס ידני עבור השאילתה הזו.

האינדקס array-contains מאפשר לכם לשלוח שאילתות לשדה המערך regions:

citiesRef.where("regions", "array-contains", "west_coast")
// array-contains-any and array-contains use the same indexes
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])

שאילתות שנתמכות על ידי אינדקסים ידניים

יוצרים אינדקסים ידניים כדי לתמוך בשאילתות מורכבות שלא נתמכות כבר על ידי אינדקסים אוטומטיים של שדה יחיד. לדוגמה, תצטרכו אינדקס ידני לשאילתות הבאות:

citiesRef.where("country", "==", "USA").orderBy("population", "asc")
citiesRef.where("country", "==", "USA").where("population", "<", 3800000)
citiesRef.where("country", "==", "USA").where("population", ">", 690000)
// in and == clauses use the same index
citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)

השאילתות האלה דורשות את האינדקס הבא. מכיוון שהשאילתה משתמשת בשוויון (== או in) בשדה country, אפשר להשתמש במצב אינדקס עולה או יורד בשדה הזה. כברירת מחדל, סעיפי אי-שוויון מוחלים על סדר מיון עולה על סמך השדה בסעיף אי-השוויון.

כדי להריץ את אותן שאילתות אבל עם סדר מיון יורד, צריך אינדקס נוסף בכיוון יורד עבור population:

citiesRef.where("country", "==", "USA").orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", "<", 3800000)
         .orderBy("population", "desc")

citiesRef.where("country", "==", "USA")
         .where("population", ">", 690000)
         .orderBy("population", "desc")

citiesRef.where("country", "in", ["USA", "Japan", "China"])
         .where("population", ">", 690000)
         .orderBy("population", "desc")

כדי למנוע ירידה בביצועים שנגרמת כתוצאה ממיזוג אינדקסים, מומלץ ליצור אינדקס כדי לשלב שאילתת array-contains או array-contains-any עם סעיפים נוספים:

citiesRef.where("regions", "array-contains", "east_coast")
         .where("capital", "==", true)

// array-contains-any and array-contains use the same index
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])
         .where("capital", "==", true)

שאילתות שנתמכות על ידי אינדקסים של קבוצות אוספים

כדי להדגים אינדקס עם היקף של קבוצת אוספים, מוסיפים landmarks אוסף משנה לחלק ממסמכי city:

var citiesRef = db.collection("cities");

citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Bridge",
    category : "bridge" });
citiesRef.doc("SF").collection("landmarks").doc().set({
    name: "Golden Gate Park",
    category : "park" });

citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Gallery of Art",
    category : "museum" });
citiesRef.doc("DC").collection("landmarks").doc().set({
    name: "National Mall",
    category : "park" });

באמצעות אינדקס של שדה יחיד עם היקף קולקציה, אפשר לשלוח שאילתה לקולקציית landmarks של עיר מסוימת על סמך השדה category:

citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])

לדוגמה, אם רוצים לשאול שאילתה לגבי ציוני דרך בכל הערים, מריצים את השאילתה הזו בקבוצת האוספים שמורכבת מכל האוספים של landmarks. צריך גם להפעיל landmarks אינדקס של שדה יחיד עם היקף של קבוצת אוספים:

אחרי שמפעילים את האינדקס הזה, אפשר לשלוח שאילתה לקבוצת האוספים landmarks:

var landmarksGroupRef = db.collectionGroup("landmarks");

landmarksGroupRef.where("category", "==", "park")
landmarksGroupRef.where("category", "in", ["park", "museum"])

כדי להריץ שאילתה של קבוצת אוספים שמחזירה תוצאות מסוננות או מסודרות, צריך להפעיל אינדקס תואם עם היקף של קבוצת אוספים. לעומת זאת, בשאילתות של קבוצות אוספים שלא מסננות או מסדרות את התוצאות, לא נדרשות הגדרות אינדקס נוספות.

לדוגמה, אפשר להריץ את השאילתה הבאה של קבוצת אוספים בלי להפעיל אינדקס נוסף:

db.collectionGroup("landmarks").get()

ערכים באינדקס

האינדקסים שהוגדרו בפרויקט ומבנה המסמך קובעים את מספר רשומות האינדקס במסמך. ערכים באינדקס נספרים כחלק מהמגבלה על מספר הערכים באינדקס.

בדוגמה הבאה מוצגות רשומות האינדקס של מסמך.

מסמך

/cities/SF

city_name : "San Francisco"
temperatures : {summer: 67, winter: 55}
neighborhoods : ["Mission", "Downtown", "Marina"]

אינדקסים אוטומטיים

• city_name ASC
• city_name DESC
• שכונות ASC
• neighborhoods DESC
• temperatures ASC
• temperatures DESC
• temperatures.summer ASC
• temperatures.summer DESC
• temperatures.winter ASC
• temperatures.winter DESC
• ‫Array Contains (מכיל מערך) של שכונות

מדדים ידניים

• city_name ASC, neighborhoods ARRAY
• city_name DESC, neighborhoods ARRAY

ערכים באינדקס

הגדרת ההוספה לאינדקס הזו יוצרת את רשומות האינדקס הבאות עבור המסמך:

אינדקסים ותמחור

אינדקסים תורמים לעלויות האחסון של האפליקציה. מידע נוסף על חישוב גודל האחסון של אינדקסים זמין במאמר גודל רשומת אינדקס.

שימוש במיזוג אינדקסים

למרות ש-Cloud Firestore משתמש באינדקס לכל שאילתה, הוא לא בהכרח דורש אינדקס אחד לכל שאילתה. בשביל שאילתות עם כמה סעיפים של שוויון (==) ואופציונלית סעיף orderBy, אפשר לעשות שימוש חוזר באינדקסים קיימים.Cloud Firestore ‫Cloud Firestore יכול למזג את האינדקסים של מסנני שוויון פשוטים כדי לבנות את האינדקסים שנדרשים לשאילתות שוויון גדולות יותר.

כדי להפחית את עלויות ההוספה לאינדקס, כדאי לזהות מצבים שבהם אפשר להשתמש במיזוג אינדקסים. לדוגמה, בrestaurantsאוסף של אפליקציה לדירוג מסעדות:

• collections_bookmark מסעדות

  • class burgerthyme

    name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
    

האפליקציה הזו משתמשת בשאילתות כמו אלה שמופיעות בהמשך. האפליקציה משתמשת בשילובים של פסוקיות שוויון עבור category, city ו-editors_pick, תוך מיון תמיד לפי סדר עולה של star_rating:

db.collection("restaurants").where("category", "==", "burgers")
                            .orderBy("star_rating")

db.collection("restaurants").where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==", "San Francisco")
                            .orderBy("star_rating")

db.collection("restaurants").where("category", "==", "burgers")
                            .where("city", "==" "San Francisco")
                            .where("editors_pick", "==", true )
                            .orderBy("star_rating")

אפשר ליצור אינדקס לכל שאילתה:

פתרון טוב יותר הוא לצמצם את מספר האינדקסים באמצעות היכולת של Cloud Firestore למזג אינדקסים עבור פסוקיות שוויון:

לא רק שקבוצת האינדקסים הזו קטנה יותר, היא גם תומכת בשאילתה נוספת:

db.collection("restaurants").where("editors_pick", "==", true)
                            .orderBy("star_rating")

מגבלות על הוספה לאינדקס

המגבלות הבאות חלות על אינדקסים. מידע נוסף על מכסות ומגבלות זמין במאמר מכסות ומגבלות.

שיטות מומלצות ליצירת אינדקס

ברוב האפליקציות, אפשר להסתמך על יצירת אינדקס אוטומטית ועל הקישורים בהודעת השגיאה כדי לנהל את האינדקסים. עם זאת, יכול להיות שתרצו להוסיף החרגות של יצירת אינדקס אוטומטית במקרים הבאים:

אם אתם משתמשים בשאילתות עם אופרטורים של טווח ואי-שוויון בכמה שדות, כדאי לעיין בשיקולים בנושא יצירת אינדקסים כדי לבצע אופטימיזציה של הביצועים והעלות של שאילתות Cloud Firestore.

מידע נוסף על פתרון בעיות בהוספה לאינדקס (פיצול אינדקס, שגיאות INVALID_ARGUMENT) זמין בדף פתרון הבעיות.