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

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

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

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

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

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

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

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

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

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

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

סוגי מדדים

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

אינדקסים של שדה יחיד

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

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

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

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

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

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

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

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

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

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

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

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

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

אינדקסים מורכבים

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

ב-Cloud Firestore נעשה שימוש באינדקסים מורכבים כדי לתמוך בשאילתות שעדיין אין להן תמיכה באינדקסים של שדה יחיד.

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

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

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

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

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

מצבי אינדקס

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

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

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

היקף האוסף

כברירת מחדל,

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 מעדכנת אינדקס אחד של שדה יחיד בעל סדר עולה לכל שדה שאינו מערך, אינדקס אחד של שדה יחיד בעל סדר יורד לכל שדה שאינו מערך, ואינדקס אחד של שדה יחיד שמכיל מערך בשדה המערך. כל שורה בטבלה הבאה מייצגת רשומה במסד נתונים עם שדה יחיד:

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

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

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"])

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

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

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()

רשומות אינדקס

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

הדוגמה הבאה ממחישה את הרשומות של המסמך ב-Index.

מסמך

/cities/SF

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

אינדקסים של שדה יחיד

• city_name ASC
• city_name DESC
• temperatures.summer ASC
• temperatures.summer DESC
• temperatures.winter ASC
• temperatures.winter DESC
• מערך השכונות מכיל (ASC ו-DESC)

אינדקסים מורכבים

• 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) זמין בדף פתרון הבעיות.