סוגי אינדקסים ב-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 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) זמין בדף לפתרון בעיות.