בדף הזה מתוארות עסקאות ב-Spanner ומוצגים ממשקי העסקאות של Spanner לקריאה וכתיבה, לקריאה בלבד ול-DML מחולק למחיצות.
טרנזקציה ב-Spanner היא קבוצה של פעולות קריאה וכתיבה. כל הפעולות בטרנזקציה הן אטומיות, כלומר כולן מצליחות או שכולן נכשלות.
סשן משמש לביצוע טרנזקציות במסד נתונים של Spanner. סשן מייצג ערוץ תקשורת לוגי עם שירות מסד הנתונים של Spanner. בסשנים אפשר לבצע טרנזקציה אחת או כמה טרנזקציות בו-זמנית. מידע נוסף זמין במאמר סשנים.
סוגי עסקאות
Spanner תומך בסוגי הטרנזקציות הבאים, שכל אחד מהם מיועד לדפוסים ספציפיים של אינטראקציה עם נתונים:
קריאה-כתיבה: העסקאות האלה משמשות לפעולות קריאה וכתיבה, ואחריהן מתבצעת פעולת commit. הם יכולים לרכוש מנעולים. אם הן נכשלות, צריך לנסות שוב. הם מוגבלים למסד נתונים אחד, אבל הם יכולים לשנות נתונים בכמה טבלאות בתוך מסד הנתונים הזה.
לקריאה בלבד: הטרנזקציות האלה מבטיחות עקביות של הנתונים בכמה פעולות קריאה, אבל לא מאפשרות לשנות את הנתונים. הן מבוצעות בחותמת זמן שנקבעת על ידי המערכת כדי לשמור על עקביות, או בחותמת זמן קודמת שהמשתמש הגדיר. בניגוד לעסקאות קריאה-כתיבה, הן לא דורשות פעולת commit או נעילות. עם זאת, יכול להיות שהן יושהו עד לסיום פעולות הכתיבה שמתבצעות.
DML מחולק למחיצות: סוג העסקה הזה מריץ פקודות DML כפעולות DML מחולקות למחיצות. הוא מותאם להרצת פקודות DML בקנה מידה נרחב, אבל עם הגבלות שמוודאות שהפקודה היא אידמפוטנטית וניתנת לחלוקה למחיצות באופן שמאפשר להריץ אותה בנפרד ממחיצות אחרות. אם יש לכם הרבה פעולות כתיבה שלא דורשות טרנזקציה אטומית, כדאי להשתמש בכתיבה באצווה. מידע נוסף זמין במאמר שינוי נתונים באמצעות כתיבה באצווה.
עסקאות קריאה וכתיבה
עסקת קריאה-כתיבה מורכבת מאפס או יותר הצהרות קריאה או שאילתה, ואחריהן בקשת commit. בכל שלב לפני בקשת ה-commit, הלקוח יכול לשלוח בקשת החזרה למצב קודם כדי לבטל את הטרנזקציה.
בידוד שמאפשר סריאליזציה
כשמשתמשים ברמת הבידוד שניתנת להמשכה כברירת מחדל עם בקרת בו-זמניות פסימית, עסקאות קריאה-כתיבה קוראות, משנות וכותבות נתונים באופן אטומי. לסוג הזה של טרנזקציה יש עקביות עם העולם האמיתי.
כשמשתמשים בעסקאות קריאה-כתיבה, מומלץ לצמצם את משך הזמן שבו העסקה פעילה. ככל שמשך העסקה קצר יותר, כך הנעילות נמשכות פחות זמן, מה שמגדיל את הסבירות לביצוע מוצלח ומפחית את התחרות. הסיבה לכך היא שנעילות לטווח ארוך עלולות להוביל למבוי סתום ולביטול טרנזקציות. Spanner מנסה להשאיר את נעילות הקריאה פעילות כל עוד הטרנזקציה ממשיכה לבצע קריאות, והטרנזקציה לא הסתיימה באמצעות commit או roll back. אם הלקוח לא פעיל במשך תקופות ארוכות, יכול להיות ש-Spanner ישחרר את הנעילות של העסקה ויבטל אותה.
כדי לבצע פעולת כתיבה שתלויה בפעולת קריאה אחת או יותר, משתמשים בטרנזקציית קריאה-כתיבה:
- אם אתם צריכים לבצע פעולת כתיבה אחת או יותר באופן אטומי, בצעו את פעולות הכתיבה האלה באותה טרנזקציית קריאה-כתיבה. לדוגמה, אם אתם מעבירים 200$ מחשבון א' לחשבון ב', בצעו את שתי פעולות הכתיבה (הפחתת 200 $מחשבון א' והוספת 200 $לחשבון ב') ואת פעולות הקריאה של היתרות הראשוניות בחשבון באותה טרנזקציה.
- אם רוצים להכפיל את היתרה בחשבון א', צריך לבצע את פעולות הקריאה והכתיבה באותה טרנזקציה. כך המערכת קוראת את היתרה לפני שהיא מכפילה ומעדכנת אותה.
- אם פעולות הכתיבה תלויות בפעולות הקריאה, צריך לבצע את שתיהן באותה טרנזקציית קריאה-כתיבה, גם אם פעולות הכתיבה לא מתבצעות. לדוגמה, אם רוצים להעביר 200 $מחשבון א' לחשבון ב' רק אם היתרה בחשבון א' גדולה מ-500$, צריך לכלול את פעולת הקריאה של היתרה בחשבון א' ואת פעולות הכתיבה המותנות באותה טרנזקציה, גם אם ההעברה לא מתבצעת.
כדי לבצע פעולות קריאה, צריך להשתמש בשיטת קריאה אחת או בטרנזקציה לקריאה בלבד:
- אם אתם מבצעים רק פעולות קריאה, ואתם יכולים לבטא את פעולת הקריאה באמצעות שיטת קריאה אחת, השתמשו בשיטת הקריאה האחת או בטרנזקציה לקריאה בלבד. בניגוד לעסקאות קריאה-כתיבה, קריאות בודדות לא רוכשות נעילות.
לחלופין, אתם יכולים להגדיר בידוד שניתן לסדרתיות כדי להשתמש בבו-זמניות אופטימית. בקרת בו-זמניות אופטימית מניחה שהתנגשויות הן נדירות. פעולות קריאה ושאילתות, אפילו בתוך טרנזקציית קריאה-כתיבה, מתבצעות בלי לרכוש נעילות. בבידוד שניתן לסדרתיות, הקריאות מאומתות בזמן השמירה. כך אפשר לוודא שאף טרנזקציה אחרת שבוצעה במקביל לא שינתה את הנתונים שנקראו קודם על ידי הטרנזקציה.
בידוד קריאה שניתן לחזור עליה
ב-Spanner, בידוד קריאה חוזרת מיושם באמצעות טכניקה שנקראת בידוד snapshot. בידוד מסוג Repeatable read מבטיח שכל פעולות הקריאה בטרנזקציה יהיו עקביות עם מסד הנתונים כפי שהיה בתחילת הטרנזקציה. היא גם מבטיחה שכתיבות בו-זמניות באותם נתונים יצליחו רק אם אין התנגשויות.
בזכות בקרת בו-זמניות אופטימית שמוגדרת כברירת מחדל, פעולות כתיבה לא רוכשות נעילות עד לזמן השמירה. אם יש התנגשות עם הנתונים שנכתבו או בגלל אירועים זמניים ב-Spanner, כמו הפעלה מחדש של השרת, יכול להיות ש-Spanner עדיין יבטל טרנזקציות. מכיוון שפעולות קריאה בעסקאות קריאה-כתיבה לא רוכשות נעילות בבידוד קריאה חוזרת, אין הבדל בין ביצוע פעולות לקריאה בלבד בתוך עסקת קריאה בלבד או עסקת קריאה-כתיבה.
משתמשים בבקרת בו-זמניות פסימית עם קריאה חוזרת כדי לרכוש נעילות בלעדיות לנתונים שנקראו באמצעות משפט FOR UPDATE או הרמז lock_scanned_ranges=exclusive, ולנתונים שנכתבו על ידי שאילתות DML. הסמנטיקה הזו דומה יותר להתנהגות הנעילה של בידוד קריאה חוזרת במסדי נתונים אחרים. בבקרת בו-זמניות פסימית, כל פעולות הקריאה מוגשות בתמונת המצב, כך שהעסקאות עשויות להתבטל אם עסקאות בו-זמניות מעדכנות את נתוני הקריאה. עם זאת, היא מונעת מעסקאות בו-זמניות לעדכן את הנתונים הנעולים מרגע קבלת הנעילות ועד לזמן השמירה, מה שעשוי להפחית את הסיכוי להתנגשויות כתיבה-כתיבה.
כדאי להשתמש בעסקאות קריאה-כתיבה בבידוד קריאה חוזרת בתרחישים הבאים:
- עומס העבודה הוא בעיקר קריאה, ויש מעט התנגשויות כתיבה.
- באפליקציה יש צווארי בקבוק בביצועים בגלל עיכובים שנובעים מתחרות על נעילות ומביטולי טרנזקציות שנגרמים על ידי טרנזקציות ישנות יותר עם עדיפות גבוהה יותר, שפוגעות בטרנזקציות חדשות יותר עם עדיפות נמוכה יותר כדי למנוע מבוי סתום פוטנציאלי (wound-wait).
- האפליקציה לא דורשת את ההבטחות המחמירות יותר שמספקת רמת הבידוד הניתנת להמשכה.
כדאי להשתמש בבידוד של קריאה חוזרת עם בו-זמניות פסימית לעומסי עבודה שבהם פקודות FOR UPDATE ו-DML רוכשות נעילות.
כשמבצעים פעולת כתיבה שתלויה בפעולת קריאה אחת או יותר, יכול להיות שתתרחש הטיית כתיבה בבידוד של קריאה חוזרת. הטיית כתיבה נובעת מסוג מסוים של עדכון בו-זמני, שבו כל עדכון מתקבל בנפרד, אבל ההשפעה המשולבת שלהם פוגעת בתקינות הנתונים של האפליקציה.
לכן, חשוב לוודא שאתם מבצעים קריאות שהן חלק מהקטע הקריטי של טרנזקציה עם פסוקית FOR UPDATE או רמז lock_scanned_ranges=exclusive כדי להימנע מהטיית כתיבה. מידע נוסף זמין במאמר קונפליקטים של קריאה-כתיבה ותקינות, ובדוגמה שמופיעה במאמר סמנטיקה של קריאה-כתיבה.
ממשק
ספריות הלקוח של Spanner מספקות ממשק להרצת גוף עבודה בתוך טרנזקציית קריאה-כתיבה, עם ניסיונות חוזרים לביטולי טרנזקציות. יכול להיות שטרנזקציה תדרוש כמה ניסיונות חוזרים לפני שהיא תתבצע.
יש כמה מצבים שיכולים לגרום לביטול של טרנזקציות. לדוגמה, אם שני טרנזקציות מנסות לשנות נתונים בו-זמנית, יכול להתרחש מבוי סתום. במקרים כאלה, Spanner מבטל טרנזקציה אחת כדי לאפשר לשנייה להמשיך. לפעמים, גם אירועים זמניים ב-Spanner יכולים לגרום לביטול של טרנזקציות.
כל העסקאות לקריאה ולכתיבה מספקות את מאפייני ה-ACID של מסדי נתונים רלציוניים.
מכיוון שהעסקאות הן אטומיות, עסקה שבוטלה לא משפיעה על מסד הנתונים. ספריות הלקוח של Spanner מנסות לבצע מחדש עסקאות כאלה באופן אוטומטי. אם אתם לא משתמשים בספריות הלקוח, נסו שוב את הטרנזקציה בעצמכם כדי לשפר את שיעורי ההצלחה. כל ניסיון חוזר שגורם לשגיאת ABORTED מגדיל את עדיפות הנעילה של הטרנזקציה. כדי לשמור על עדיפות הנעילה הזו, צריך לנסות שוב את העסקה באותו סשן. אם אתם משתמשים בסשנים מרובי-ערוצים, צריך גם להגדיר את TransactionOptions.ReadWrite.multiplexed_session_previous_transaction_id למזהה של העסקה שבוטלה כשמתחילים את הניסיון החוזר. בנוסף, מנהלי ההתקנים של לקוחות Spanner כוללים לוגיקה פנימית של ניסיון חוזר של טרנזקציות, שמסתירה שגיאות זמניות על ידי הפעלה מחדש של הטרנזקציה.
אם אתם משתמשים בסשנים מרובי-ערוצים, ספריות הלקוח של Spanner שולחות את המזהה של העסקה שבוטלה בכל ניסיון חוזר. כך הטרנזקציה שמנסים לבצע מחדש שומרת על עדיפות הנעילה שלה, למרות שטרנזקציות אחרות משתפות את אותו סשן.
כשמשתמשים בטרנזקציה בספריית לקוח של Spanner, מגדירים את גוף הטרנזקציה כאובייקט פונקציה. הפונקציה הזו כוללת את פעולות הקריאה והכתיבה שבוצעו בטבלה אחת או יותר של מסד הנתונים. ספריית הלקוח של Spanner מריצה את הפונקציה הזו שוב ושוב עד שהטרנזקציה מתבצעת או עד שמתקבלת שגיאה שלא מאפשרת ניסיון חוזר.
לולאת הניסיון החוזר הזו נפרדת מהגדרות הזמן הקצוב לתפוגה והניסיון החוזר של קריאות RPC נפרדות, ומשך ברירת המחדל שלה תלוי בספריית הלקוח. כדי להגביל את משך הזמן הכולל של עסקה, כולל ניסיונות חוזרים, קראו את המאמר הגדרת זמן קצוב לתפוגה של עסקה.
דוגמה
נניח שיש לכם עמודה MarketingBudget בטבלה Albums:
CREATE TABLE Albums ( SingerId INT64 NOT NULL, AlbumId INT64 NOT NULL, AlbumTitle STRING(MAX), MarketingBudget INT64 ) PRIMARY KEY (SingerId, AlbumId);
מחלקת השיווק מבקשת מכם להעביר 200,000 $מהתקציב של Albums
(2, 2) אל Albums (1, 1), אבל רק אם הכסף זמין בתקציב של האלבום הזה. לפעולה הזו צריך להשתמש בטרנזקציית קריאה-כתיבה עם נעילה, כי יכול להיות שהטרנזקציה תבצע כתיבה בהתאם לתוצאה של קריאה.
בדוגמאות הבאות של ספריית הלקוח מוסבר איך לבצע טרנזקציית קריאה-כתיבה באמצעות רמת הבידוד שניתנת להמרה לסדרה כברירת מחדל:
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
במאמר שימוש ברמת בידוד של קריאה חוזרת מוסבר איך לבצע עסקת קריאה-כתיבה באמצעות בידוד של קריאה חוזרת.
סמנטיקה
בקטע הזה מתוארת הסמנטיקה של עסקאות קריאה-כתיבה ב-Spanner.
מאפיינים
בידוד שמאפשר סריאליזציה הוא רמת הבידוד שמוגדרת כברירת מחדל ב-Spanner. בבידוד שניתן לסריאליזציה, Spanner מספק ללקוחות את הערבויות המחמירות ביותר לבקרת בו-זמניות של עסקאות, עקביות עם העולם האמיתי. עסקת קריאה-כתיבה מבצעת קבוצה של קריאות וכתיבות באופן אטומי. פעולות כתיבה יכולות להמשיך בלי להיחסם על ידי טרנזקציות לקריאה בלבד. חותמת הזמן שבה מתבצעות עסקאות קריאה-כתיבה תואמת לזמן שחלף. סדר הסריאליזציה תואם לסדר של חותמות הזמן.
בזכות המאפיינים האלה, מפתחי אפליקציות יכולים להתמקד בתקינות של כל טרנזקציה בנפרד, בלי לדאוג לגבי הגנה על הביצוע שלה מפני טרנזקציות אחרות שעשויות להתבצע בו-זמנית.
אפשר גם לבצע עסקאות קריאה-כתיבה באמצעות בידוד קריאה חוזרת. בידוד קריאה חוזרת מבטיח שכל פעולות הקריאה בטרנזקציה יראו תמונת מצב עקבית וחזקה של מסד הנתונים כפי שהיה בתחילת הטרנזקציה. מידע נוסף זמין במאמר בידוד קריאה חוזרת.
עסקאות קריאה-כתיבה עם בידוד שניתן לסדרתיות
אחרי ביצוע מוצלח של טרנזקציה שמכילה סדרה של קריאות וכתיבות בבידוד שניתן לסדר כברירת מחדל, מתקיימים התנאים הבאים:
- הטרנזקציה מחזירה ערכים שמשקפים תמונת מצב עקבית בחותמת הזמן של ה-commit של הטרנזקציה.
- שורות או טווחים ריקים נשארים ריקים בזמן השמירה.
- העסקה מבצעת את כל פעולות הכתיבה בחותמת הזמן של ביצוע העסקה.
- אף עסקה לא יכולה לראות את פעולות הכתיבה עד שהעסקה מתבצעת.
מנהלי ההתקנים של לקוחות Spanner כוללים לוגיקה של ניסיון חוזר של טרנזקציות, שמסתירה שגיאות זמניות על ידי הפעלה מחדש של הטרנזקציה ואימות הנתונים שהלקוח רואה.
התוצאה היא שכל פעולות הקריאה והכתיבה נראות כאילו התרחשו בנקודת זמן אחת, גם מנקודת המבט של הטרנזקציה עצמה וגם מנקודת המבט של קוראים וכותבים אחרים במסד הנתונים של Spanner. כלומר, פעולות הקריאה והכתיבה מתרחשות באותה חותמת זמן. לדוגמה, ראו יכולת סריאליזציה ועקביות עם העולם האמיתי.
עסקאות קריאה-כתיבה עם בידוד קריאה חוזרת
אחרי ביצוע מוצלח של טרנזקציה עם בידוד קריאה חוזרת, חלים הכללים הבאים:
- הטרנזקציה מחזירה ערכים שמשקפים תמונת מצב עקבית של מסד הנתונים. תמונת המצב נוצרת בדרך כלל במהלך פעולת הטרנזקציה הראשונה, ויכול להיות שהיא לא תהיה זהה לחותמת הזמן של ה-commit.
- מכיוון שקריאה חוזרת מיושמת באמצעות בידוד snapshot, העסקה מבצעת commit לכל פעולות הכתיבה בחותמת הזמן של ה-commit של העסקה רק אם קבוצת הכתיבה לא השתנתה בין חותמת הזמן של ה-snapshot של העסקה לבין חותמת הזמן של ה-commit.
- עסקאות אחרות לא רואות את פעולות הכתיבה עד שהעסקה מתבצעת.
בידוד של טרנזקציות קריאה-כתיבה עם פעולות לקריאה בלבד
כשעסקת קריאה-כתיבה מבצעת רק פעולות קריאה, היא מספקת הבטחות עקביות דומות לאלה של עסקת קריאה בלבד. כל פעולות הקריאה בטרנזקציה מחזירות נתונים מחותמת זמן עקבית, כולל אישור של שורות שלא קיימות.
הבדל אחד הוא כשטרנזקציית קריאה-כתיבה מבצעת commit בלי לבצע פעולת כתיבה. בתרחיש כזה, אין ערובה לכך שהנתונים שנקראו בטרנזקציה לא השתנו במסד הנתונים בין פעולת הקריאה לבין ה-commit של הטרנזקציה.
כדי לוודא את עדכניות הנתונים ולאמת שהנתונים לא השתנו מאז השליפה האחרונה, נדרשת קריאה נוספת. אפשר לבצע את הקריאה החוזרת הזו בטרנזקציית קריאה-כתיבה אחרת או באמצעות קריאה חזקה.
כדי להשיג יעילות אופטימלית, אם עסקה מבצעת קריאות בלבד, השתמשו בעסקה לקריאה בלבד במקום בעסקה לקריאה ולכתיבה, במיוחד כשמשתמשים בבידוד שניתן להפוך לסדרתי.
מה ההבדל בין יכולת סריאליזציה ועקביות עם העולם האמיתי לבין קריאה חוזרת (repeatable read)
כברירת מחדל, Spanner מציע הבטחות חזקות לגבי טרנזקציות, כולל יכולת סריאליזציה ועקביות עם העולם האמיתי. המאפיינים האלה מבטיחים שהנתונים יישארו עקביים ושהפעולות יתרחשו בסדר צפוי, גם בסביבה מבוזרת.
הסדרתיות מבטיחה שכל הטרנזקציות יתבצעו אחת אחרי השנייה בסדר עוקב, גם אם הן מעובדות בו-זמנית. כדי לעשות את זה, Spanner מקצה חותמות זמן של ביצוע לעסקאות, שמשקפות את הסדר שבו הן בוצעו.
Spanner מספק הבטחה חזקה עוד יותר, שנקראת עקביות עם העולם האמיתי. כלומר, לא רק שהטרנזקציות מתבצעות בסדר שמשתקף בחותמות הזמן של הביצוע, אלא שחותמות הזמן האלה גם תואמות לזמן בעולם האמיתי. כך אפשר להשוות בין חותמות הזמן של ההתחייבות לבין הזמן בפועל, ולקבל תצוגה עקבית ומסודרת באופן גלובלי של הנתונים.
למעשה, אם עסקה Txn1 מתבצעת לפני עסקה אחרת Txn2 בזמן אמת, חותמת הזמן של ביצוע העסקה Txn1 מוקדמת יותר מחותמת הזמן של ביצוע העסקה Txn2.
לדוגמה:
בתרחיש הזה, במהלך ציר הזמן t:
- הטרנזקציה
Txn1קוראת את הנתוניםA, מכינה כתיבה ל-Aואז מבצעת commit בהצלחה. - העסקה
Txn2מתחילה אחרי ש-Txn1מתחילה. הוא קורא את הנתוניםBואז קורא את הנתוניםA.
למרות ש-Txn2 התחילה לפני ש-Txn1 הסתיימה, Txn2 רואה את השינויים שבוצעו על ידי Txn1 ב-A. הסיבה לכך היא ש-Txn2 קורא את A אחרי ש-Txn1 מבצע את הכתיבה שלו ל-A.
למרות שזמן הביצוע של Txn1 ו-Txn2 עשוי לחפוף, חותמות הזמן של ה-commit שלהן, c1 ו-c2 בהתאמה, אוכפות סדר טרנזקציות לינארי. זה אומר:
- נראה שכל פעולות הקריאה והכתיבה ב-
Txn1התרחשו בנקודת זמן אחת,c1. - נראה שכל פעולות הקריאה והכתיבה ב-
Txn2התרחשו בנקודת זמן אחת,c2. - חשוב לציין ש-
c1מוקדם יותר מ-c2לכתיבות שבוצעו, גם אם הכתיבות התרחשו במכונות שונות. אםTxn2מבצע רק קריאות,c1מוקדם יותר או באותו זמן כמוc2.
הסדר החזק הזה אומר שאם פעולת קריאה עוקבת מזהה את ההשפעות של Txn2, היא גם מזהה את ההשפעות של Txn1. המאפיין הזה נכון לכל העסקאות שבוצעו בהצלחה.
לעומת זאת, אם משתמשים בבידוד של קריאה חוזרת, התרחיש הבא מתרחש באותן טרנזקציות:
-
Txn1מתחיל בקריאת הנתוניםA, ויוצר תמונת מצב משלו של מסד הנתונים באותו רגע. - לאחר מכן,
Txn2מתחיל, קורא את הנתוניםBויוצר תמונת מצב משלו. - לאחר מכן,
Txn1משנה את הנתוניםAומאשר את השינויים. -
Txn2מנסה לקרוא נתוניםA. חשוב לציין: מכיוון שהפעולה מתבצעת בתמונת מצב מוקדמת יותר,Txn2לא רואה את העדכון ש-Txn1ביצע זה עתה ב-A. Txn2קורא את הערך הישן יותר. -
Txn2משנה את הנתוניםBומאשר את השינויים.
בתרחיש הזה, כל טרנזקציה פועלת על תמונת מצב עקבית משלה של מסד הנתונים, שנוצרה ברגע שהטרנזקציה התחילה. הרצף הזה יכול להוביל לאנומליה של הטיית כתיבה אם הכתיבה ל-B על ידי Txn2 הייתה תלויה באופן לוגי בערך שהיא קראה מ-A. למעשה, Txn2 ביצע את העדכונים שלו על סמך מידע מיושן, והכתיבה הבאה שלו עלולה להפר אי-משתנה ברמת האפליקציה. כדי למנוע את התרחיש הזה, כדאי להשתמש ב-SELECT...FOR UPDATE לבידוד קריאה חוזרת או ליצור אילוצי בדיקה בסכימה.
התחייבויות לקריאה ולכתיבה במקרה של כשל בטרנזקציה
אם קריאה לביצוע טרנזקציה נכשלת, ההבטחות לקריאה ולכתיבה תלויות בשגיאה שגרמה לקריאת ה-commit הבסיסית להיכשל.
יכול להיות ש-Spanner יבצע את הפעולות של טרנזקציה כמה פעמים באופן פנימי. אם ניסיון הביצוע נכשל, השגיאה שמוחזרת מציינת את התנאים שהתרחשו ומציינת את ההתחייבויות שאתם מקבלים. עם זאת, אם Spanner מנסה שוב לבצע את העסקה, כל תופעות הלוואי מהפעולות שלה (לדוגמה, שינויים במערכות חיצוניות או במצב מערכת מחוץ למסד נתונים של Spanner) עשויות להתרחש כמה פעמים.
כשטרנזקציה ב-Spanner נכשלת, ההתחייבויות שאתם מקבלים לגבי קריאות וכתיבות תלויות בשגיאה הספציפית שמתרחשת במהלך פעולת ה-commit.
לדוגמה, הודעת שגיאה כמו "Row Not Found" או "Row Already Exists" מצביעה על בעיה במהלך הכתיבה של מוטציות במאגר נתונים זמני. לדוגמה, אם הלקוח מנסה לעדכן שורה שלא קיימת. במקרים הבאים:
- הקריאות עקביות: כל הנתונים שנקראים במהלך הטרנזקציה יהיו עקביים עד לנקודה שבה מתרחשת השגיאה.
- פעולות הכתיבה לא מוחלות: המוטציות שהטרנזקציה ניסתה לבצע לא נשמרות במסד הנתונים.
- עקביות בשורות: אי-הקיום (או המצב הקיים) של השורה שגרמה לשגיאה עקבי עם פעולות הקריאה שבוצעו בטרנזקציה.
אתם יכולים לבטל פעולות קריאה אסינכרוניות ב-Spanner בכל שלב, בלי להשפיע על פעולות אחרות שמתבצעות באותה טרנזקציה. הגמישות הזו שימושית אם פעולה ברמה גבוהה יותר מבוטלת, או אם אתם מחליטים לבטל קריאה על סמך תוצאות ראשוניות.
עם זאת, חשוב להבין ששליחת בקשה לביטול פעולת קריאה לא מבטיחה שהיא תסתיים באופן מיידי. אחרי בקשת ביטול, יכול להיות שפעולת הקריאה עדיין:
- השלמה: יכול להיות שפעולת הקריאה תסתיים ותחזיר תוצאות לפני שהביטול ייכנס לתוקף.
- נכשל מסיבה אחרת: הקריאה יכולה להסתיים בגלל שגיאה אחרת, כמו ביטול.
- החזרת תוצאות חלקיות: יכול להיות שהקריאה תחזיר תוצאות חלקיות, שיאומתו כחלק מתהליך האישור של הטרנזקציה.
ביטול של פעולת commit מבטל את כל הטרנזקציה, אלא אם כבר בוצע commit לטרנזקציה או שהיא נכשלה מסיבה אחרת.
אטומיות, עקביות, עמידות
בנוסף לבידוד, Spanner מספק את שאר מאפייני ה-ACID:
- אטומיות: טרנזקציה נחשבת אטומית אם כל הפעולות שלה הושלמו בהצלחה, או אם אף אחת מהן לא הושלמה. אם פעולה כלשהי בטרנזקציה נכשלת, כל הטרנזקציה חוזרת למצב המקורי שלה כדי לשמור על תקינות הנתונים.
- עקביות: טרנזקציה חייבת לשמור על תקינות הכללים והאילוצים של מסד הנתונים. אחרי שהטרנזקציה מסתיימת, מסד הנתונים צריך להיות במצב תקין, בהתאם לכללים שהוגדרו מראש.
- עמידות: אחרי שטרנזקציה מתבצעת, השינויים שלה נשמרים באופן קבוע במסד הנתונים, גם במקרה של כשלים במערכת, הפסקות חשמל או שיבושים אחרים.
ביצועים
בקטע הזה מתוארות בעיות שמשפיעות על הביצועים של טרנזקציות קריאה-כתיבה.
בקרת בו-זמניות באמצעות נעילה
כברירת מחדל, Spanner מאפשר לכמה לקוחות לקיים אינטראקציה עם אותו מסד נתונים בו-זמנית ברמת הבידוד שניתנת להמרה לסדרה (serializable) שמוגדרת כברירת מחדל. כדי לשמור על עקביות הנתונים בטרנזקציות בו-זמניות, ל-Spanner יש מנגנון נעילה שמשתמש גם בנעילות משותפות וגם בנעילות בלעדיות. נעילות הקריאה האלה נרכשות רק לעסקאות שמאפשרות סריאליזציה, ולא לעסקאות שמשתמשות בבידוד קריאה שניתן לחזור עליו.
כשטרנזקציה ניתנת לסריאליזציה מבצעת פעולת קריאה, Spanner רוכש נעילות קריאה משותפות על הנתונים הרלוונטיים. הנעילות המשותפות האלה מאפשרות לפעולות קריאה אחרות שמתרחשות בו-זמנית לגשת לאותם נתונים. הפעולות בו-זמנית נמשכות עד שהטרנזקציה מתכוננת לביצוע השינויים.
בבידוד שניתן לסדרתיות, במהלך שלב האישור, כשמחילים את פעולות הכתיבה, העסקה מנסה לשדרג את הנעילות שלה לנעילות בלעדיות. כדי לעשות את זה, Spanner מבצע את הפעולות הבאות:
- חוסמת כל בקשה חדשה לנעילת קריאה משותפת בנתונים המושפעים.
- ממתין עד שכל נעילות הקריאה המשותפות הקיימות בנתונים האלה ישוחררו.
- אחרי שכל נעילות הקריאה המשותפות מתבטלות, היא מפעילה נעילה בלעדית, שמעניקה לה גישה יחידה לנתונים למשך זמן הכתיבה.
לעומת זאת, ב-Spanner, לא בידוד שמאפשר סריאליזציה עם בקרת בו-זמניות אופטימית ולא בידוד של קריאה חוזרת עם בקרת בו-זמניות אופטימית רוכשים נעילות במהלך ביצוע הטרנזקציה. בזמן האישור, העסקה מקבלת נעילות בלעדיות לנתונים שנכתבו. יכול להיות שהעסקה תצטרך להמתין לנעילות אם עסקה בו-זמנית גם מבצעת כתיבה לאותם נתונים.
בבידוד של קריאה חוזרת עם בו-זמניות פסימית, נעילות בלעדיות נרכשות לנתונים שנקראים על ידי שאילתות שמשתמשות ב-FOR UPDATE או ברמז lock_scanned_ranges=exclusive, ולנתונים שנכתבים באמצעות שאילתות DML.
לכן, אין צורך לרכוש נעילות נוספות בזמן השמירה.
הערות לגבי נעילות:
- רמת הפירוט: Spanner מחיל נעילות ברמת הפירוט של השורה והעמודה. כלומר, אם טרנזקציה
T1נועלת את העמודהAבשורהalbumid, טרנזקציהT2עדיין יכולה לכתוב בו-זמנית בעמודהBבאותה שורהalbumidבלי התנגשות. כתיבה ללא קריאה:
- אם אין קריאות בעסקה, יכול להיות ש-Spanner לא ידרוש נעילה בלעדית לכתיבה ללא קריאה. במקום זאת, יכול להיות שהיא תשתמש בנעילה משותפת של כותב. הסיבה לכך היא שסדר היישום של פעולות כתיבה ללא קריאה נקבע לפי חותמות הזמן של ה-commit שלהן, וכך כמה כותבים יכולים לפעול על אותו פריט בו-זמנית ללא התנגשות. נעילה בלעדית נדרשת רק אם הטרנזקציה קוראת קודם את הנתונים שהיא מתכוונת לכתוב.
- בבידוד של קריאה חוזרת, טרנזקציות בדרך כלל מקבלות נעילות בלעדיות לתאים שנכתבו בזמן האישור.
אינדקסים משניים לחיפושי שורות: בבידוד שניתן לסריאליזציה, כשמבצעים קריאות בתוך טרנזקציית קריאה-כתיבה, שימוש באינדקסים משניים יכול לשפר משמעותית את הביצועים. כשמשתמשים באינדקסים משניים כדי להגביל את השורות שנסרקות לטווח קטן יותר, Spanner נועל פחות שורות בטבלה, וכך מאפשר שינוי בו-זמני של יותר שורות מחוץ לטווח הספציפי הזה.
גישה בלעדית למשאבים חיצוניים: הנעילות הפנימיות של Spanner נועדו לשמור על עקביות הנתונים במסד הנתונים של Spanner עצמו. אל תשתמשו בהם כדי להבטיח גישה בלעדית למשאבים מחוץ ל-Spanner. יכול להיות ש-Spanner יבטל טרנזקציות מסיבות שונות, כולל אופטימיזציות פנימיות של המערכת כמו העברת נתונים בין משאבי מחשוב. אם מתבצע ניסיון חוזר לטרנזקציה (באופן מפורש על ידי קוד האפליקציה או באופן משתמע על ידי ספריות לקוח כמו מנהל ההתקן של Spanner JDBC), הנעילות מובטחות רק במהלך הניסיון המוצלח לביצוע commit.
נתונים סטטיסטיים של נעילות: כדי לאבחן ולחקור התנגשויות של נעילות במסד הנתונים, אתם יכולים להשתמש בכלי לבדיקה פנימית Lock statistics.
זיהוי מבוי סתום
Spanner מזהה מצבים שבהם כמה טרנזקציות עלולות להגיע למבוי סתום, ומאלץ את כל הטרנזקציות להתבטל, חוץ מאחת. נניח ש:
Txn1 מחזיק בנעילה של רשומה A וממתין לנעילה של רשומה B, ו-Txn2 מחזיק בנעילה של רשומה B וממתין לנעילה של רשומה A. כדי לפתור את הבעיה, צריך לבטל את אחת מהעסקאות, לשחרר את הנעילה שלה ולאפשר לשנייה להמשיך.
Spanner משתמש באלגוריתם wound-wait הרגיל לזיהוי מבוי סתום. מאחורי הקלעים, Spanner עוקב אחרי הגיל של כל טרנזקציה שמבקשת נעילות מתנגשות. הוא מאפשר לעסקאות ישנות יותר לבטל עסקאות חדשות יותר. עסקה ישנה יותר היא עסקה שהקריאה, השאילתה או ה-commit המוקדמים ביותר שלה התרחשו מוקדם יותר.
כך, Spanner מבטיח שכל טרנזקציה תרכוש בסופו של דבר נעילות אחרי שהיא תהיה ישנה מספיק כדי לקבל עדיפות גבוהה יותר. לדוגמה, עסקה ישנה יותר שצריכה נעילה משותפת של כותב יכולה לבטל עסקה חדשה יותר שמחזיקה בנעילה משותפת של קורא.
הרצה מבוזרת
Spanner יכול לבצע טרנזקציות על נתונים שמתפרסים על פני כמה שרתים, אבל היכולת הזו כרוכה בעלות ביצועים בהשוואה לטרנזקציות בשרת יחיד.
אילו סוגי עסקאות יכולים להיות מפוצלים? Spanner יכול לחלק את האחריות על שורות במסד הנתונים בין הרבה שרתים. בדרך כלל, שורה והשורות התואמות לה בטבלה המשולבת מוגשות על ידי אותו שרת, כמו גם שתי שורות באותה טבלה עם מפתחות קרובים. Spanner יכול לבצע טרנזקציות בשורות בשרתים שונים. עם זאת, ככלל, טרנזקציות שמשפיעות על שורות רבות שנמצאות באותו מיקום הן מהירות וזולות יותר מאלה שמשפיעות על שורות רבות שמפוזרות במסד הנתונים או בטבלה גדולה.
הטרנזקציות הכי יעילות ב-Spanner כוללות רק את פעולות הקריאה והכתיבה שצריך להחיל באופן אטומי. העסקאות מתבצעות הכי מהר כשכל פעולות הקריאה והכתיבה ניגשות לנתונים באותו חלק של מרחב המפתחות.
עסקאות לקריאה בלבד
בנוסף לנעילת עסקאות לקריאה ולכתיבה, Spanner מציע עסקאות לקריאה בלבד.
משתמשים בטרנזקציה לקריאה בלבד כשצריך לבצע יותר מקריאה אחת באותה חותמת זמן. אם אתם יכולים לבטא את הקריאה באמצעות אחת משיטות הקריאה הבודדת של Spanner, כדאי להשתמש בשיטת הקריאה הבודדת הזו במקום זאת. הביצועים של שימוש בקריאה אחת כזו צריכים להיות דומים לביצועים של קריאה אחת שמתבצעת בטרנזקציה לקריאה בלבד.
אם אתם קוראים כמות גדולה של נתונים, כדאי להשתמש במחיצות כדי לקרוא את הנתונים במקביל.
מכיוון שעסקאות לקריאה בלבד לא כותבות, הן לא מחזיקות נעילות ולא חוסמות עסקאות אחרות. עסקאות לקריאה בלבד צופות בתחילית עקבית של היסטוריית ה-commit של העסקה, כך שהאפליקציה תמיד מקבלת נתונים עקביים.
ממשק
ב-Spanner יש ממשק להרצת גוף עבודה בהקשר של טרנזקציה לקריאה בלבד, עם ניסיונות חוזרים לביטולי טרנזקציות.
דוגמה
בדוגמה הבאה מוסבר איך להשתמש בעסקה לקריאה בלבד כדי לקבל נתונים עקביים לשתי קריאות באותה חותמת זמן:
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
סמנטיקה
בקטע הזה מתוארת הסמנטיקה של טרנזקציות לקריאה בלבד.
עסקאות לקריאה בלבד של תמונת מצב
כשעסקה לקריאה בלבד מתבצעת ב-Spanner, היא מבצעת את כל פעולות הקריאה שלה בנקודת זמן לוגית אחת. כלומר, גם העסקה לקריאה בלבד וגם כל קורא או כותב אחר שפועלים בו-זמנית רואים תמונת מצב עקבית של מסד הנתונים באותו רגע ספציפי.
העסקאות האלה לקריאה בלבד של תמונת מצב מציעות גישה פשוטה יותר לקריאות עקביות בהשוואה לעסקאות לקריאה ולכתיבה עם נעילה. אלו הסיבות לכך:
- ללא נעילות: טרנזקציות לקריאה בלבד לא רוכשות נעילות. במקום זאת, הן פועלות על ידי בחירת חותמת זמן של Spanner והרצת כל פעולות הקריאה מול הגרסה ההיסטורית הזו של הנתונים. הן לא משתמשות בנעילות, ולכן הן לא חוסמות טרנזקציות של קריאה וכתיבה בו-זמנית.
- ללא ביטולים: העסקאות האלה אף פעם לא מבוטלות. הן עלולות להיכשל אם חותמת הזמן לקריאה שנבחרה נאספה על ידי איסוף הזבל, אבל מדיניות ברירת המחדל של איסוף הזבל ב-Spanner בדרך כלל נדיבה מספיק כדי שרוב האפליקציות לא ייתקלו בבעיה הזו.
- אין אישורים או החזרות למצב קודם: עסקאות לקריאה בלבד לא דורשות קריאות ל-
sessions.commitאו ל-sessions.rollback, ולמעשה הן לא יכולות לבצע אותן.
כדי לבצע טרנזקציית תמונת מצב, הלקוח מגדיר גבול לחותמת הזמן, שמורה ל-Spanner איך לבחור חותמת זמן לקריאה. סוגי הגבולות של חותמות הזמן כוללים:
- קריאות חזקות: הקריאות האלה מבטיחות שתראו את ההשפעות של כל הטרנזקציות שבוצעו לפני שהקריאה התחילה. כל השורות בקריאה אחת הן עקביות. עם זאת, לא ניתן לחזור על קריאות חזקות, למרות שקריאות חזקות מחזירות חותמת זמן, וניתן לחזור על קריאה באותה חותמת זמן. שתי עסקאות חזקות לקריאה בלבד שמתבצעות ברצף עשויות להניב תוצאות שונות בגלל כתיבות בו-זמניות. שאילתות על סנכרון שינויים בזרמי נתונים חייבות להשתמש בגבול הזה. פרטים נוספים זמינים במאמר TransactionOptions.ReadOnly.strong.
- זמן מדויק של נתונים לא עדכניים: האפשרות הזו מבצעת קריאות בחותמת זמן שאתם מציינים, כחותמת זמן מוחלטת או כמשך זמן של נתונים לא עדכניים ביחס לזמן הנוכחי. הוא מבטיח שתראו תחילית עקבית של היסטוריית העסקאות הגלובלית עד לחותמת הזמן הזו. הקריאה ממתינה עד לסיום כל הטרנזקציות המתנגשות שעשויות להתבצע בחותמת הזמן של הקריאה או לפניה. הוא קצת יותר מהיר ממצבי עדכניות מוגבלת, אבל יכול להיות שהוא יחזיר נתונים ישנים יותר. לפרטים נוספים, ראו TransactionOptions.ReadOnly.read_timestamp ו-TransactionOptions.ReadOnly.exact_staleness.
- עדכניות מוגבלת: Spanner בוחר את חותמת הזמן החדשה ביותר שמאפשרת לרפליקה הזמינה הקרובה ביותר להגיש את הקריאה בלי לחסום, בתוך מגבלת עדכניות שאתם מגדירים. כל השורות שמוחזרות עקביות. כמו קריאות חזקות, אי אפשר לחזור על קריאות עם גבולות מוגדרים, כי קריאות שונות עשויות להתבצע בחותמות זמן שונות, גם אם הגבולות זהים. הקריאות האלה פועלות בשני שלבים (משא ומתן על חותמת הזמן ואז הקריאה), והן בדרך כלל קצת יותר איטיות מקריאות בעבר מדויקות, אבל לעיתים קרובות הן מחזירות תוצאות עדכניות יותר. המצב הזה זמין רק לעסקאות לקריאה בלבד לשימוש חד-פעמי, כי כדי לנהל משא ומתן על חותמת הזמן צריך לדעת מראש לאילו שורות הקריאה ניגשת. לפרטים נוספים, ראו TransactionOptions.ReadOnly.max_staleness ו-TransactionOptions.ReadOnly.min_read_timestamp.
גם קריאות מדויקות וגם קריאות מוגבלות בעבר מתבצעות ברפליקה הזמינה הקרובה ביותר. אם הרפליקה הזו לא מעודכנת לחותמת הזמן של הקריאה, היא צריכה לתקשר עם הרפליקה הראשית לפני שהיא מציגה את הקריאה. בפעולות קריאה עם התיישנות מוגבלת, פחות סביר שיהיה צורך בתקשורת הזו עם ה-leader, כי Spanner בוחר חותמת זמן שהרפליקה כבר יכולה להציג.
עסקאות DML מחולקות למחיצות
אתם יכולים להשתמש ב-DML מחולק למחיצות כדי להריץ הצהרות UPDATE ו-DELETE בקנה מידה גדול, בלי להיתקל במגבלות על טרנזקציות או לנעול טבלה שלמה. כדי לעשות את זה, Spanner מחלק את מרחב המפתחות למחיצות ומריץ את פקודות ה-DML בכל מחיצה בטרנזקציית קריאה-כתיבה נפרדת.
כדי להשתמש ב-DML לא מחולק, מריצים הצהרות בתוך טרנזקציות קריאה-כתיבה שיוצרים באופן מפורש בקוד. לפרטים נוספים, קראו את המאמר שימוש ב-DML.
ממשק
ב-Spanner יש את הממשק TransactionOptions.partitionedDml להרצת פקודת DML אחת עם מחיצות.
דוגמאות
בדוגמת הקוד הבאה, מעדכנים את העמודה MarketingBudget בטבלה Albums.
C++
כדי להריץ פקודת DML מחולקת למחיצות, משתמשים בפונקציה ExecutePartitionedDml().
C#
משתמשים ב-method ExecutePartitionedUpdateAsync() כדי להריץ פקודת DML מחולקת למחיצות.
המשך
משתמשים ב-method PartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.
Java
משתמשים ב-method executePartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.
Node.js
משתמשים ב-method runPartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.
PHP
משתמשים ב-method executePartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.
Python
משתמשים ב-method execute_partitioned_dml() כדי להריץ פקודת DML מחולקת למחיצות.
Ruby
משתמשים ב-method execute_partitioned_update() כדי להריץ פקודת DML מחולקת למחיצות.
בדוגמת הקוד הבאה נמחקות שורות מהטבלה Singers, על סמך העמודה SingerId.
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
סמנטיקה
בקטע הזה מתוארת הסמנטיקה של DML מחולק למחיצות.
הסבר על הפעלת DML מחולק למחיצות
אפשר להריץ רק פקודת DML אחת בכל פעם, גם אם משתמשים ב-method של ספריית לקוח וגם אם משתמשים ב-Google Cloud CLI.
עסקאות מחולקות למחיצות לא תומכות בביצוע שינויים או בביטול שינויים. Spanner מריץ ומחיל את פקודת ה-DML באופן מיידי. אם מבטלים את הפעולה או שהיא נכשלת, Spanner מבטל את כל המחיצות שמופעלות ולא מפעיל את המחיצות שנותרו. עם זאת, Spanner לא מבטל את הפעולות במחיצות שכבר בוצעו.
אסטרטגיית רכישת נעילה של DML מחולק למחיצות
כדי לצמצם את התחרות על נעילות, DML מחולק למחיצות רוכש נעילות קריאה רק בשורות שתואמות לסעיף WHERE. עסקאות קטנות ועצמאיות שמשמשות לכל מחיצה גם מחזיקות נעילות לזמן קצר יותר.
חותמות זמן ישנות של קריאה ואיסוף של גרסאות
Spanner מבצע איסוף אשפה של גרסאות כדי לאסוף נתונים שנמחקו או שוכתבו, ולפנות מקום באחסון. כברירת מחדל, נתונים מלפני יותר משעה נמחקים. Spanner לא יכול לבצע קריאות בחותמות זמן שקודמות לערך VERSION_RETENTION_PERIOD שהוגדר. ערך ברירת המחדל הוא שעה אחת, אבל אפשר להגדיר אותו עד שבוע אחד. אם פעולות הקריאה מתיישנות במהלך הביצוע, הן נכשלות ומוחזרת השגיאה FAILED_PRECONDITION.
שאילתות על סנכרון שינויים בזרמי נתונים
סנכרון שינויים בזרמי נתונים הוא אובייקט סכימה שאפשר להגדיר כדי לעקוב אחרי שינויים בנתונים במסד נתונים שלם, בטבלאות ספציפיות או בקבוצה מוגדרת של עמודות במסד נתונים.
כשיוצרים סנכרון שינויים בזרמי נתונים, Spanner מגדיר פונקציה תואמת עם ערך טבלה (TVF) ב-SQL. אתם יכולים להשתמש ב-TVF הזה כדי לשלוח שאילתות על רשומות השינויים בסנכרון שינויים בזרמי נתונים המשויך באמצעות השיטה sessions.executeStreamingSql. השם של ה-TVF נוצר מהשם של סנכרון השינויים בזרמי הנתונים, והוא תמיד מתחיל ב-READ_.
צריך להריץ את כל השאילתות על פונקציות TVF של סנכרון שינויים בזרמי נתונים באמצעות ה-API של sessions.executeStreamingSql, בתוך עסקה לקריאה בלבד לשימוש חד-פעמי עם timestamp_bound חזק לקריאה בלבד. הפונקציה בעלת ערך הטבלה של סנכרון השינויים בזרמי נתונים מאפשרת לציין את start_timestamp ו-end_timestamp לטווח התאריכים. כל רשומות השינויים בתקופת השמירה נגישות באמצעות timestamp_bound החזקה הזו לקריאה בלבד. כל ערך אחר של TransactionOptions לא תקין לשאילתות של סנכרון שינויים בזרמי נתונים.
בנוסף, אם TransactionOptions.read_only.return_read_timestamp מוגדר ל-true, ההודעה Transaction שמתארת את העסקה מחזירה ערך מיוחד של 2^63 - 2 במקום חותמת זמן קריאה חוקית. צריך להתעלם מהערך המיוחד הזה ולא להשתמש בו בשאילתות הבאות.
מידע נוסף זמין במאמר תהליך העבודה של שאילתות לסנכרון שינויים בזרמי נתונים.
עסקאות לא פעילות
טרנזקציה נחשבת לא פעילה אם אין לה קריאות או שאילתות SQL פתוחות, והיא לא התחילה אחת ב-10 השניות האחרונות. Spanner יכול לבטל טרנזקציות לא פעילות כדי למנוע מהן להחזיק נעילות ללא הגבלת זמן. אם טרנזקציה לא פעילה מבוטלת, ה-commit נכשל ומוחזרת השגיאה ABORTED.
כדי למנוע מצב של חוסר פעילות, אפשר להריץ מדי פעם שאילתה קטנה, כמו SELECT 1, בתוך הטרנזקציה.