עימוד תוצאות החיפוש

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

אפשרויות חלוקה לדפים

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

יש שתי דרכים להטמיע שאילתות עם חלוקה לדפים ב-Spanner: חלוקה לדפים לפי מפתח (מומלץ) וחלוקה לדפים לפי היסט.

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

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

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

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

כדי לשמור על יציבות בתוצאות הדפים, האפליקציה יכולה להנפיק את כל השאילתות לדפים שונים באותה חותמת זמן. עם זאת, יכול להיות שהפעולה תיכשל אם השאילתה חורגת מתקופת השמירה של הגרסה (ברירת המחדל היא שעה). לדוגמה, השגיאה הזו מתרחשת אם הערך של version_gc הוא שעה אחת, ומשתמש הקצה אחזר את התוצאות הראשונות בשעה 13:00 ולחץ על Next בשעה 15:00.

שימוש בחלוקה לדפים שמבוססת על מפתחות

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

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

לפי הסכימה לדוגמה של Albums, השאילתה לדף הראשון נראית כך:

GoogleSQL

SELECT AlbumId, ReleaseTimestamp
FROM Albums
WHERE SEARCH(AlbumTitle_Tokens, "fifth symphony")
ORDER BY ReleaseTimestamp DESC, AlbumId
LIMIT 10;

PostgreSQL

SELECT albumid, releasetimestamp
FROM albums
WHERE spanner.search(albumtitle_tokens, 'fifth symphony')
ORDER BY releasetimestamp DESC, albumid
LIMIT 10;

העמודה AlbumId היא שובר השוויון כי ReleaseTimestamp היא לא מפתח. יכול להיות שיש שני אלבומים שונים עם אותו ערך של ReleaseTimestamp.

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

בדוגמה שלנו, AlbumId היא עמודת המפתח היחידה (בסדר עולה) והיא לא יכולה להיות NULL, אז התנאי הוא:

GoogleSQL

SELECT AlbumId, ReleaseTimestamp
FROM Albums
WHERE (ReleaseTimestamp < @last_page_release_timestamp
    OR (ReleaseTimestamp = @last_page_release_timestamp
        AND AlbumId > @last_page_album_id))
    AND SEARCH(AlbumTitle_Tokens, @p)
ORDER BY ReleaseTimestamp DESC, AlbumId ASC
LIMIT @page_size;

PostgreSQL

בדוגמה הזו נעשה שימוש בפרמטרים של שאילתה $1, $2, $3 ו-$4 שקשורים לערכים שצוינו עבור last_page_release_timestamp, last_page_album_id, query ו-page_size, בהתאמה.

SELECT albumid, releasetimestamp
FROM albums
WHERE (releasetimestamp < $1
    OR (releasetimestamp = $1
        AND albumid > $2))
    AND spanner.search(albumtitle_tokens, $3)
ORDER BY releasetimestamp DESC, albumid ASC
LIMIT $4;

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

שימוש בעימוד מבוסס-היסט

עימוד מבוסס-היסט משתמש בסעיפים LIMIT ו-OFFSET של שאילתת SQL כדי לדמות דפים. הערך LIMIT מציין את מספר התוצאות בדף. הערך של OFFSET מוגדר לאפס בדף הראשון, לגודל הדף בדף השני ולגודל הדף כפול שתיים בדף השלישי.

לדוגמה, השאילתה הבאה מאחזרת את הדף השלישי, עם גודל דף של 50:

GoogleSQL

SELECT AlbumId
FROM Albums
WHERE SEARCH(AlbumTitle_Tokens, "fifth symphony")
ORDER BY ReleaseTimestamp DESC, AlbumId
LIMIT 50 OFFSET 100;

PostgreSQL

SELECT albumid
FROM albums
WHERE spanner.search(albumtitle_tokens, 'fifth symphony')
ORDER BY releasetimestamp DESC, albumid
LIMIT 50 OFFSET 100;

הערות לגבי השימוש:

  • מומלץ מאוד להשתמש בסעיף ORDER BY כדי להבטיח סדר עקבי בין הדפים.
  • בשאילתות בסביבת הייצור, כדי לשפר את היעילות של השמירה במטמון של השאילתות, השתמשו בפרמטרים של שאילתות במקום בקבועים כדי לציין את LIMIT ו-OFFSET. מידע נוסף מופיע במאמר פרמטרים של שאילתות.

עימוד תוצאות חיפוש מדורגות

‫Spanner ממליץ על חלוקה לדפים לפי היסט בשאילתות מדורגות, שמסדרות את התוצאות לפי הערך של הפונקציה SCORE ולא לפי עמודות המפתח של הטבלה. אפשר לכלול את הציון האחרון מהדף הקודם בסעיף WHERE של הדף הבא, אבל התנאי הזה לא ניתן לחיפוש ולכן לא מספק את היתרונות של עימוד מבוסס-מפתח מבחינת עלות וביצועים. בנוסף, אי אפשר להשוות בין ערכי SCORE בגרסאות שונות של מנגנון הניקוד, ולכן עימוד מבוסס-היסט גורם לפחות דילוגים על שורות או חזרות על שורות כשגרסת מנגנון הניקוד משתנה.

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

GoogleSQL

SELECT
  AlbumId,
  SCORE(AlbumTitle_Tokens, @p) AS Score
FROM Albums
WHERE SEARCH(AlbumTitle_Tokens, @p)
ORDER BY Score DESC, AlbumId
LIMIT 2 OFFSET 0;

PostgreSQL

בדוגמה הזו נעשה שימוש בפרמטר השאילתה $1, שקשור למחרוזת השאילתה.

SELECT
  albumid,
  spanner.score(albumtitle_tokens, $1) AS score
FROM albums
WHERE spanner.search(albumtitle_tokens, $1)
ORDER BY score DESC, albumid
LIMIT 2 OFFSET 0;

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

AlbumId ציון בגרסה 1 ציון בגרסה 2
1 0.9 0.7
2 0.8 0.95
3 0.7 0.6
4 0.6 0.85

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

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

אם אתם צריכים יותר שליטה על השינוי, יש לכם שתי אפשרויות:

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

כדי להצמיד את גרסת מודל הדירוג ברמת השאילתה:

  1. מגדירים את גרסת הניקוד באופן מפורש בארגומנט options של הפונקציה SCORE. משתמשים באותה שאילתה לכל דף, כשההיסט מוגדר ל-0 בדף הראשון:

    GoogleSQL

    SELECT
      AlbumId,
      SCORE(AlbumTitle_Tokens, @p,
            options=>JSON_OBJECT('version', @score_version)) AS Score
    FROM Albums
    WHERE SEARCH(AlbumTitle_Tokens, @p)
    ORDER BY Score DESC, AlbumId
    LIMIT @page_size OFFSET @offset;
    

    PostgreSQL

    בדוגמה הזו נעשה שימוש בפרמטרים של שאילתה $1,‏ $2,‏ $3 ו-$4, שקשורים למחרוזת השאילתה, לאפשרויות הניקוד כערך JSONB כמו {"version": 2}, לגודל הדף ולהיסט, בהתאמה.

    SELECT
      albumid,
      spanner.score(albumtitle_tokens, $1, options => $2) AS score
    FROM albums
    WHERE spanner.search(albumtitle_tokens, $1)
    ORDER BY score DESC, albumid
    LIMIT $3 OFFSET $4;
    

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

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

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

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

המאמרים הבאים