פקודות לניהול סשנים ב-PGAdapter

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

מידע נוסף זמין ברשימה המלאה של מנהלי התקנים (drivers) ו-ORM של PostgreSQL. הפקודות הבאות חלות על מסדי נתונים בניב PostgreSQL.

מידע נוסף על השימוש ב-PGAdapter זמין במאמר הפעלת PGAdapter.

דוחות חיבור

ההצהרות הבאות משנות את המאפיינים של החיבור הנוכחי או מציגות אותם.

SPANNER.READONLY

ערך בוליאני שמציין אם החיבור נמצא במצב קריאה-בלבד. ערך ברירת המחדל הוא false.

SHOW [VARIABLE] SPANNER.READONLY
SET SPANNER.READONLY {TO|=} { true | false }

אפשר לשנות את הערך של המאפיין הזה רק כשאין טרנזקציה פעילה.

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

SET SPANNER.READONLY = TRUE;
-- This transaction is a read-only transaction.
BEGIN TRANSACTION;

-- The following two queries both use the read-only transaction.
SELECT first_name, last_name
FROM singers
ORDER BY last_name;

SELECT first_name, last_name
FROM albums
ORDER BY title;

-- This shows the read timestamp that was used for the two queries.
SHOW SPANNER.READ_TIMESTAMP;

-- This marks the end of the read-only transaction. The next statement will
-- start a new read-only transaction.
COMMIT;

AUTOCOMMIT

ערך בוליאני שמציין אם החיבור נמצא במצב אישור אוטומטי. ערך ברירת המחדל הוא true.

NOTE: בדרך כלל לא צריך לשנות את הערך של המשתנה הזה כשמשתמשים בדרייבר של PostgreSQL עם PGAdapter. הדרייברים האלה מנהלים את העסקאות באופן אוטומטי על ידי הפעלת הפקודות BEGIN ו-COMMIT כשצריך. אפשר להשבית את autocommit כשמשתמשים בכלי שורת פקודה כמו psql כדי למנוע מצב שבו שינויים בנתונים יבוצעו אוטומטית בטעות.

SHOW [VARIABLE] AUTOCOMMIT
SET AUTOCOMMIT {TO|=} { true | false }

אפשר לשנות את הערך של הנכס הזה רק כשאין טרנזקציה פעילה.

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

‫▶ דוגמה: ביצוע אוטומטי של פעולת Commit (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך משתמשים במאפיין autocommit.

-- The default value for AUTOCOMMIT is true.
SHOW AUTOCOMMIT;

-- This insert statement is automatically committed after it is executed, as
-- the connection is in autocommit mode.
INSERT INTO T (id, col_a, col_b) VALUES (1, 100, 1);

-- Turning off autocommit means that a new transaction is automatically started
-- when the next statement is executed.
SET AUTOCOMMIT = FALSE;
-- The following statement starts a new transaction.
INSERT INTO T (id, col_a, col_b) VALUES (2, 200, 2);

-- This statement uses the same transaction as the previous statement.
INSERT INTO T (id, col_a, col_b) VALUES (3, 300, 3);

-- Commit the current transaction with the two INSERT statements.
COMMIT;

-- Transactions can also be executed in autocommit mode by executing the BEGIN
-- statement.
SET AUTOCOMMIT = TRUE;

-- Execute a transaction while in autocommit mode.
BEGIN;
INSERT INTO T (id, col_a, col_b) VALUES (4, 400, 4);
INSERT INTO T (id, col_a, col_b) VALUES (5, 500, 5);
COMMIT;

SPANNER.RETRY_ABORTS_INTERNALLY

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

SHOW [VARIABLE] SPANNER.RETRY_ABORTS_INTERNALLY
SET SPANNER.RETRY_ABORTS_INTERNALLY {TO|=} { true | false }

אפשר להריץ את הפקודה הזו רק אחרי שמתחילים טרנזקציה (ראו BEGIN [TRANSACTION | WORK]) ולפני שמריצים הצהרות בתוך הטרנזקציה.

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

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

SPANNER.AUTOCOMMIT_DML_MODE

מאפיין STRING שמציין את מצב האישור האוטומטי של הצהרות שפת טיפול בנתונים (DML).

SHOW [VARIABLE] SPANNER.AUTOCOMMIT_DML_MODE
SET SPANNER.AUTOCOMMIT_DML_MODE {TO|=} { 'TRANSACTIONAL' | 'PARTITIONED_NON_ATOMIC' }

הערכים האפשריים הם:

  • במצב TRANSACTIONAL, מנהל ההתקן מבצע הצהרות DML כטרנזקציות אטומיות נפרדות. הדרייבר יוצר טרנזקציה חדשה, מריץ את הצהרת ה-DML ומבצע commit לטרנזקציה אם ההרצה מצליחה, או מבצע rollback לטרנזקציה אם מתרחשת שגיאה.
  • במצב PARTITIONED_NON_ATOMIC, מנהל ההתקן מפעיל הצהרות DML כהצהרות עדכון מחולקות. הצהרת עדכון עם חלוקה למחיצות יכולה לפעול כסדרה של הרבה טרנזקציות, שכל אחת מהן מכסה קבוצת משנה של השורות המושפעות. ההצהרה עם המחיצות מספקת סמנטיקה מוחלשת בתמורה לשיפור ההתאמה לעומס ולביצועים.

ערך ברירת המחדל הוא TRANSACTIONAL.

‫▶ דוגמה: DML עם חלוקה למחיצות (יש ללחוץ כדי להרחיב)
 בדוגמה הבאה מוצג אופן ההפעלה של Partitioned DML באמצעות PGAdapter.

-- Change autocommit DML mode to use Partitioned DML.
SET SPANNER.AUTOCOMMIT_DML_MODE = 'PARTITIONED_NON_ATOMIC';

-- Delete all singers that have been marked as inactive.
-- This statement is executed using Partitioned DML.
DELETE
FROM singers
WHERE active=false;

-- Change DML mode back to standard `TRANSACTIONAL`.
SET SPANNER.AUTOCOMMIT_DML_MODE = 'TRANSACTIONAL';

STATEMENT_TIMEOUT

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

SHOW [VARIABLE] STATEMENT_TIMEOUT
SET STATEMENT_TIMEOUT {TO|=} { '<int8>{ s | ms | us | ns }' | <int8> | DEFAULT }

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

יחידות הזמן הנתמכות הן:

  • ‫s: שניות
  • ‫ms: אלפיות השנייה
  • ‫us: מיקרו-שניות
  • ‫ns: ננו-שניות

הערך DEFAULT הוא 0 שניות, כלומר אין זמן קצוב לתפוגה. מספר int8 ללא יחידות מציין int8 ms. לדוגמה, שתי הפקודות הבאות מגדירות את הזמן הקצוב לתפוגה של ההצהרה ל-2 שניות.

SET STATEMENT_TIMEOUT TO 2000;
SET STATEMENT_TIMEOUT TO '2s';

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

READ_ONLY_STALENESS

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

SHOW [VARIABLE] SPANNER.READ_ONLY_STALENESS
SET SPANNER.READ_ONLY_STALENESS {TO|=} staleness_type

staleness_type:

{ 'STRONG'
  | 'MIN_READ_TIMESTAMP timestamp'
  | 'READ_TIMESTAMP timestamp'
  | 'MAX_STALENESS <int8>{ s | ms | us | ns }'
  | 'EXACT_STALENESS <int8>{ s | ms | us | ns }' }

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

ערך ברירת המחדל הוא STRONG.

אלה האפשרויות של חותמת הזמן:

חותמות הזמן צריכות להיות בפורמט הבא:

YYYY-[M]M-[D]D [[H]H:[M]M:[S]S[.DDDDDD]][timezone]

יחידות הזמן הנתמכות להגדרת הערכים MAX_STALENESS ו-EXACT_STALENESS:

  • ‫s: שניות
  • ‫ms: אלפיות השנייה
  • ‫us: מיקרו-שניות
  • ‫ns: ננו-שניות

אפשר לשנות את הערך של המאפיין הזה רק כשאין טרנזקציה פעילה.

‫▶ דוגמה: נתונים לא עדכניים לקריאה בלבד (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה מוצג איך להריץ שאילתות באמצעות ערך מותאם אישית של נתונים לא עדכניים עם PGAdapter.

-- Set the read-only staleness to MAX_STALENESS 10 seconds.
SET SPANNER.READ_ONLY_STALENESS = 'MAX_STALENESS 10s';

-- Execute a query in auto-commit mode. This will return results that are up to
-- 10 seconds stale.
SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Read-only staleness can also be applied to read-only transactions.
-- MAX_STALENESS is however only allowed for queries in autocommit mode.
-- Change the staleness to EXACT_STALENESS and start a read-only transaction.
SET SPANNER.READ_ONLY_STALENESS = 'EXACT_STALENESS 10s';
BEGIN;
SET TRANSACTION READ ONLY;

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

SELECT title, singer_id
FROM albums
ORDER BY title;

COMMIT;

-- Read staleness can also be an exact timestamp.
SET SPANNER.READ_ONLY_STALENESS = 'READ_TIMESTAMP 2024-01-26T10:36:00Z';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

SPANNER.OPTIMIZER_VERSION

מאפיין מסוג STRING שמציין את optimizer version. הגרסה היא מספר או הערך LATEST.

SHOW [VARIABLE] SPANNER.OPTIMIZER_VERSION
SET SPANNER.OPTIMIZER_VERSION {TO|=} { 'version'|'LATEST'|'' }

הגדרת הגרסה של האופטימיזציה שתשמש לכל ההצהרות הבאות בחיבור. הגדרת גרסת האופטימיזציה ל-'' (המחרוזת הריקה) מציינת שיש להשתמש בגרסה האחרונה. אם לא מוגדרת גרסת אופטימיזציה,‏ Spanner משתמש בגרסת האופטימיזציה שמוגדרת ברמת מסד הנתונים.

ערך ברירת המחדל הוא ''.

‫▶ דוגמה: גרסת הכלי לאופטימיזציה (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה מוצג איך להריץ שאילתות באמצעות גרסה ספציפית של אופטימיזציה עם PGAdapter.

-- Set the optimizer version to 5 and execute a query.
SET SPANNER.OPTIMIZER_VERSION = '5';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Execute the same query with the latest optimizer version.
SET SPANNER.OPTIMIZER_VERSION = 'LATEST';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Revert back to using the default optimizer version that has been set for the
-- database.
SET SPANNER.OPTIMIZER_VERSION = '';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

SPANNER.OPTIMIZER_STATISTICS_PACKAGE

מאפיין מסוג STRING שמציין את חבילת נתוני האופטימיזציה הנוכחית שבה נעשה שימוש בחיבור הזה.

SHOW [VARIABLE] SPANNER.OPTIMIZER_STATISTICS_PACKAGE
SET SPANNER.OPTIMIZER_STATISTICS_PACKAGE {TO|=} { 'package'|'' }

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

ערך ברירת המחדל הוא ''.

‫▶ דוגמה: חבילת נתונים סטטיסטיים של כלי האופטימיזציה (יש ללחוץ כדי להרחיב)
 בדוגמה הבאה מוצגות דרכים להריץ שאילתות באמצעות חבילת נתונים סטטיסטיים ספציפית של אופטימיזציה עם PGAdapter.

-- Show the available optimizer statistics packages in this database.
SELECT * FROM INFORMATION_SCHEMA.SPANNER_STATISTICS;

-- Set the optimizer statistics package and execute a query.
SET SPANNER.OPTIMIZER_STATISTICS_PACKAGE = 'auto_20240124_06_47_29UTC';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Execute the same query with the default optimizer statistics package.
SET SPANNER.OPTIMIZER_VERSION = '';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

SPANNER.RETURN_COMMIT_STATS

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

SHOW [VARIABLE] SPANNER.RETURN_COMMIT_STATS
SET SPANNER.RETURN_COMMIT_STATS {TO|=} { true | false }

ערך ברירת המחדל הוא false.

‫▶ דוגמה: נתונים סטטיסטיים של ביצוע שינויים (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך מציגים נתונים סטטיסטיים של ביצוע פעולות (commit) בעסקה באמצעות PGAdapter.

-- Enable the returning of commit stats.
SET SPANNER.RETURN_COMMIT_STATS = true;

-- Execute a transaction.
BEGIN;
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1), (2, 200, 2), (3, 300, 3);
COMMIT;

-- View the commit response with the transaction statistics for the last
-- transaction that was committed.
SHOW SPANNER.COMMIT_RESPONSE;

SPANNER.RPC_PRIORITY

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

SHOW [VARIABLE] SPANNER.RPC_PRIORITY
SET SPANNER.RPC_PRIORITY {TO|=} {'HIGH'|'MEDIUM'|'LOW'|'NULL'}

‫'NULL' פירושו שלא צריך לכלול רמז בבקשה.

ערך ברירת המחדל הוא 'NULL'.

אפשר גם להשתמש ברמז של הצהרה כדי לציין את העדיפות של ה-RPC:

/*@RPC_PRIORITY=PRIORITY_LOW*/ SELECT * FROM Albums

מידע נוסף זמין במאמר Priority.

דוחות עסקאות

ההצהרות הבאות מנהלות עסקאות ב-Spanner ומבצעות אותן.

רמת הבידוד של טרנזקציה

SHOW [ VARIABLE ] TRANSACTION ISOLATION LEVEL

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

SPANNER.READ_TIMESTAMP

SHOW [VARIABLE] SPANNER.READ_TIMESTAMP

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

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

-- Execute a query in autocommit mode using the default read-only staleness
-- (strong).
SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Shows the read timestamp that was used for the previous query.
SHOW SPANNER.READ_TIMESTAMP;

-- Set a non-deterministic read-only staleness and execute the same query.
SET SPANNER.READ_ONLY_STALENESS = 'MAX_STALENESS 20s';

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Shows the read timestamp that was used for the previous query. The timestamp
-- is determined by Spanner, and is guaranteed to be no less than 20
-- seconds stale.
SHOW SPANNER.READ_TIMESTAMP;

-- The read timestamp of a read-only transaction can also be retrieved.
SET SPANNER.READ_ONLY_STALENESS = 'STRONG';
BEGIN;
SET TRANSACTION READ ONLY;

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Shows the read timestamp of the current read-only transaction. All queries in
-- this transaction will use this read timestamp.
SHOW SPANNER.READ_TIMESTAMP;

SELECT title
FROM albums
ORDER BY title;

-- The read timestamp is the same as for the previous query, as all queries in
-- the same transaction use the same read timestamp.
SHOW SPANNER.READ_TIMESTAMP;

COMMIT;

SPANNER.COMMIT_TIMESTAMP

SHOW [VARIABLE] SPANNER.COMMIT_TIMESTAMP

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

‫▶ דוגמה: חותמת זמן של ביצוע (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך מציגים את חותמת הזמן של הקומיט האחרון לפעולת כתיבה באמצעות PGAdapter.

-- Execute a DML statement.
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1), (2, 200, 2), (3, 300, 3);

-- Show the timestamp that the statement was committed.
SHOW SPANNER.COMMIT_TIMESTAMP;

SPANNER.COMMIT_RESPONSE

SHOW [VARIABLE] SPANNER.COMMIT_RESPONSE

מחזירה קבוצת תוצאות עם שורה אחת ושתי עמודות:

  • ‫COMMIT_TIMESTAMP (type=TIMESTAMP) מציין מתי בוצעה העסקה האחרונה.
  • ‫MUTATION_COUNT (type=int8) מציין כמה שינויים בוצעו בטרנזקציה שאושרה. הערך הזה תמיד ריק כשמריצים את הפקודה באמולטור.

מספר השינויים זמין רק אם הערך של SET RETURN_COMMIT_STATS הוגדר ל-true לפני אישור העסקה.

‫▶ דוגמה: תגובה על ביצוע שינוי (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך צופים בתגובה של הקומיט האחרון לפעולת כתיבה באמצעות PGAdapter.

-- Enable returning commit stats in addition to the commit timestamp.
SET SPANNER.RETURN_COMMIT_STATS = true;

-- Execute a DML statement.
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1), (2, 200, 2), (3, 300, 3);

-- Show the timestamp that the statement was committed.
SHOW SPANNER.COMMIT_RESPONSE;

‫{ START | BEGIN } [ TRANSACTION | WORK ]

{ START | BEGIN } [ TRANSACTION | WORK ] [{ READ ONLY | READ WRITE }]

מתחילים עסקה חדשה. מילות המפתח TRANSACTION ו-WORK הן אופציונליות, שוות ערך ולא משפיעות.

  • משתמשים ב-COMMIT או ב-ROLLBACK כדי להפסיק עסקה.
  • אם הפעלתם את מצב AUTOCOMMIT, ההצהרה הזו מוציאה את החיבור ממצב AUTOCOMMIT באופן זמני. החיבור חוזר למצב AUTOCOMMIT כשהעסקה מסתיימת.
  • אם לא מציינים את READ ONLY או READ WRITE, מצב העסקה נקבע לפי מצב העסקה שמוגדר כברירת מחדל בסשן. ברירת המחדל הזו מוגדרת באמצעות הפקודה SET SESSION CHARACTERISTICS AS TRANSACTION.

אפשר להריץ את ההצהרה הזו רק כשאין טרנזקציה פעילה.

‫▶ דוגמה: BEGIN TRANSACTION (כדי להרחיב, לוחצים)
 בדוגמה הבאה מוצגות דרכים להתחיל סוגים שונים של טרנזקציות באמצעות PGAdapter.

-- This starts a transaction using the current defaults of this connection.
-- The value of SPANNER.READONLY determines whether the transaction is a
-- read/write or a read-only transaction.

BEGIN;
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1);
COMMIT;

-- Set SPANNER.READONLY to TRUE to use read-only transactions by default.
SET SPANNER.READONLY=TRUE;

-- This starts a read-only transaction.
BEGIN;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
COMMIT;

-- Use the 'READ WRITE' or 'READ ONLY' qualifier in the BEGIN statement to
-- override the current default of the connection.
SET SPANNER.READONLY=FALSE;
BEGIN READ ONLY;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
COMMIT;

COMMIT [TRANSACTION | WORK]

COMMIT [TRANSACTION | WORK]

מאשרים את העסקה הנוכחית. מילות המפתח TRANSACTION ו-WORK הן אופציונליות, שוות ערך ואין להן השפעה.

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

אפשר להריץ את ההצהרה הזו רק בזמן שמתבצעת טרנזקציה פעילה.

‫▶ דוגמה: COMMIT TRANSACTION (לוחצים כדי להרחיב)
 בדוגמה הבאה אפשר לראות איך מבצעים קומיט של טרנזקציה באמצעות PGAdapter.

-- Execute a regular read/write transaction.
BEGIN;
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1);
COMMIT;

-- Execute a read-only transaction. Read-only transactions also need to be
-- either committed or rolled back in PGAdapter in order to mark the
-- end of the transaction.
BEGIN READ ONLY;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
COMMIT;

ROLLBACK [TRANSACTION | WORK]

ROLLBACK [TRANSACTION | WORK]

מבצע ROLLBACK של העסקה הנוכחית. מילות המפתח TRANSACTION ו-WORK הן אופציונליות ושקולות, ואין להן השפעה.

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

אפשר להריץ את ההצהרה הזו רק בזמן שמתבצעת טרנזקציה פעילה.

‫▶ דוגמה: ROLLBACK TRANSACTION (לוחצים כדי להרחיב)
 בדוגמה הבאה אפשר לראות איך מבטלים טרנזקציה באמצעות PGAdapter.

-- Use ROLLBACK to undo the effects of a transaction.
BEGIN;
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1);
-- This will ensure that the insert statement is not persisted in the database.
ROLLBACK;

-- Read-only transactions also need to be either committed or rolled back in
-- PGAdapter in order to mark the end of the transaction. There is no
-- semantic difference between rolling back or committing a read-only
-- transaction.
BEGIN READ ONLY;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
ROLLBACK;

SET TRANSACTION

SET TRANSACTION { READ ONLY | READ WRITE }

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

אפשר להריץ את ההצהרה הזו רק אם AUTOCOMMIT הוא false, או אם התחלתם טרנזקציה על ידי הרצת BEGIN [TRANSACTION | WORK] ועדיין לא הרצתם הצהרות בטרנזקציה.

ההצהרה הזו מגדירה את מצב העסקה רק לעסקה הנוכחית. כשהעסקה מתבצעת או מבוטלת, העסקה הבאה משתמשת במצב ברירת המחדל של החיבור. (ראו SET SESSION CHARACTERISTICS).

‫▶ דוגמה: הגדרת טרנזקציה (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך מגדירים מאפיינים של טרנזקציות באמצעות PGAdapter.

-- Start a transaction and set the transaction mode to read-only.
BEGIN;
SET TRANSACTION READ ONLY;

SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- Commit the read-only transaction to mark the end of the transaction.
COMMIT;

-- Start a transaction and set the transaction mode to read/write.
BEGIN;
SET TRANSACTION READ WRITE;

INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1);

COMMIT;

הגדרת מאפייני הסשן

SET SESSION CHARACTERISTICS AS TRANSACTION { READ ONLY | READ WRITE }

הגדרת מצב ברירת המחדל של העסקאות בסשן ל-READ ONLY או ל-READ WRITE. ההצהרה הזו מותרת רק כשאין טרנזקציה פעילה.

הפקודה SET TRANSACTION יכולה לבטל את ההגדרה הזו.

‫▶ דוגמה: SET SESSION CHARACTERISTICS (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך מגדירים מאפיינים של סשן באמצעות PGAdapter.

-- Set the default transaction mode to read-only.
SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY;

-- This will now start a read-only transaction.
BEGIN;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
COMMIT;

-- You can override the default transaction mode with the SET TRANSACTION
-- statement.
SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE;
BEGIN;
SET TRANSACTION READ ONLY;
SELECT first_name, last_name
FROM singers
ORDER BY last_name;
COMMIT;

SPANNER.STATEMENT_TAG

מאפיין מסוג STRING שמכיל את תג הבקשה של ההצהרה הבאה.

SHOW [ VARIABLE ] SPANNER.STATEMENT_TAG
SET SPANNER.STATEMENT_TAG {TO|=} 'tag-name'

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

ערך ברירת המחדל הוא ''.

אפשר להגדיר גם תגי עסקאות וגם תגי דפי תדפיס לאותו דף תדפיס.

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

/*@STATEMENT_TAG='my-tag'*/ SELECT * FROM albums

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

‫▶ דוגמה: תגי הצהרה (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך מגדירים תגי הצהרה באמצעות PGAdapter.

-- Set the statement tag that should be included with the next statement.
SET SPANNER.STATEMENT_TAG = 'tag1';
SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- The statement tag property is cleared after each statement execution.
SHOW SPANNER.STATEMENT_TAG;
-- Set another tag for the next statement.
SET SPANNER.STATEMENT_TAG = 'tag2';
SELECT title
FROM albums
ORDER BY title;

-- Set a statement tag with a query hint.
/*@STATEMENT_TAG='tag3'*/
SELECT track_number, title
FROM tracks
WHERE album_id=1 AND singer_id=1
ORDER BY track_number;

SPANNER.TRANSACTION_TAG

מאפיין מסוג STRING שמכיל את תג העסקה לעסקה הבאה.

SHOW [ VARIABLE ] SPANNER.TRANSACTION_TAG
SET SPANNER.TRANSACTION_TAG {TO|=} 'tag-name'

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

ערך ברירת המחדל הוא ''.

אפשר להגדיר גם תגי עסקאות וגם תגי דפי תדפיס לאותו דף תדפיס.

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

‫▶ דוגמה: תגי עסקאות (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך מגדירים תגי עסקאות באמצעות PGAdapter.

BEGIN;
-- Set the transaction tag for the current transaction.
SET SPANNER.TRANSACTION_TAG = 'transaction-tag-1';

-- Set the statement tag that should be included with the next statement.
-- The statement will include both the statement tag and the transaction tag.
SET SPANNER.STATEMENT_TAG = 'select-statement';
SELECT first_name, last_name
FROM singers
ORDER BY last_name;

-- The statement tag property is cleared after each statement execution.
SHOW SPANNER.STATEMENT_TAG;

-- Set another tag for the next statement.
SET SPANNER.STATEMENT_TAG = 'insert-statement';
INSERT INTO T (id, col_a, col_b)
VALUES (1, 100, 1);

COMMIT;

-- The transaction tag property is cleared when the transaction finishes.
SHOW SPANNER.TRANSACTION_TAG;

דוחות באצווה

ההצהרות הבאות מנהלות קבוצות של הצהרות DDL ושולחות את הקבוצות האלה ל-Spanner.

START BATCH DDL

START BATCH DDL

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

אפשר להריץ את ההצהרה הזו רק כשאין טרנזקציה פעילה.

‫▶ דוגמה: קבוצת פקודות DDL (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך להריץ קבוצת פקודות DDL באמצעות PGAdapter.

-- Start a DDL batch. All following statements must be DDL statements.
START BATCH DDL;

-- This statement is buffered locally until RUN BATCH is executed.
CREATE TABLE singers (
  id bigint primary key,
  first_name varchar,
  last_name varchar
);

-- This statement is buffered locally until RUN BATCH is executed.
CREATE TABLE albums (
  id bigint primary key,
  title varchar,
  singer_id bigint,
  constraint fk_albums_singers foreign key (singer_id) references singers (id)
);

-- This runs the DDL statements as one batch.
RUN BATCH;

RUN BATCH

RUN BATCH

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

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

ביטול של קבוצת בקשות

מנקה את כל הצהרות ה-DDL שנמצאות בבאפר באוסף הנוכחי של הצהרות DDL ומסיים את האוסף.

אפשר להריץ את ההצהרה הזו רק כשקבוצת DDL פעילה. אפשר להשתמש ב-ABORT BATCH גם אם יש או אין הצהרות DDL במאגר הזמני של החבילה. כל הצהרות ה-DDL הקודמות באצווה יבוטלו.

‫▶ דוגמה: ביטול של קבוצת פקודות DDL (לחצו להרחבה)
 בדוגמה הבאה אפשר לראות איך מבטלים אצווה של DDL באמצעות PGAdapter.

-- Start a DDL batch. All following statements must be DDL statements.
START BATCH DDL;

-- The following statements are buffered locally.
CREATE TABLE singers (
  id bigint primary key,
  first_name varchar,
  last_name varchar
);
CREATE TABLE albums (
  id bigint primary key,
  title varchar,
  singer_id bigint,
  constraint fk_albums_singers foreign key (singer_id) references singers (id)
);

-- This aborts the DDL batch and removes the DDL statements from the buffer.
ABORT BATCH;

START BATCH DML

ההצהרות הבאות מקבצות את שתי הצהרות ה-DML ושולחות אותן בקריאה אחת לשרת. אפשר להריץ קבוצת פקודות DML כחלק מעסקה או במצב אישור אוטומטי.

START BATCH DML;
INSERT INTO MYTABLE (ID, NAME) VALUES (1, 'ONE');
INSERT INTO MYTABLE (ID, NAME) VALUES (2, 'TWO');
RUN BATCH;

‫▶ דוגמה: חבילת DML (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך להריץ חבילת DML באמצעות PGAdapter.

-- Start a DML batch. All following statements must be a DML statement.
START BATCH DML;

-- The following statements are buffered locally.
INSERT INTO MYTABLE (ID, NAME) VALUES (1, 'ONE');
INSERT INTO MYTABLE (ID, NAME) VALUES (2, 'TWO');

-- This sends the statements to Spanner.
RUN BATCH;

-- DML batches can also be part of a read/write transaction.
BEGIN;
-- Insert a row using a single statement.
INSERT INTO MYTABLE (ID, NAME) VALUES (3, 'THREE');

-- Insert two rows using a batch.
START BATCH DML;
INSERT INTO MYTABLE (ID, NAME) VALUES (4, 'FOUR');
INSERT INTO MYTABLE (ID, NAME) VALUES (5, 'FIVE');
RUN BATCH;

-- Rollback the current transaction. This rolls back both the single DML
-- statement and the DML batch.
ROLLBACK;

פקודות של נקודות שמירה

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

יצירה ושחרור של נקודות שמירה תמיד מצליחות כשמופעלת תמיכה בנקודות שמירה.

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

SPANNER.SAVEPOINT_SUPPORT

SHOW [VARIABLE] SPANNER.SAVEPOINT_SUPPORT
SET SPANNER.SAVEPOINT_SUPPORT = { 'DISABLED' | 'FAIL_AFTER_ROLLBACK' | 'ENABLED' }

מאפיין מסוג STRING שמציין את ההגדרה הנוכחית של SAVEPOINT_SUPPORT הנכס. הערכים שאפשר לבחור הם:

  • ‫DISABLED: כל הפקודות של נקודות השמירה מושבתות וייכשלו.
  • ‫FAIL_AFTER_ROLLBACK: פקודות Savepoint מופעלות. ביטול שינויים עד לנקודת שמירה מבטל את כל השינויים בעסקה. הפעולה תיכשל אם תנסו להשתמש בעסקה אחרי שתחזרו לנקודת שמירה.
  • ‫ENABLED: כל הפקודות של נקודות השמירה מופעלות. ביטול שינויים עד לנקודת שמירה מבטל את השינויים שבוצעו בעסקה, ומנסה שוב לבצע את הפעולה עד לנקודת השמירה. הפעולה הזו תיכשל עם שגיאה AbortedDueToConcurrentModificationException אם נתוני הבסיס ששימשו את העסקה עד לנקודת השמירה השתנו.

ערך ברירת המחדל הוא ENABLED.

אפשר להריץ את ההצהרה הזו רק כשאין טרנזקציה פעילה.

SAVEPOINT savepoint_name

SAVEPOINT savepoint-name;

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

‫▶ דוגמה: נקודת שמירה (יש ללחוץ כדי להרחיב)
 בדוגמה הבאה אפשר לראות איך משתמשים בנקודות שמירה עם PGAdapter.

-- Start a transaction and execute an insert statement.
BEGIN;
INSERT INTO T (id, col_a, col_b) VALUES (1, 100, 1);

-- Set a savepoint and then execute another insert statement.
SAVEPOINT one_row_inserted;
INSERT INTO T (id, col_a, col_b) VALUES (2, 200, 2);

-- Roll back to the savepoint. This will undo all statements that have been
-- executed after the savepoint.
ROLLBACK TO one_row_inserted;

-- This only commits the first insert statement.
COMMIT;

ROLLBACK TO savepoint_name

ROLLBACK TO savepoint_name

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

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

RELEASE [SAVEPOINT] savepoint_name

RELEASE savepoint_name

הסרת נקודת השמירה מהטרנזקציה הנוכחית. אי אפשר יותר להשתמש בו כדי להריץ הצהרה של ROLLBACK TO savepoint_name.

תצהירים

ההצהרות הבאות יוצרות ומריצות הצהרות מוכנות.

הכנה

PREPARE statement_name [(data_type, ...)] AS statement

מכין הצהרה לגבי החיבור הזה. ההצהרה מנותחת ומאומתת על ידי Spanner ומאוחסנת בזיכרון ב-PGAdapter.

‫▶ דוגמה: הצהרות מוכנות (יש ללחוץ כדי להרחיב את הקטע)
 בדוגמה הבאה אפשר לראות איך ליצור ולהפעיל הצהרות מוכנות באמצעות PGAdapter.

-- Create a prepared statement that can be used to insert a single row.
PREPARE insert_t AS INSERT INTO T (id, col_a, col_b) VALUES ($1, $2, $3);

-- The prepared statement can be used to insert rows both in autocommit, in a
-- transaction, and in DML batches.

-- Execute in autocommit.
EXECUTE insert_t (1, 100, 1);

-- Execute in transaction.
BEGIN;
EXECUTE insert_t (2, 200, 2);
EXECUTE insert_t (3, 300, 3);
COMMIT;

-- Execute in a DML batch.
START BATCH DML;
EXECUTE insert_t (4, 400, 4);
EXECUTE insert_t (5, 500, 5);
RUN BATCH;

-- Prepared statements can be removed with the DEALLOCATE command.
DEALLOCATE insert_t;

EXECUTE

EXECUTE statement_name [(value, ...)]

מריץ הצהרה שנוצרה בחיבור הזה באמצעות PREPARE.

‫▶ דוגמה: הפעלה (לחיצה להרחבה)
 בדוגמה הבאה אפשר לראות איך מכינים ומריצים הצהרות באמצעות PGAdapter.

-- Create a prepared statement.
PREPARE my_statement AS insert into my_table (id, value) values ($1, $2);

-- Execute the statement twice with different parameter values.
EXECUTE my_statement (1, 'One');
EXECUTE my_statement (2, 'Two');

ביטול הקצאה

DEALLOCATE statement_name

הסרת הצהרה מוכנה מהחיבור הזה.

העתקה

‫PGAdapter תומך בקבוצת משנה של הפקודה COPY של PostgreSQL.

COPY table_name FROM STDIN

COPY table_name FROM STDIN [BINARY]

העתקת נתונים מ-stdin אל Spanner. יעיל יותר להשתמש ב-COPY כדי לייבא מערך נתונים גדול ל-Spanner מאשר להריץ הצהרות של INSERT.

אפשר לשלב את COPY עם SPANNER.AUTOCOMMIT_DML_MODE כדי לבצע עסקה לא אטומית. כך העסקה יכולה לבצע יותר מוטציות מהמגבלה הרגילה של מוטציות בעסקה.

‫▶ דוגמה: העתקה (לוחצים כדי להרחיב)
 בדוגמאות הבאות אפשר לראות איך מעתיקים נתונים אל Spanner וממנו באמצעות PGAdapter.

create table numbers (number bigint not null primary key, name varchar);

ביצוע פעולת COPY אטומית:

cat numbers.txt | psql -h /tmp -d test-db -c "copy numbers from stdin;"

ביצוע פעולה לא אטומית COPY:

cat numbers.txt | psql -h /tmp -d test-db \
  -c "set spanner.autocommit_dml_mode='partitioned_non_atomic'; copy numbers from stdin;"

העתקת נתונים מ-PostgreSQL ל-Spanner:

psql -h localhost -p 5432 -d my-local-db \
  -c "copy (select i, to_char(i, 'fm000') from generate_series(1, 1000000) s(i)) to stdout binary" \
  | psql -h localhost -p 5433 -d my-spanner-db \
  -c "set spanner.autocommit_dml_mode='partitioned_non_atomic'; copy numbers from stdin binary;"

בדוגמה הזו מניחים ש-PostgreSQL פועל ביציאה 5432 ו-PGAdapter פועל ביציאה 5433.

דוגמאות נוספות זמינות במאמר PGAdapter – תמיכה בפקודה COPY.

‫COPY table_name TO STDOUT [BINARY]

COPY table_name TO STDOUT [BINARY]

הפונקציה מעתיקה את הנתונים בטבלה או משאילתה אל stdout.

הצהרות של שאילתות עם מחיצות ו-Data Boost

‫Data Boost מאפשר לכם להריץ שאילתות ניתוח ולייצא נתונים כמעט ללא השפעה על עומסי העבודה הקיימים במופע Spanner שהוקצה. האצת נתונים נתמכת רק בשאילתות עם חלוקה למחיצות.

אפשר להפעיל את התכונה 'הגדלת נפח הנתונים' באמצעות ההצהרה SET SPANNER.DATA_BOOST_ENABLED.

‫PGAdapter תומך בשלוש חלופות להרצת שאילתות עם חלוקה למחיצות:

  • SET SPANNER.AUTO_PARTITION_MODE = true
  • RUN PARTITIONED QUERY sql
  • ‫PARTITION sql ואחריו כמה RUN PARTITION 'partition-token'

כל אחת מהשיטות האלה מתוארת בקטעים הבאים.

SPANNER.DATA_BOOST_ENABLED

SHOW SPANNER.DATA_BOOST_ENABLED
SET SPANNER.DATA_BOOST_ENABLED {TO|=} { true | false }

המדיניות קובעת אם החיבור הזה ישתמש בData Boost לשאילתות עם חלוקה למחיצות.

ערך ברירת המחדל הוא false.

‫▶ דוגמה: הרצת שאילתה באמצעות Data Boost (לחיצה להרחבה)
 בדוגמה הבאה מוצגת שאילתה שמשתמשת ב-Data Boost עם PGAdapter.

-- Enable Data Boost on this connection.
SET SPANNER.DATA_BOOST_ENABLED = true;

-- Execute a partitioned query. Data Boost is only used for partitioned queries.
RUN PARTITIONED QUERY SELECT FirstName, LastName FROM Singers;

SPANNER.AUTO_PARTITION_MODE

SHOW SPANNER.AUTO_PARTITION_MODE
SET SPANNER.AUTO_PARTITION_MODE {TO|=} { true | false}

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

  • מגדירים את המשתנה הזה לערך true אם רוצים שהחיבור ישתמש בשאילתה עם חלוקה למחיצות לכל השאילתות שמופעלות.
  • אם רוצים שהחיבור ישתמש בData Boost לכל השאילתות, צריך להגדיר את SPANNER.DATA_BOOST_ENABLED ל-true.

ערך ברירת המחדל הוא false.

‫▶ דוגמה: הפעלה (לחיצה להרחבה)
 בדוגמה הזו מבוצעות שתי שאילתות באמצעות PGAdapter עם Data Boost

SET SPANNER.AUTO_PARTITION_MODE = true
SET SPANNER.DATA_BOOST_ENABLED = true
SELECT first_name, last_name FROM singers
SELECT singer_id, title FROM albums

הפעלת שאילתה עם חלוקה למחיצות

RUN PARTITIONED QUERY <sql>

מריץ שאילתה כשאילתה מחולקת ב-Spanner. מוודאים שהערך של SPANNER.DATA_BOOST_ENABLED מוגדר ל-true כדי להריץ את השאילתה עם Data Boost:

SET SPANNER.DATA_BOOST_ENABLED = true
RUN PARTITIONED QUERY SELECT FirstName, LastName FROM Singers

‫PGAdapter מחלק את השאילתה באופן פנימי ומבצע את החלוקות במקביל. התוצאות ממוזגות לקבוצת תוצאות אחת ומוחזרות לאפליקציה. אפשר להגדיר את מספר השרשורים של העובדים שמבצעים מחיצות באמצעות המשתנה SPANNER.MAX_PARTITIONED_PARALLELISM.

PARTITION <SQL>

PARTITION <sql>

יוצר רשימה של מחיצות להרצת שאילתה ב-Spanner ומחזיר רשימה של טוקנים של מחיצות. אפשר להריץ כל אסימון של חלוקה למחיצות בחיבור נפרד באותו מופע של PGAdapter או במופע אחר באמצעות הפקודה RUN PARTITION 'partition-token'.

‫▶ דוגמה: שאילתת חלוקה (צריך ללחוץ כדי להרחיב)
 בדוגמה הבאה אפשר לראות איך מחלקים שאילתה למחיצות ואז מריצים כל מחיצה בנפרד באמצעות PGAdapter.

-- Partition a query. This returns a list of partition tokens that can be
-- executed either on this connection or on any other connection to the same
-- database.
PARTITION SELECT FirstName, LastName FROM Singers;

-- Run the partitions that were returned from the previous statement.
RUN PARTITION 'partition-token-1';
RUN PARTITION 'partition-token-2';

RUN PARTITION 'partition-token'

RUN PARTITION 'partition-token'

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

SPANNER.MAX_PARTITIONED_PARALLELISM

מאפיין מסוג bigint שמציין את מספר ה-worker threads ש-PGAdapter משתמש בהם כדי להפעיל מחיצות. הערך הזה משמש למטרות הבאות:

  • SPANNER.AUTO_PARTITION_MODE = true
  • RUN PARTITIONED QUERY sql
SHOW SPANNER.MAX_PARTITIONED_PARALLELISM
SET SPANNER.MAX_PARTITIONED_PARALLELISM {TO|=} <bigint>

המספר המקסימלי של שרשורי עובדים ש-PGAdapter יכול להשתמש בהם כדי להריץ מחיצות. הגדרת הערך הזה ל-0 מורה ל-PGAdapter להשתמש במספר ליבות ה-CPU במכונת הלקוח כמספר המקסימלי.

ערך ברירת המחדל הוא 0.

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