עיבוד הודעות לפי סדר לכל ישות

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

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

שרשור הודעות לתהליכי עבודה רציפים

כשמשימה ברקע של ישות מורכבת משלבים עוקבים תלויים (לדוגמה, step-1 ואחריו step-2 ו-step-3), ובקשות חיצוניות לא מוסיפות משימות מתחרות לתהליך העבודה הזה במקביל, אתם רוצים שכל שלב יתחיל רק אחרי שהשלב הקודם מסתיים.

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

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

לדוגמה, כשעובד מסיים step-1 מתהליך העבודה של הכשרת עובדים חדשים ומתזמן step-2:

GoogleSQL

-- Inside the worker transaction after finishing step-1:
-- 1. Acknowledge the current step
DELETE FROM OnboardingQueue
WHERE CustomerId = 456 AND StepName = 'step-1'
ASSERT_ROWS_MODIFIED 1;

-- 2. Enqueue the next step in the sequence
INSERT INTO OnboardingQueue (CustomerId, StepName, DeliverTime, Payload)
VALUES (456, 'step-2', CURRENT_TIMESTAMP(), b'{"stage": "provision_resources"}');

PostgreSQL

-- Inside the worker transaction after finishing step-1:
-- 1. Acknowledge the current step
DELETE FROM onboardingqueue
WHERE customerid = 456 AND stepname = 'step-1'
ASSERT_ROWS_MODIFIED 1;

-- 2. Enqueue the next step in the sequence
INSERT INTO onboardingqueue (customerid, stepname, deliver_time, payload)
VALUES (456, 'step-2', CURRENT_TIMESTAMP, CAST('{"stage": "provision_resources"}' AS bytea));

שימוש בטבלת עבודה מסודרת ובתור התעוררות

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

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

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

GoogleSQL

CREATE SEQUENCE CustomerIdSeq OPTIONS (sequence_kind = 'bit_reversed_positive');

CREATE TABLE Customers (
  CustomerId          INT64 NOT NULL DEFAULT (GET_NEXT_SEQUENCE_VALUE(SEQUENCE CustomerIdSeq)),
  CustomerName        STRING(1024),
  IsProcessing        BOOL NOT NULL DEFAULT (FALSE),
  ActiveClaimId       STRING(36),
  ProcessingExpiresAt TIMESTAMP,
) PRIMARY KEY (CustomerId);

CREATE TABLE CustomerWorkItems (
  CustomerId   INT64 NOT NULL,
  CreatedAt    TIMESTAMP NOT NULL DEFAULT (PENDING_COMMIT_TIMESTAMP())
    OPTIONS (allow_commit_timestamp = true),
  BatchIndex   INT64 NOT NULL DEFAULT (0),
  WorkType     STRING(128) NOT NULL,
  WorkPayload  JSON NOT NULL,
) PRIMARY KEY (CustomerId, CreatedAt, BatchIndex),
  INTERLEAVE IN PARENT Customers ON DELETE CASCADE;

CREATE QUEUE CustomerDirtyQueue (
  CustomerId   INT64 NOT NULL,
  MessageId    STRING(36) NOT NULL,
  Payload      BYTES(MAX) NOT NULL,
) PRIMARY KEY (CustomerId, MessageId),
  INTERLEAVE IN PARENT Customers ON DELETE CASCADE;

PostgreSQL

CREATE SEQUENCE customeridseq BIT_REVERSED_POSITIVE;

CREATE TABLE customers (
  customerid          bigint NOT NULL DEFAULT nextval('customeridseq'),
  customername        varchar(1024),
  isprocessing        boolean NOT NULL DEFAULT false,
  activeclaimid       varchar(36),
  processingexpiresat timestamptz,
  PRIMARY KEY (customerid)
);

CREATE TABLE customerworkitems (
  customerid  bigint NOT NULL,
  createdat   spanner.commit_timestamp NOT NULL DEFAULT spanner.pending_commit_timestamp(),
  batchindex  bigint NOT NULL DEFAULT 0,
  worktype    varchar(128) NOT NULL,
  workpayload jsonb NOT NULL,
  PRIMARY KEY (customerid, createdat, batchindex)
) INTERLEAVE IN PARENT customers ON DELETE CASCADE;

CREATE QUEUE customerdirtyqueue (
  customerid  bigint NOT NULL,
  messageid   varchar(36) NOT NULL,
  payload     bytea NOT NULL,
  PRIMARY KEY (customerid, messageid)
) INTERLEAVE IN PARENT customers ON DELETE CASCADE;

כשהסכימה הזו מוגדרת, השולחים וה-workers מתואמים לפי תהליך העבודה הבא:

  1. הוספת משימות מסודרות והודעת התעוררות: בטרנזקציה של השולח, מוסיפים את המשימות ל-CustomerWorkItems (באמצעות PENDING_COMMIT_TIMESTAMP() ו-BatchIndex מבוסס-אפס כדי לסדר כמה משימות באותה טרנזקציה) ומוסיפים הודעת התעוררות אחת עם מטען ייעודי ריק (b'') ל-CustomerDirtyQueue.
  2. כדי להגיש תלונה, לעבד את הישות ולבטל את התלונה, מבצעים את שלושת השלבים הבאים:
    • שלב 1 (תביעת בעלות על הישות בטרנזקציה 1): כש-worker מקבל הודעת השכמה מ-RECEIVE_CustomerDirtyQueue, הוא מריץ טרנזקציית קריאה-כתיבה קצרה:
      1. בודקים את Customers ומאשרים את הודעת ההתעוררות הנכנסת (DELETE ... ASSERT_ROWS_MODIFIED 1). אם ל-worker אחר כבר יש תביעה פעילה (IsProcessing = TRUE ו-ProcessingExpiresAt > CURRENT_TIMESTAMP()), מבצעים את Transaction 1 ויוצאים. ה-worker הפעיל בודק אם נותרו משימות לפני שהוא משחרר את התביעה שלו.
      2. אחרת, קוראים את קבוצת המשימות הישנה ביותר (לדוגמה, LIMIT 25) מ-CustomerWorkItems לפי הסדר של CreatedAt ASC, BatchIndex ASC, ומוחקים את כל הודעות הגיבוי שנותרו ושתוקפן פג (שה-MessageId שלהן הוא ה-ActiveClaimId הקודם).
      3. אם מוחזרות משימות, מגדירים את IsProcessing = TRUE, ActiveClaimId ו-ProcessingExpiresAt (למשל, 10 שניות בעתיד) ב-Customers, ומכניסים הודעת חלופית (MessageId = ActiveClaimId) ל-CustomerDirtyQueue שמתוזמנת ל-ProcessingExpiresAt. אם לא נותרו משימות, מאפסים את IsProcessing = FALSE, ActiveClaimId = NULL ו-ProcessingExpiresAt = NULL.
    • שלב 2 (עיבוד משימות מחוץ לעסקה): אחרי ש-Transaction 1 מסתיים, ה-worker מריץ את המשימות ברצף בקוד האפליקציה. אם משימה נכשלת, ה-worker מפסיק את האצווה מוקדם ועדיין מריץ את שלב 3, כך שהמשימות שהושלמו נמחקות לפני שהוא מנסה שוב להריץ את המשימה שנכשלה.
    • שלב 3 (מחיקת המשימות שהושלמו ושחרור הישות בטרנזקציה 2): ה-worker פותח טרנזקציה שנייה קצרה לקריאה ולכתיבה, מוחק את הודעת הגיבוי (ActiveClaimId) מ-CustomerDirtyQueue באמצעות ASSERT_ROWS_MODIFIED 1, מוחק את המשימות שהושלמו מ-CustomerWorkItems, מוסיף הודעת התעוררות חדשה אם נותרו עוד משימות ב-CustomerWorkItems ומאפס את IsProcessing = FALSE, ActiveClaimId = NULL ו-ProcessingExpiresAt = NULL ב-Customers.

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

  • סדר חותמות הזמן של ה-commit: אחסון משימות ב-CustomerWorkItems עם מפתח לפי (CustomerId, CreatedAt, BatchIndex) מסדר כל משימה לפי חותמת הזמן של ה-commit של הטרנזקציה, גם כשכמה שולחים כותבים בו-זמנית.
  • לוקליזציה של פיצול יחיד: שזירה CustomerWorkItems ו-CustomerDirtyQueue ב-Customers שומרת על מצב ההצהרה, המשימות והודעות ההתעוררות של הישות באותו פיצול. אם משאירים את CustomerDirtyQueue.Payload ריק (b''), זה גם מצמצם את נפח האחסון בתור ואת התקורה של המסירה בזיכרון.
  • נעילות קצרות של מסד הנתונים: החזקת טרנזקציית קריאה-כתיבה פתוחה במהלך שלב 2 נועלת את השורה Customers וחוסמת שולחים בו-זמנית. פיצול התביעה (עסקה 1) וההשלמה (עסקה 2) לשתי עסקאות קצרות מבטיח שרק עובד אחד מעבד ישות בכל פעם, בלי להחזיק נעילות של מסד נתונים בזמן שקוד האפליקציה פועל.
  • התאוששות מקריסה וגידור: אישור מיידי של הודעת ההתעוררות הראשונית בטרנזקציה 1 ותזמון הודעת גיבוי (ActiveClaimId) ב-ProcessingExpiresAt מחליפים את השכירות הקבועה של 10 שניות להודעת RECEIVE בתביעת ישות שניתנת להגדרה. אם ה-worker קורס במהלך שלב 2, ההודעה החלופית מבשילה ומעירה worker אחר. אם עובד איטי מסיים אחרי שתוקף התביעה שלו פג ועובד אחר כבר השתלט, מחיקת ActiveClaimId עם ASSERT_ROWS_MODIFIED 1 בטרנזקציה 2 נכשלת עם OUT_OF_RANGE. הפצת השגיאה הזו (או החזרה מפורשת למצב קודם) מבטלת את עסקה 2 לפני שניתן לבצע את פעולות הכתיבה האלה.

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

GoogleSQL

-- 1. Insert ordered tasks for the entity using a 0-based BatchIndex
INSERT INTO CustomerWorkItems (CustomerId, CreatedAt, BatchIndex, WorkType, WorkPayload)
VALUES
  (456, PENDING_COMMIT_TIMESTAMP(), 0, 'ORDER_CREATED', JSON '{"order_id": 1001}'),
  (456, PENDING_COMMIT_TIMESTAMP(), 1, 'PAYMENT_CAPTURED', JSON '{"order_id": 1001}');

-- 2. Send a single lightweight wake-up message to the interleaved queue
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'msg-uuid-1', CURRENT_TIMESTAMP(), b'');

PostgreSQL

-- 1. Insert ordered tasks for the entity using a 0-based batchindex
INSERT INTO customerworkitems (customerid, createdat, batchindex, worktype, workpayload)
VALUES
  (456, spanner.pending_commit_timestamp(), 0, 'ORDER_CREATED', '{"order_id": 1001}'::jsonb),
  (456, spanner.pending_commit_timestamp(), 1, 'PAYMENT_CAPTURED', '{"order_id": 1001}'::jsonb);

-- 2. Send a single lightweight wake-up message to the interleaved queue
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'msg-uuid-1', CURRENT_TIMESTAMP, CAST('' AS bytea));

הצהרות ה-SQL הבאות מראות איך ה-worker מקבל הודעות התעוררות, תובע בעלות על הישות בטרנזקציה 1 ומשחרר את הישות בטרנזקציה 2:

GoogleSQL

-- Stream wake-up messages from the queue:
SELECT CustomerId, MessageId, Payload, DeliverTime, SpannerLeaseToken
FROM RECEIVE_CustomerDirtyQueue(max_duration=>'20m', max_batch_size=>10);

-- Transaction 1 (claim the entity):
-- 1. Check whether another worker holds an active claim on the entity
SELECT
  IsProcessing,
  ActiveClaimId,
  IFNULL(ProcessingExpiresAt > CURRENT_TIMESTAMP(), FALSE) AS HasActiveClaim
FROM Customers
WHERE CustomerId = 456;

-- Always acknowledge the incoming wake-up message in Transaction 1.
-- Let OUT_OF_RANGE propagate to roll back the transaction so duplicate workers exit.
-- If IsProcessing = TRUE and HasActiveClaim = TRUE, commit after this DELETE and exit.
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'msg-uuid-1'
ASSERT_ROWS_MODIFIED 1;

-- 2. Only if no active claim exists, read the next ordered batch of work items
SELECT CreatedAt, BatchIndex, WorkType, WorkPayload
FROM CustomerWorkItems
WHERE CustomerId = 456
ORDER BY CreatedAt ASC, BatchIndex ASC
LIMIT 25;

-- 3. Always clean up any remaining expired fallback message
--    (when ActiveClaimId IS NOT NULL AND ActiveClaimId != 'msg-uuid-1'):
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'expired-claim-uuid';

-- 4. If step 2 returns work items, schedule a 10-second fallback message
--    and mark the entity as busy. (If step 2 returns no rows, clear any
--    expired claim fields on Customers instead.)
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'claim-uuid-2', TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND), b'');

UPDATE Customers
SET IsProcessing = TRUE,
    ActiveClaimId = 'claim-uuid-2',
    ProcessingExpiresAt = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND)
WHERE CustomerId = 456;

-- Transaction 2 (after processing the batch in order outside a transaction):
-- 1. Verify the claim is still active by deleting the fallback message.
--    Let OUT_OF_RANGE propagate to roll back the transaction if another worker took over.
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;

-- 2. Delete the completed work items
DELETE FROM CustomerWorkItems
WHERE CustomerId = 456
  AND CreatedAt = TIMESTAMP '2026-05-01T12:00:00.123456Z'
  AND BatchIndex IN (0, 1);

-- 3. Check whether any unprocessed work items remain:
SELECT 1 FROM CustomerWorkItems
WHERE CustomerId = 456
LIMIT 1;

-- Run this INSERT only if the preceding SELECT returned a row:
INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'continuation-uuid-3', CURRENT_TIMESTAMP(), b'');

-- 4. Release the entity claim
UPDATE Customers
SET IsProcessing = FALSE, ActiveClaimId = NULL, ProcessingExpiresAt = NULL
WHERE CustomerId = 456 AND ActiveClaimId = 'claim-uuid-2';

PostgreSQL

-- Stream wake-up messages from the queue:
SELECT customerid, messageid, payload, deliver_time, spanner_lease_token
FROM spanner.receive_customerdirtyqueue(
    max_batch_size=>10, priority=>NULL, max_duration=>'20m');

-- Transaction 1 (claim the entity):
-- 1. Check whether another worker holds an active claim on the entity
SELECT
  isprocessing,
  activeclaimid,
  COALESCE(processingexpiresat > CURRENT_TIMESTAMP, false) AS hasactiveclaim
FROM customers
WHERE customerid = 456;

-- Always acknowledge the incoming wake-up message in Transaction 1.
-- Let OUT_OF_RANGE propagate to roll back the transaction so duplicate workers exit.
-- If isprocessing = true and hasactiveclaim = true, commit after this DELETE and exit.
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'msg-uuid-1'
ASSERT_ROWS_MODIFIED 1;

-- 2. Only if no active claim exists, read the next ordered batch of work items
SELECT createdat, batchindex, worktype, workpayload
FROM customerworkitems
WHERE customerid = 456
ORDER BY createdat ASC, batchindex ASC
LIMIT 25;

-- 3. Always clean up any remaining expired fallback message
--    (when activeclaimid IS NOT NULL AND activeclaimid != 'msg-uuid-1'):
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'expired-claim-uuid';

-- 4. If step 2 returns work items, schedule a 10-second fallback message
--    and mark the entity as busy. (If step 2 returns no rows, clear any
--    expired claim fields on customers instead.)
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'claim-uuid-2', CURRENT_TIMESTAMP + INTERVAL '10 SECOND', CAST('' AS bytea));

UPDATE customers
SET isprocessing = true,
    activeclaimid = 'claim-uuid-2',
    processingexpiresat = CURRENT_TIMESTAMP + INTERVAL '10 SECOND'
WHERE customerid = 456;

-- Transaction 2 (after processing the batch in order outside a transaction):
-- 1. Verify the claim is still active by deleting the fallback message.
--    Let OUT_OF_RANGE propagate to roll back the transaction if another worker took over.
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;

-- 2. Delete the completed work items
DELETE FROM customerworkitems
WHERE customerid = 456
  AND createdat = '2026-05-01T12:00:00.123456Z'::timestamptz
  AND batchindex IN (0, 1);

-- 3. Check whether any unprocessed work items remain:
SELECT 1 FROM customerworkitems
WHERE customerid = 456
LIMIT 1;

-- Run this INSERT only if the preceding SELECT returned a row:
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'continuation-uuid-3', CURRENT_TIMESTAMP, CAST('' AS bytea));

-- 4. Release the entity claim
UPDATE customers
SET isprocessing = false, activeclaimid = NULL, processingexpiresat = NULL
WHERE customerid = 456 AND activeclaimid = 'claim-uuid-2';

מניעת כפילויות של הודעות התעוררות מתפרצות באמצעות קיבוץ זמני

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

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

  • מגדירים את MessageId למזהה הקטגוריה של חלון הזמן (לדוגמה, קטגוריה של 5 שניות).
  • מעגלים את DeliverTime כלפי מעלה לחלון הזמן הבא, בתוספת היסט לכל ישות שמחושב באמצעות FARM_FINGERPRINT (או spanner.farm_fingerprint).
  • מזינים את הודעת ההתעוררות באמצעות INSERT OR IGNORE ב-GoogleSQL או INSERT ... SELECT ... FROM ... WHERE NOT EXISTS ב-PostgreSQL.

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

לדוגמה, הטרנזקציה הבאה של השולח מאחדת הודעות התעוררות לקטגוריות של 5 שניות:

GoogleSQL

-- 1. Insert the ordered work item
INSERT INTO CustomerWorkItems (CustomerId, CreatedAt, BatchIndex, WorkType, WorkPayload)
VALUES (456, PENDING_COMMIT_TIMESTAMP(), 0, 'METRIC_RECORDED', JSON '{"v": 42}');

-- 2. Coalesce wake-up messages into a 5-second window with a per-customer offset
INSERT OR IGNORE INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (
  456,
  CONCAT('bucket-', CAST(DIV(UNIX_SECONDS(CURRENT_TIMESTAMP()), 5) * 5 AS STRING)),
  TIMESTAMP_SECONDS(
    DIV(UNIX_SECONDS(CURRENT_TIMESTAMP()), 5) * 5 + 5
    + MOD(ABS(FARM_FINGERPRINT(CAST(456 AS STRING))), 5)
  ),
  b''
);

PostgreSQL

-- 1. Insert the ordered work item
INSERT INTO customerworkitems (customerid, createdat, batchindex, worktype, workpayload)
VALUES (456, spanner.pending_commit_timestamp(), 0, 'METRIC_RECORDED', '{"v": 42}'::jsonb);

-- 2. Coalesce wake-up messages into a 5-second window with a per-customer offset
INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
SELECT
  456,
  'bucket-' || bucket.start_sec::text,
  to_timestamp(
    bucket.start_sec + 5
    + (abs(spanner.farm_fingerprint(456::text)) % 5)
  ),
  CAST('' AS bytea)
FROM (
  SELECT (floor(EXTRACT(EPOCH FROM CURRENT_TIMESTAMP))::bigint / 5) * 5 AS start_sec
) AS bucket
WHERE NOT EXISTS (
  SELECT 1 FROM customerdirtyqueue
  WHERE customerid = 456
    AND messageid = 'bucket-' || bucket.start_sec::text
);

צמצום התחרות על נעילה מהודעות התעוררות בו-זמניות

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

כדי לצמצם את התחרות על נעילות בישויות חמות, מבצעים קריאה יחידה (client.Single()) ללא נעילה לפני שמתחילים את עסקה 1, כדי לבדוק אם IsProcessing = TRUE ו-ProcessingExpiresAt > CURRENT_TIMESTAMP(). אם הישות עסוקה, ממתינים זמן קצר באופן אקראי (למשל 10 עד 50 אלפיות השנייה) לפני שמריצים את טרנזקציה 1 כדי לבדוק שוב את Customers ולאשר את הודעת ההפעלה הכפולה.

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

לדוגמה, הפונקציה הבאה ב-Go מחילה השהיה אקראית כשישות כבר עסוקה:

func maybeJitterBeforeClaim(ctx context.Context, client *spanner.Client, customerID int64) error {
    iter := client.Single().Query(ctx, spanner.Statement{
        SQL: `SELECT IsProcessing AND IFNULL(ProcessingExpiresAt > CURRENT_TIMESTAMP(), FALSE) AS IsBusy
              FROM Customers WHERE CustomerId = @cid`,
        Params: map[string]interface{}{"cid": customerID},
    })
    defer iter.Stop()
    row, err := iter.Next()
    if errors.Is(err, iterator.Done) {
        return nil
    }
    if err != nil {
        return err
    }
    var isBusy bool
    if err := row.Columns(&isBusy); err != nil {
        return err
    }
    if isBusy {
        time.Sleep(time.Duration(10+rand.Intn(40)) * time.Millisecond)
    }
    return nil
}

טיפול באצוות שפועלות לאורך זמן ובקריאות חיצוניות

כשעיבוד של קבוצת משימות נמשך יותר מחלון הזמן הראשוני של 10 שניות ב-ProcessingExpiresAt, או כשמתבצעות קריאות לממשקי API חיצוניים (כמו Payment Gateway או תגובות לפעולה מאתר אחר (webhook)) שלא מתבטלות כשטרנזקציה במסד הנתונים נכשלת, צריך למנוע פעולות חיצוניות כפולות ותפוגה מוקדמת של הצהרות.

כדי להגן על קריאות חיצוניות ולהאריך את תביעות הישות של אצוות איטיות:

  1. העברת מפתח אידמפוטנטיות דטרמיניסטי לממשקי API חיצוניים: משלבים את CustomerId,‏ CreatedAt ו-BatchIndex (לדוגמה, 456:2026-05-01T12:00:00.123456Z:0) ומעבירים את המפתח הזה לשירותים במורד הזרם במהלך שלב 2.
  2. הארכת התביעה על הישות באמצעות אות פעימה תקופתי: אפשר להגדיר ערך ראשוני ProcessingExpiresAt וערך חלופי DeliverTime ארוכים יותר (למשל 30 או 60 שניות) בטרנזקציה 1, או להריץ טרנזקציה של אות פעימה ברקע לפני שתוקף התביעה פג (למשל, כל 3 עד 4 שניות בחלון תביעה של 10 שניות). כל טרנזקציית אות חיים מוחקת את הודעת הגיבוי הנוכחית (ActiveClaimId) באמצעות ASSERT_ROWS_MODIFIED 1, מוסיפה הודעת גיבוי חדשה עם DeliverTime עתידי מעודכן, ומעדכנת את ActiveClaimId ואת ProcessingExpiresAt ב-Customers. עוצרים את האות לפני שמתחילים את עסקה 2.

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

לדוגמה, טרנזקציית האות הבאה מאריכה את התביעה הפעילה על הישות ב-10 שניות:

GoogleSQL

-- Run every 3 to 4 seconds on a 10-second claim window before starting Transaction 2:
DELETE FROM CustomerDirtyQueue
WHERE CustomerId = 456 AND MessageId = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;

INSERT INTO CustomerDirtyQueue (CustomerId, MessageId, DeliverTime, Payload)
VALUES (456, 'claim-uuid-3', TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND), b'');

UPDATE Customers
SET ActiveClaimId = 'claim-uuid-3',
    ProcessingExpiresAt = TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 10 SECOND)
WHERE CustomerId = 456 AND ActiveClaimId = 'claim-uuid-2';

PostgreSQL

-- Run every 3 to 4 seconds on a 10-second claim window before starting Transaction 2:
DELETE FROM customerdirtyqueue
WHERE customerid = 456 AND messageid = 'claim-uuid-2'
ASSERT_ROWS_MODIFIED 1;

INSERT INTO customerdirtyqueue (customerid, messageid, deliver_time, payload)
VALUES (456, 'claim-uuid-3', CURRENT_TIMESTAMP + INTERVAL '10 SECOND', CAST('' AS bytea));

UPDATE customers
SET activeclaimid = 'claim-uuid-3',
    processingexpiresat = CURRENT_TIMESTAMP + INTERVAL '10 SECOND'
WHERE customerid = 456 AND activeclaimid = 'claim-uuid-2';

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

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

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

  • פיצול טבלאות העבודה וביטול הכפילויות: יוצרים טבלת הורה CustomerShards עם PRIMARY KEY (ShardId, CustomerId) (ShardId מ-0 עד N - 1) ומשלבים טבלת עבודה מפוצלת עם מפתח (ShardId, CustomerId, CreatedAt, BatchIndex). הפיכת ShardId לעמודת המפתח המובילה מפזרת את פעולות הכתיבה על פני N פיצולים. כדי למנוע שורות כפולות של משימות כשעסקה שמנסים לבצע מחדש מקבלת PENDING_COMMIT_TIMESTAMP() חדש, צריך גם לשלב טבלת ביטול כפילויות באצווה עם מפתח לפי (ShardId, CustomerId, BatchId) עם מדיניות TTL.
  • ניתוב כל אצווה של יצרן למאגר נתונים אחד בלי כתיבה לתור: בכל טרנזקציה של יצרן, מחשבים את ShardId מגיבוב (hash) של BatchId ייחודי (כמו FARM_FINGERPRINT) ומכניסים גם לטבלת ביטול הכפילויות וגם לטבלת העבודה של מאגר הנתונים, בלי להכניס לתור. גיבוב (hashing) של BatchId שומר כל טרנזקציה של יצרן בפיצול יחיד, ומבטל את התקורה של התור לכל כתיבה.
  • סריקת מקטעים לפי הסדר באמצעות קריאה בעבר וסמן התקדמות: שומרים על תביעה פעילה וסמן (LastSweptAt, LastBatchIndex, LastShardId) בטבלת CustomerSweeperState נפרדת עם תור התעוררות משולב, שמכיל הודעת סריקה חוזרת אחת לכל ישות. כשהוא מופעל, ה-worker תובע את הישות (באמצעות אותה תבנית של תביעה והודעת חלופית כמו ב-שימוש בטבלת עבודה מסודרת ובתור התעוררות), שולח שאילתות לכל N השארדים אחרי הסמן באמצעות קריאה של התיישנות מדויקת של 10 שניות, מסודרת לפי CreatedAt ASC, BatchIndex ASC, ShardId ASC, מעבד את ה-batch לפי הסדר ומבצע טרנזקציית השלמה שמוחקת את השורות שעובדו, מקדמת את הסמן ומתזמנת את הסריקה הבאה. שימוש בקריאה בעבר מונע חסימה של כתיבות של יצרנים במהלך הפיצולים, והסמן מדלג על שורות שעובדו ונמחקו בחלון הזמן של הקריאה בעבר.

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