סקירה כללית על עסקאות

בדף הזה מתוארות עסקאות ב-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++‎

void ReadWriteTransaction(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  using ::google::cloud::Status;
  using ::google::cloud::StatusCode;
  using ::google::cloud::StatusOr;

  // A helper to read a single album MarketingBudget.
  auto get_current_budget =
      [](spanner::Client client, spanner::Transaction txn,
         std::int64_t singer_id,
         std::int64_t album_id) -> StatusOr<std::int64_t> {
    auto key = spanner::KeySet().AddKey(spanner::MakeKey(singer_id, album_id));
    auto rows = client.Read(std::move(txn), "Albums", std::move(key),
                            {"MarketingBudget"});
    using RowType = std::tuple<std::int64_t>;
    auto row = spanner::GetSingularRow(spanner::StreamOf<RowType>(rows));
    if (!row) return std::move(row).status();
    return std::get<0>(*std::move(row));
  };

  auto constexpr kInsufficientFundsMessage =
      "The second album does not have enough funds to transfer";
  auto commit = client.Commit(
      [&](spanner::Transaction const& txn) -> StatusOr<spanner::Mutations> {
        auto b1 = get_current_budget(client, txn, 1, 1);
        if (!b1) return std::move(b1).status();
        auto b2 = get_current_budget(client, txn, 2, 2);
        if (!b2) return std::move(b2).status();
        std::int64_t transfer_amount = 200000;

        if (*b2 < transfer_amount) {
          return Status(StatusCode::kFailedPrecondition,
                        kInsufficientFundsMessage);
        }

        return spanner::Mutations{
            spanner::UpdateMutationBuilder(
                "Albums", {"SingerId", "AlbumId", "MarketingBudget"})
                .EmplaceRow(1, 1, *b1 + transfer_amount)
                .EmplaceRow(2, 2, *b2 - transfer_amount)
                .Build()};
      });

  if (!commit) throw std::move(commit).status();
  std::cout << "Transfer was successful [spanner_read_write_transaction]\n";
}

C#‎


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;
using System.Transactions;

public class ReadWriteWithTransactionAsyncSample
{
    public async Task<int> ReadWriteWithTransactionAsync(string projectId, string instanceId, string databaseId)
    {
        // This sample transfers 200,000 from the MarketingBudget
        // field of the second Album to the first Album. Make sure to run
        // the Add Column and Write Data To New Column samples first,
        // in that order.

        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
        decimal transferAmount = 200000;
        decimal secondBudget = 0;
        decimal firstBudget = 0;

        using var connection = new SpannerConnection(connectionString);
        using var cmdLookup1 = connection.CreateSelectCommand("SELECT * FROM Albums WHERE SingerId = 2 AND AlbumId = 2");

        using (var reader = await cmdLookup1.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                // Read the second album's budget.
                secondBudget = reader.GetFieldValue<decimal>("MarketingBudget");
                // Confirm second Album's budget is sufficient and
                // if not raise an exception. Raising an exception
                // will automatically roll back the transaction.
                if (secondBudget < transferAmount)
                {
                    throw new Exception($"The second album's budget {secondBudget} is less than the amount to transfer.");
                }
            }
        }

        // Read the first album's budget.
        using var cmdLookup2 = connection.CreateSelectCommand("SELECT * FROM Albums WHERE SingerId = 1 and AlbumId = 1");
        using (var reader = await cmdLookup2.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                firstBudget = reader.GetFieldValue<decimal>("MarketingBudget");
            }
        }

        // Specify update command parameters.
        using var cmdUpdate = connection.CreateUpdateCommand("Albums", new SpannerParameterCollection
        {
            { "SingerId", SpannerDbType.Int64 },
            { "AlbumId", SpannerDbType.Int64 },
            { "MarketingBudget", SpannerDbType.Int64 },
        });

        // Update second album to remove the transfer amount.
        secondBudget -= transferAmount;
        cmdUpdate.Parameters["SingerId"].Value = 2;
        cmdUpdate.Parameters["AlbumId"].Value = 2;
        cmdUpdate.Parameters["MarketingBudget"].Value = secondBudget;
        var rowCount = await cmdUpdate.ExecuteNonQueryAsync();

        // Update first album to add the transfer amount.
        firstBudget += transferAmount;
        cmdUpdate.Parameters["SingerId"].Value = 1;
        cmdUpdate.Parameters["AlbumId"].Value = 1;
        cmdUpdate.Parameters["MarketingBudget"].Value = firstBudget;
        rowCount += await cmdUpdate.ExecuteNonQueryAsync();
        scope.Complete();
        Console.WriteLine("Transaction complete.");
        return rowCount;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func writeWithTransaction(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		getBudget := func(key spanner.Key) (int64, error) {
			row, err := txn.ReadRow(ctx, "Albums", key, []string{"MarketingBudget"})
			if err != nil {
				return 0, err
			}
			var budget int64
			if err := row.Column(0, &budget); err != nil {
				return 0, err
			}
			return budget, nil
		}
		album2Budget, err := getBudget(spanner.Key{2, 2})
		if err != nil {
			return err
		}
		const transferAmt = 200000
		if album2Budget >= transferAmt {
			album1Budget, err := getBudget(spanner.Key{1, 1})
			if err != nil {
				return err
			}
			album1Budget += transferAmt
			album2Budget -= transferAmt
			cols := []string{"SingerId", "AlbumId", "MarketingBudget"}
			txn.BufferWrite([]*spanner.Mutation{
				spanner.Update("Albums", cols, []interface{}{1, 1, album1Budget}),
				spanner.Update("Albums", cols, []interface{}{2, 2, album2Budget}),
			})
			fmt.Fprintf(w, "Moved %d from Album2's MarketingBudget to Album1's.", transferAmt)
		}
		return nil
	})
	return err
}

Java

static void writeWithTransaction(DatabaseClient dbClient) {
  dbClient
      .readWriteTransaction()
      .run(transaction -> {
        // Transfer marketing budget from one album to another. We do it in a transaction to
        // ensure that the transfer is atomic.
        Struct row =
            transaction.readRow("Albums", Key.of(2, 2), Arrays.asList("MarketingBudget"));
        long album2Budget = row.getLong(0);
        // Transaction will only be committed if this condition still holds at the time of
        // commit. Otherwise it will be aborted and the callable will be rerun by the
        // client library.
        long transfer = 200000;
        if (album2Budget >= transfer) {
          long album1Budget =
              transaction
                  .readRow("Albums", Key.of(1, 1), Arrays.asList("MarketingBudget"))
                  .getLong(0);
          album1Budget += transfer;
          album2Budget -= transfer;
          transaction.buffer(
              Mutation.newUpdateBuilder("Albums")
                  .set("SingerId")
                  .to(1)
                  .set("AlbumId")
                  .to(1)
                  .set("MarketingBudget")
                  .to(album1Budget)
                  .build());
          transaction.buffer(
              Mutation.newUpdateBuilder("Albums")
                  .set("SingerId")
                  .to(2)
                  .set("AlbumId")
                  .to(2)
                  .set("MarketingBudget")
                  .to(album2Budget)
                  .build());
        }
        return null;
      });
}

Node.js

// This sample transfers 200,000 from the MarketingBudget field
// of the second Album to the first Album, as long as the second
// Album has enough money in its budget. Make sure to run the
// addColumn and updateData samples first (in that order).

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

const transferAmount = 200000;

// Note: the `runTransaction()` method is non blocking and returns "void".
// For sequential execution of the transaction use `runTransactionAsync()` method which returns a promise.
// For example: await database.runTransactionAsync(async (err, transaction) => { ... })
database.runTransaction(async (err, transaction) => {
  if (err) {
    console.error(err);
    return;
  }
  let firstBudget, secondBudget;
  const queryOne = {
    columns: ['MarketingBudget'],
    keys: [[2, 2]], // SingerId: 2, AlbumId: 2
  };

  const queryTwo = {
    columns: ['MarketingBudget'],
    keys: [[1, 1]], // SingerId: 1, AlbumId: 1
  };

  Promise.all([
    // Reads the second album's budget
    transaction.read('Albums', queryOne).then(results => {
      // Gets second album's budget
      const rows = results[0].map(row => row.toJSON());
      secondBudget = rows[0].MarketingBudget;
      console.log(`The second album's marketing budget: ${secondBudget}`);

      // Makes sure the second album's budget is large enough
      if (secondBudget < transferAmount) {
        throw new Error(
          `The second album's budget (${secondBudget}) is less than the transfer amount (${transferAmount}).`,
        );
      }
    }),

    // Reads the first album's budget
    transaction.read('Albums', queryTwo).then(results => {
      // Gets first album's budget
      const rows = results[0].map(row => row.toJSON());
      firstBudget = rows[0].MarketingBudget;
      console.log(`The first album's marketing budget: ${firstBudget}`);
    }),
  ])
    .then(() => {
      console.log(firstBudget, secondBudget);
      // Transfers the budgets between the albums
      firstBudget += transferAmount;
      secondBudget -= transferAmount;

      console.log(firstBudget, secondBudget);

      // Updates the database
      // Note: Cloud Spanner interprets Node.js numbers as FLOAT64s, so they
      // must be converted (back) to strings before being inserted as INT64s.
      transaction.update('Albums', [
        {
          SingerId: '1',
          AlbumId: '1',
          MarketingBudget: firstBudget.toString(),
        },
        {
          SingerId: '2',
          AlbumId: '2',
          MarketingBudget: secondBudget.toString(),
        },
      ]);
    })
    .then(() => {
      // Commits the transaction and send the changes to the database
      return transaction.commit();
    })
    .then(() => {
      console.log(
        `Successfully executed read-write transaction to transfer ${transferAmount} from Album 2 to Album 1.`,
      );
    })
    .catch(err => {
      console.error('ERROR:', err);
    })
    .then(() => {
      transaction.end();
      // Closes the database when finished
      return database.close();
    });
});

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Transaction;
use UnexpectedValueException;

/**
 * Performs a read-write transaction to update two sample records in the
 * database.
 *
 * This will transfer 200,000 from the `MarketingBudget` field for the second
 * Album to the first Album. If the `MarketingBudget` for the second Album is
 * too low, it will raise an exception.
 *
 * Before running this sample, you will need to run the `update_data` sample
 * to populate the fields.
 * Example:
 * ```
 * read_write_transaction($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_write_transaction(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $database->runTransaction(function (Transaction $t) use ($spanner) {
        $transferAmount = 200000;

        // Read the second album's budget.
        $secondAlbumKey = [2, 2];
        $secondAlbumKeySet = $spanner->keySet(['keys' => [$secondAlbumKey]]);
        $secondAlbumResult = $t->read(
            'Albums',
            $secondAlbumKeySet,
            ['MarketingBudget'],
            ['limit' => 1]
        );

        $firstRow = $secondAlbumResult->rows()->current();
        $secondAlbumBudget = $firstRow['MarketingBudget'];
        if ($secondAlbumBudget < $transferAmount) {
            // Throwing an exception will automatically roll back the transaction.
            throw new UnexpectedValueException(
                'The second album\'s budget is lower than the transfer amount: ' . $transferAmount
            );
        }

        $firstAlbumKey = [1, 1];
        $firstAlbumKeySet = $spanner->keySet(['keys' => [$firstAlbumKey]]);
        $firstAlbumResult = $t->read(
            'Albums',
            $firstAlbumKeySet,
            ['MarketingBudget'],
            ['limit' => 1]
        );

        // Read the first album's budget.
        $firstRow = $firstAlbumResult->rows()->current();
        $firstAlbumBudget = $firstRow['MarketingBudget'];

        // Update the budgets.
        $secondAlbumBudget -= $transferAmount;
        $firstAlbumBudget += $transferAmount;
        printf('Setting first album\'s budget to %s and the second album\'s ' .
            'budget to %s.' . PHP_EOL, $firstAlbumBudget, $secondAlbumBudget);

        // Update the rows.
        $t->updateBatch('Albums', [
            ['SingerId' => 1, 'AlbumId' => 1, 'MarketingBudget' => $firstAlbumBudget],
            ['SingerId' => 2, 'AlbumId' => 2, 'MarketingBudget' => $secondAlbumBudget],
        ]);

        // Commit the transaction!
        $t->commit();

        print('Transaction complete.' . PHP_EOL);
    });
}

Python

def read_write_transaction(instance_id, database_id):
    """Performs a read-write transaction to update two sample records in the
    database.

    This will transfer 200,000 from the `MarketingBudget` field for the second
    Album to the first Album. If the `MarketingBudget` is too low, it will
    raise an exception.

    Before running this sample, you will need to run the `update_data` sample
    to populate the fields.
    """
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    def update_albums(transaction):
        # Read the second album budget.
        second_album_keyset = spanner.KeySet(keys=[(2, 2)])
        second_album_result = transaction.read(
            table="Albums",
            columns=("MarketingBudget",),
            keyset=second_album_keyset,
            limit=1,
        )
        second_album_row = list(second_album_result)[0]
        second_album_budget = second_album_row[0]

        transfer_amount = 200000

        if second_album_budget < transfer_amount:
            # Raising an exception will automatically roll back the
            # transaction.
            raise ValueError("The second album doesn't have enough funds to transfer")

        # Read the first album's budget.
        first_album_keyset = spanner.KeySet(keys=[(1, 1)])
        first_album_result = transaction.read(
            table="Albums",
            columns=("MarketingBudget",),
            keyset=first_album_keyset,
            limit=1,
        )
        first_album_row = list(first_album_result)[0]
        first_album_budget = first_album_row[0]

        # Update the budgets.
        second_album_budget -= transfer_amount
        first_album_budget += transfer_amount
        print(
            "Setting first album's budget to {} and the second album's "
            "budget to {}.".format(first_album_budget, second_album_budget)
        )

        # Update the rows.
        transaction.update(
            table="Albums",
            columns=("SingerId", "AlbumId", "MarketingBudget"),
            values=[(1, 1, first_album_budget), (2, 2, second_album_budget)],
        )

    database.run_in_transaction(update_albums)

    print("Transaction complete.")

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner         = Google::Cloud::Spanner.new project: project_id
client          = spanner.client instance_id, database_id
transfer_amount = 200_000

client.transaction do |transaction|
  first_album  = transaction.read("Albums", [:MarketingBudget], keys: [[1, 1]]).rows.first
  second_album = transaction.read("Albums", [:MarketingBudget], keys: [[2, 2]]).rows.first

  raise "The second album does not have enough funds to transfer" if second_album[:MarketingBudget] < transfer_amount

  new_first_album_budget  = first_album[:MarketingBudget] + transfer_amount
  new_second_album_budget = second_album[:MarketingBudget] - transfer_amount

  transaction.update "Albums", [
    { SingerId: 1, AlbumId: 1, MarketingBudget: new_first_album_budget  },
    { SingerId: 2, AlbumId: 2, MarketingBudget: new_second_album_budget }
  ]
end

puts "Transaction complete"

במאמר שימוש ברמת בידוד של קריאה חוזרת מוסבר איך לבצע עסקת קריאה-כתיבה באמצעות בידוד של קריאה חוזרת.

סמנטיקה

בקטע הזה מתוארת הסמנטיקה של עסקאות קריאה-כתיבה ב-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++‎

void ReadOnlyTransaction(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto read_only = spanner::MakeReadOnlyTransaction();

  spanner::SqlStatement select(
      "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
  using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;

  // Read#1.
  auto rows1 = client.ExecuteQuery(read_only, select);
  std::cout << "Read 1 results\n";
  for (auto& row : spanner::StreamOf<RowType>(rows1)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
  // Read#2. Even if changes occur in-between the reads the transaction ensures
  // that Read #1 and Read #2 return the same data.
  auto rows2 = client.ExecuteQuery(read_only, select);
  std::cout << "Read 2 results\n";
  for (auto& row : spanner::StreamOf<RowType>(rows2)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
}

C#‎


using Google.Cloud.Spanner.Data;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Transactions;

public class QueryDataWithTransactionAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> QueryDataWithTransactionAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        var albums = new List<Album>();
        using TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
        using var connection = new SpannerConnection(connectionString);

        // Opens the connection so that the Spanner transaction included in the TransactionScope
        // is read-only TimestampBound.Strong.
        await connection.OpenAsync(SpannerTransactionCreationOptions.ReadOnly, options: null, cancellationToken: default);
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");

        // Read #1.
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                Console.WriteLine("SingerId : " + reader.GetFieldValue<string>("SingerId")
                    + " AlbumId : " + reader.GetFieldValue<string>("AlbumId")
                    + " AlbumTitle : " + reader.GetFieldValue<string>("AlbumTitle"));
            }
        }

        // Read #2. Even if changes occur in-between the reads,
        // the transaction ensures that Read #1 and Read #2
        // return the same data.
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                albums.Add(new Album
                {
                    AlbumId = reader.GetFieldValue<int>("AlbumId"),
                    SingerId = reader.GetFieldValue<int>("SingerId"),
                    AlbumTitle = reader.GetFieldValue<string>("AlbumTitle")
                });
            }
        }
        scope.Complete();
        Console.WriteLine("Transaction complete.");
        return albums;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

func readOnlyTransaction(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	ro := client.ReadOnlyTransaction()
	defer ro.Close()
	stmt := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
	iter := ro.Query(ctx, stmt)
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		var singerID int64
		var albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}

	iter = ro.Read(ctx, "Albums", spanner.AllKeys(), []string{"SingerId", "AlbumId", "AlbumTitle"})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID int64
		var albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

Java

static void readOnlyTransaction(DatabaseClient dbClient) {
  // ReadOnlyTransaction must be closed by calling close() on it to release resources held by it.
  // We use a try-with-resource block to automatically do so.
  try (ReadOnlyTransaction transaction = dbClient.readOnlyTransaction()) {
    try (ResultSet queryResultSet =
        transaction.executeQuery(
            Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"))) {
      while (queryResultSet.next()) {
        System.out.printf(
            "%d %d %s\n",
            queryResultSet.getLong(0), queryResultSet.getLong(1), queryResultSet.getString(2));
      }
    } // queryResultSet.close() is automatically called here
    try (ResultSet readResultSet =
        transaction.read(
          "Albums", KeySet.all(), Arrays.asList("SingerId", "AlbumId", "AlbumTitle"))) {
      while (readResultSet.next()) {
        System.out.printf(
            "%d %d %s\n",
            readResultSet.getLong(0), readResultSet.getLong(1), readResultSet.getString(2));
      }
    } // readResultSet.close() is automatically called here
  } // transaction.close() is automatically called here
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

// Gets a transaction object that captures the database state
// at a specific point in time
database.getSnapshot(async (err, transaction) => {
  if (err) {
    console.error(err);
    return;
  }
  const queryOne = 'SELECT SingerId, AlbumId, AlbumTitle FROM Albums';

  try {
    // Read #1, using SQL
    const [qOneRows] = await transaction.run(queryOne);

    qOneRows.forEach(row => {
      const json = row.toJSON();
      console.log(
        `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`,
      );
    });

    const queryTwo = {
      columns: ['SingerId', 'AlbumId', 'AlbumTitle'],
    };

    // Read #2, using the `read` method. Even if changes occur
    // in-between the reads, the transaction ensures that both
    // return the same data.
    const [qTwoRows] = await transaction.read('Albums', queryTwo);

    qTwoRows.forEach(row => {
      const json = row.toJSON();
      console.log(
        `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`,
      );
    });

    console.log('Successfully executed read-only transaction.');
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    transaction.end();
    // Close the database when finished.
    await database.close();
  }
});

PHP

use Google\Cloud\Spanner\SpannerClient;

/**
 * Reads data inside of a read-only transaction.
 *
 * Within the read-only transaction, or "snapshot", the application sees
 * consistent view of the database at a particular timestamp.
 * Example:
 * ```
 * read_only_transaction($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_only_transaction(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $snapshot = $database->snapshot();
    $results = $snapshot->execute(
        'SELECT SingerId, AlbumId, AlbumTitle FROM Albums'
    );
    print('Results from the first read:' . PHP_EOL);
    foreach ($results as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }

    // Perform another read using the `read` method. Even if the data
    // is updated in-between the reads, the snapshot ensures that both
    // return the same data.
    $keySet = $spanner->keySet(['all' => true]);
    $results = $database->read(
        'Albums',
        $keySet,
        ['SingerId', 'AlbumId', 'AlbumTitle']
    );

    print('Results from the second read:' . PHP_EOL);
    foreach ($results->rows() as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

def read_only_transaction(instance_id, database_id):
    """Reads data inside of a read-only transaction.

    Within the read-only transaction, or "snapshot", the application sees
    consistent view of the database at a particular timestamp.
    """
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    with database.snapshot(multi_use=True) as snapshot:
        # Read using SQL.
        results = snapshot.execute_sql(
            "SELECT SingerId, AlbumId, AlbumTitle FROM Albums"
        )

        print("Results from first read:")
        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

        # Perform another read using the `read` method. Even if the data
        # is updated in-between the reads, the snapshot ensures that both
        # return the same data.
        keyset = spanner.KeySet(all_=True)
        results = snapshot.read(
            table="Albums", columns=("SingerId", "AlbumId", "AlbumTitle"), keyset=keyset
        )

        print("Results from second read:")
        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.snapshot do |snapshot|
  snapshot.execute("SELECT SingerId, AlbumId, AlbumTitle FROM Albums").rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end

  # Even if changes occur in-between the reads, the transaction ensures that
  # both return the same data.
  snapshot.read("Albums", [:AlbumId, :AlbumTitle, :SingerId]).rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end
end

סמנטיקה

בקטע הזה מתוארת הסמנטיקה של טרנזקציות לקריאה בלבד.

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

כשעסקה לקריאה בלבד מתבצעת ב-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().

void DmlPartitionedUpdate(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("UPDATE Albums SET MarketingBudget = 100000"
                            "  WHERE SingerId > 1"));
  if (!result) throw std::move(result).status();
  std::cout << "Updated at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_update]\n";
}

C#‎

משתמשים ב-method‏ ExecutePartitionedUpdateAsync() כדי להריץ פקודת DML מחולקת למחיצות.


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class UpdateUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> UpdateUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) updated...");
        return rowCount;
    }
}

המשך

משתמשים ב-method‏ PartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func updateUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "%d record(s) updated.\n", rowCount)
	return nil
}

Java

משתמשים ב-method‏ executePartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.

static void updateUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records updated.\n", rowCount);
}

Node.js

משתמשים ב-method‏ runPartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1',
  });
  console.log(`Successfully updated ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

משתמשים ב-method‏ executePartitionedUpdate() כדי להריץ פקודת DML מחולקת למחיצות.

use Google\Cloud\Spanner\SpannerClient;

/**
 * Updates sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function update_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1'
    );

    printf('Updated %d row(s).' . PHP_EOL, $rowCount);
}

Python

משתמשים ב-method‏ execute_partitioned_dml() כדי להריץ פקודת DML מחולקת למחיצות.

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml(
    "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

print("{} records updated.".format(row_ct))

Ruby

משתמשים ב-method‏ execute_partitioned_update() כדי להריץ פקודת DML מחולקת למחיצות.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

puts "#{row_count} records updated."

בדוגמת הקוד הבאה נמחקות שורות מהטבלה Singers, על סמך העמודה SingerId.

C++‎

void DmlPartitionedDelete(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("DELETE FROM Singers WHERE SingerId > 10"));
  if (!result) throw std::move(result).status();
  std::cout << "Deleted at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_delete]\n";
}

C#‎


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class DeleteUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> DeleteUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("DELETE FROM Singers WHERE SingerId > 10");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) deleted...");
        return rowCount;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func deleteUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "DELETE FROM Singers WHERE SingerId > 10"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err

	}
	fmt.Fprintf(w, "%d record(s) deleted.", rowCount)
	return nil
}

Java

static void deleteUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "DELETE FROM Singers WHERE SingerId > 10";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records deleted.\n", rowCount);
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'DELETE FROM Singers WHERE SingerId > 10',
  });
  console.log(`Successfully deleted ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

use Google\Cloud\Spanner\SpannerClient;

/**
 * Delete sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function delete_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'DELETE FROM Singers WHERE SingerId > 10'
    );

    printf('Deleted %d row(s).' . PHP_EOL, $rowCount);
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml("DELETE FROM Singers WHERE SingerId > 10")

print("{} record(s) deleted.".format(row_ct))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "DELETE FROM Singers WHERE SingerId > 10"
)

puts "#{row_count} records deleted."

סמנטיקה

בקטע הזה מתוארת הסמנטיקה של 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, בתוך הטרנזקציה.

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