סקירה כללית של GoogleSQL for Bigtable

אתם יכולים להשתמש בהצהרות GoogleSQL כדי לשלוח שאילתות לנתוני Bigtable. ‫GoogleSQL היא שפת שאילתות מובנית (SQL) שתואמת לתקן ANSI, והיא מיושמת גם בשירותים אחרים כמו BigQuery ו-Spanner. Google Cloud

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

אפשר ליצור ולהריץ שאילתות ב-Bigtable Studio במסוף Google Cloud , או להריץ אותן באופן פרוגרמטי באמצעות ספריית הלקוח של Bigtable ל-Java, ל-Python או ל-Go. מידע נוסף זמין במאמר שימוש ב-SQL עם ספריית לקוח של Bigtable.

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

תרחישים לדוגמה

‫GoogleSQL for Bigtable הוא פתרון אופטימלי לפיתוח אפליקציות עם זמן אחזור קצר. בנוסף, הפעלת שאילתות SQL במסוףGoogle Cloud יכולה להיות שימושית כדי לקבל במהירות ייצוג חזותי של סכימת טבלה, כדי לוודא שנתונים מסוימים נכתבו או כדי לנפות באגים בבעיות נתונים אפשריות.

הגרסה הנוכחית של GoogleSQL ל-Bigtable לא תומכת בכמה מבנים נפוצים של SQL, כולל, בין היתר, המבנים הבאים:

• פקודות בשפת טיפול בנתונים (DML) מעבר ל-SELECT, כמו INSERT,‏ UPDATE או DELETE
• הצהרות של שפת הגדרת נתונים (DDL) כמו CREATE, ALTER או DROP
• הצהרות של בקרת גישה לנתונים
• תחביר של שאילתות משנה, JOIN, UNION ו-CTEs

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

תצוגות

אפשר להשתמש ב-GoogleSQL ל-Bigtable כדי ליצור את המשאבים הבאים:

• תצוגה חומרית מתמשכת – תוצאה מחושבת מראש של שאילתת SQL שפועלת באופן רציף, כולל נתונים מצטברים, שמסונכרנת עם טבלת המקור שלה באמצעות עדכונים מצטברים.
• תצוגה לוגית – שאילתה שמורה עם שם שאפשר להריץ עליה שאילתות כמו על טבלה.

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

מושגים מרכזיים

בקטע הזה נסביר מושגים חשובים שכדאי להכיר כשמשתמשים ב-GoogleSQL כדי לשלוח שאילתות לנתוני Bigtable.

קבוצות עמודות בתשובות של SQL

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

• עמודה מיוחדת בשם _key שתואמת למפתחות השורות בטבלה שנשלחה לגביה שאילתה
• עמודה אחת לכל קבוצת עמודות ב-Bigtable בטבלה, שמכילה את הנתונים של קבוצת העמודות בשורה הזו

סוג הנתונים של המיפוי

‫GoogleSQL for Bigtable כולל את סוג הנתונים MAP<key, value>, שנועד במיוחד להתאים למשפחות עמודות.

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

הדוגמה הבאה היא של שאילתת SQL שמחזירה טבלה עם ערך מפתח השורה והערך האחרון של המאפיין מתוך מפה בשם columnFamily.

  SELECT _key, columnFamily['qualifier'] FROM myTable

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

במקרה הזה, המפות שמייצגות משפחות של עמודות הן מקוננות ומוחזרות כמערך. במערך, כל ערך הוא מיפוי שמורכב מחותמת זמן כמפתח ומנתוני התא כערך. הפורמט הוא MAP<key, ARRAY<STRUCT<timestamp, value>>>.

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

  SELECT _key, info FROM users(with_history => TRUE) WHERE _key = 'user_123';

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

/*----------+------------------------------------------------------------------------------------------------------------------------------------*
 |   _key   |                                                                info                                                                |
 +----------+------------------------------------------------------------------------------------------------------------------------------------+
 | user_123 | {"city": [{<t5> timestamp, "Brooklyn" value}, {<t0> timestamp, "New York" value}], "state": [{<t0> timestamp, "NY" value}]}        |
 +----------+------------------------------------------------------------------------------------------------------------------------------------*/

טבלאות דלילות

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

עם זאת, כשמבצעים שאילתה בטבלת Bigtable באמצעות GoogleSQL, עמודה שלא נעשה בה שימוש מיוצגת באמצעות מפה ריקה ומוחזרת כערך NULL. אפשר להשתמש בערכי NULL האלה כפרדיקטים של שאילתות. לדוגמה, אפשר להשתמש בפרדיקט כמו WHERE family['column1'] IS NOT NULL כדי להחזיר שורה רק אם נעשה שימוש ב-column1 בשורה.

בייטים

כאשר אתה מספק מחרוזת, GoogleSQL כברירת מחדל מבצע באופן מרומז הטלה מערכי STRING לערכים של BYTES. לדוגמה, במקום רצף הבייטים b'qualifier', אפשר להזין את המחרוזת 'qualifier'.

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

מסננים זמניים

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

ארגומנט	תיאור
as_of	חותמת זמן. הפונקציה מחזירה את הערכים האחרונים עם חותמות זמן שקטנות מחותמת הזמן שצוינה או שוות לה.
with_history	בוליאני. המדיניות קובעת אם הערך האחרון יוחזר כסקלר או כערכים עם חותמת זמן(timestamp) כ-STRUCT.
after	חותמת זמן. ערכים עם חותמות זמן אחרי הקלט, לא כולל. נדרש with_history => TRUE.
after_or_equal	חותמת זמן. ערכים עם חותמות זמן אחרי הקלט, כולל. נדרש with_history => TRUE.
before	חותמת זמן. ערכים עם חותמות זמן לפני הקלט, לא כולל. נדרש with_history => TRUE.
latest_n	מספר שלם. מספר הערכים עם חותמת הזמן שיוחזרו לכל מסווג עמודה (מפתח מפה). הערך חייב להיות גדול מ-1 או שווה לו. נדרש with_history => TRUE.

דוגמאות נוספות זמינות במאמר בנושא דפוסי שאילתות מתקדמות.

שאילתות בסיסיות

בקטע הזה מתוארות שאילתות SQL בסיסיות ב-Bigtable, מוצגות דוגמאות שלהן ומוסבר איך הן פועלות. דוגמאות נוספות לשאילתות זמינות במאמר דוגמאות למבני שאילתות ב-GoogleSQL ל-Bigtable.

שחזור הגרסה האחרונה

למרות ש-Bigtable מאפשר לשמור כמה גרסאות של נתונים בכל עמודה, GoogleSQL for Bigtable מחזיר כברירת מחדל את הגרסה האחרונה – התא האחרון – של הנתונים בכל שורה.

הנה מערך נתונים לדוגמה שבו אפשר לראות ש-user1 עבר פעמיים בתוך מדינת ניו יורק ופעם אחת בתוך העיר ברוקלין. בדוגמה הזו, address היא קבוצת העמודות, והמסווגים של העמודות הם street,‏ city ו-state. התאים בעמודה מופרדים באמצעות שורות ריקות.

		address
_key	street	city	state
user1	2023/01/10-14:10:01.000: '113 Xyz Street' 2021/12/20-09:44:31.010: '76 Xyz Street' 2005/03/01-11:12:15.112: '123 Abc Street'	‪2021/12/20-09:44:31.010: 'Brooklyn' ‪2005/03/01-11:12:15.112: 'Queens'	2005/03/01-11:12:15.112: 'NY'

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

   SELECT address['street'], address['city'] FROM myTable WHERE _key = 'user1'

התגובה מכילה את הכתובת הנוכחית, שהיא שילוב של הערכים האחרונים של הרחוב, העיר והמדינה (שנכתבו בזמנים שונים), שמוצגים כ-JSON. חותמות הזמן לא נכללות בתשובה.

_key	address
user1	‪{street:'113 Xyz Street', city:'Brooklyn', state: :'NY'}

אחזור כל הגרסאות

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

  SELECT _key, columnFamily['qualifier'] AS col1
  FROM myTable(with_history => TRUE)

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

  SELECT
    address['street'][0].value AS moved_to,
    address['street'][1].value AS moved_from,
    FORMAT_TIMESTAMP('%Y-%m-%d', address['street'][0].timestamp) AS moved_on,
  FROM myTable(with_history => TRUE)
  WHERE _key = 'user1'

כשמשתמשים בדגל with_history בשאילתת SQL, התשובה מוחזרת כ-MAP<key, ARRAY<STRUCT<timestamp, value>>>. כל פריט במערך הוא ערך עם חותמת זמן של השורה, משפחת העמודות והעמודה שצוינו. חותמות הזמן מסודרות בסדר כרונולוגי הפוך, כך שהנתונים העדכניים ביותר תמיד מוחזרים ראשונים.

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

זו תהיה התגובה לשאילתה.

moved_to			moved_from	moved_on
113 Xyz Street			‪76 Xyz Street	‫2023/01/10

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

  SELECT _key, ARRAY_LENGTH(MAP_ENTRIES(address)) AS version_count
  FROM myTable(with_history => TRUE)

אחזור נתונים מנקודת זמן ספציפית

שימוש במסנן as_of מאפשר לאחזר את המצב של שורה מסוימת בזמן מסוים. לדוגמה, אם רוצים לדעת את הכתובת של user נכון ל-10 בינואר 2022 בשעה 13:14, אפשר להריץ את השאילתה הבאה.

  SELECT address
  FROM myTable(as_of => TIMESTAMP('2022-01-10T13:14:00.234Z'))
  WHERE _key = 'user1'

התוצאה מראה מה הייתה הכתובת האחרונה הידועה ב-10 בינואר 2022 בשעה 13:14, שהיא שילוב של הרחוב והעיר מהעדכון 2021/12/20-09:44:31.010 והמדינה מהעדכון 2005/03/01-11:12:15.112.

address
‪{street:'76 Xyz Street', city:'Brooklyn', state: :'NY'}

אפשר להשיג את אותה תוצאה גם באמצעות חותמות זמן של Unix.

  SELECT address
  FROM myTable(as_of => TIMESTAMP_FROM_UNIX_MILLIS(1641820440000))
  WHERE _key = 'user1'

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

	alarmType
_key	עשן	carbonMonoxide
building1#section1	‫2023/04/01-09:10:15.000: 'off' 2023/04/01-08:41:40.000: 'on' 2020/07/03-06:25:31.000: 'off' 2020/07/03-06:02:04.000: 'on'	‫2023/04/01-09:22:08.000: 'off' 2023/04/01-08:53:12.000: 'on'
building1#section2	‪2021/03/11-07:15:04.000: 'off' ‪2021/03/11-07:00:25.000: 'on'

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

  SELECT _key AS location, alarmType['carbonMonoxide'] AS CO_sensor
  FROM alarms(as_of => TIMESTAMP('2023-04-01T09:00:00.000Z'))
  WHERE _key LIKE 'building1%' and alarmType['smoke'] = 'on'

התוצאה היא:

מיקום	CO_sensor
building1#section1	'on'

שליחת שאילתות לנתונים של פעולות על ציר הזמן

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

	metrics
_key	temperature	humidity
sensorA#20230105	‫2023/01/05-02:00:00.000: 54 ‫2023/01/05-01:00:00.000: 56 ‫2023/01/05-00:00:00.000: 55	‫2023/01/05-02:00:00.000: 0.89 ‫2023/01/05-01:00:00.000: 0.9 ‫2023/01/05-00:00:00.000: 0.91
sensorA#20230104	2023/01/04-23:00:00.000: 56 2023/01/04-22:00:00.000: 57	‫2023/01/04-23:00:00.000: 0.9 ‫2023/01/04-22:00:00.000: 0.91

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

   SELECT metrics['temperature'] AS temp_versioned
   FROM
   sensorReadings(with_history => true, after => TIMESTAMP('2023-01-04T23:00:00.000Z'),
         before => TIMESTAMP('2023-01-05T01:00:00.000Z'))
   WHERE _key LIKE 'sensorA%'

השאילתה מחזירה את הנתונים בפורמט הזה:

temp_versioned
‪[{timestamp: '2023/01/05-01:00:00.000', value:56} {timestamp: '2023/01/05-00:00:00.000', value: 55}]
[{timestamp: '2023/01/04-23:00:00.000', value:56}]

UNPACK נתונים של פעולות על ציר הזמן

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

‫UNPACK היא פונקציית ערך טבלה (TVF) של Bigtable שמחזירה טבלת פלט שלמה במקום ערך סקלרי יחיד, והיא מופיעה בסעיף FROM כמו שאילתת משנה של טבלה. הפונקציה UNPACK TVF מרחיבה כל ערך עם חותמת זמן לכמה שורות – שורה אחת לכל חותמת זמן – ומעבירה את חותמת הזמן לעמודה _timestamp.

הקלט של UNPACK הוא שאילתת משנה שבה with_history => true.

הפלט הוא טבלה מורחבת עם עמודה _timestamp בכל שורה.

קבוצת עמודות של קלט MAP<key, ARRAY<STRUCT<timestamp, value>>>מתפרקת ל-MAP<key, value>, ומסווג עמודות ARRAY<STRUCT<timestamp, value>>> מתפרק ל-value. סוגים אחרים של עמודות קלט לא משתנים. כדי שהעמודות יפורקו וייבחרו, צריך לבחור אותן בשאילתת המשנה. לא צריך לבחור את העמודה החדשה _timestamp כדי לבצע פירוק של חותמות הזמן.

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

  SELECT temp_versioned, _timestamp
  FROM
  UNPACK((
    SELECT metrics['temperature'] AS temperature_versioned
    FROM
    sensorReadings(with_history => true, after => TIMESTAMP('2023-01-04T23:00:00.000Z'),
          before => TIMESTAMP('2023-01-05T01:00:00.000Z'))
    WHERE _key LIKE 'sensorA%'
  ));

השאילתה מחזירה את הנתונים בפורמט הזה:

temp_versioned	_timestamp
55	1672898400
55	1672894800
56	1672891200

שאילתת JSON

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

לדוגמה, אפשר לאחזר את הערך של רכיב ה-JSON‏ abc מהתא האחרון במשפחת העמודות session יחד עם מפתח השורה באמצעות השאילתה הבאה.

  SELECT _key, JSON_VALUE(session['payload'],'$.abc') AS abc FROM analytics

תו בריחה (escape) לתווים מיוחדים ולמילים שמורות

ב-Bigtable יש גמישות רבה במתן שמות לטבלאות ולעמודות. כתוצאה מכך, יכול להיות שתצטרכו להשתמש בתווי בריחה (escape) בשמות הטבלאות בשאילתות ה-SQL שלכם, בגלל תווים מיוחדים או מילים שמורות.

לדוגמה, השאילתה הבאה היא לא שאילתת SQL תקינה בגלל הנקודה בשם הטבלה.

  -- ERROR: Table name format not supported

  SELECT * FROM my.table WHERE _key = 'r1'

אבל אפשר לפתור את הבעיה הזו על ידי הוספת תו גרש הפוך (`) לפני ואחרי הפריטים.

  SELECT * FROM `my.table` WHERE _key = 'r1'

אם משתמשים במילת מפתח שמורה של SQL כמזהה, אפשר להשתמש בתו בריחה באופן דומה.

  SELECT * FROM `select` WHERE _key = 'r1'

שימוש ב-SQL עם ספריית לקוח של Bigtable

ספריות הלקוח של Bigtable ל-Java, ל-Python ול-Go תומכות בשאילתות של נתונים באמצעות SQL באמצעות executeQuery API. בדוגמאות הבאות מוסבר איך לשלוח שאילתה ולגשת לנתונים:

המשך

כדי להשתמש בתכונה הזו, צריך להשתמש ב-cloud.google.com/go/bigtable מגרסה 1.36.0 ואילך. מידע נוסף על השימוש זמין במאמרי העזרה בנושא PrepareStatement,‏ Bind,‏ Execute ו-ResultRow.

  import (
    "cloud.google.com/go/bigtable"
  )

  func query(client *bigtable.Client) {
    // Prepare once for queries that will be run multiple times, and reuse
    // the PreparedStatement for each request. Use query parameters to
    // construct PreparedStatements that can be reused.
    ps, err := client.PrepareStatement(
      "SELECT cf1['bytesCol'] AS bytesCol, CAST(cf2['stringCol'] AS STRING) AS stringCol, cf3 FROM myTable WHERE _key=@keyParam",
      map[string]SQLType{
        "keyParam": BytesSQLType{},
      }
    )
    if err != nil {
      log.Fatalf("Failed to create PreparedStatement: %v", err)
    }

    // For each request, create a BoundStatement with your query parameters set.
    bs, err := ps.Bind(map[string]any{
      "keyParam": []byte("mykey")
    })
    if err != nil {
      log.Fatalf("Failed to bind parameters: %v", err)
    }

    err = bs.Execute(ctx, func(rr ResultRow) bool {
      var byteValue []byte
      err := rr.GetByName("bytesCol", &byteValue)
      if err != nil {
        log.Fatalf("Failed to access bytesCol: %v", err)
      }
      var stringValue string
      err = rr.GetByName("stringCol", &stringValue)
      if err != nil {
        log.Fatalf("Failed to access stringCol: %v", err)
      }
      // Note that column family maps have byte valued keys. Go maps don't support
      // byte[] keys, so the map will have Base64 encoded string keys.
      var cf3 map[string][]byte
      err = rr.GetByName("cf3", &cf3)
      if err != nil {
        log.Fatalf("Failed to access cf3: %v", err)
      }
      // Do something with the data
      // ...
      return true
    })
  }

Java

כדי להשתמש בתכונה הזו, צריך להשתמש ב-java-bigtable מגרסה 2.57.3 ואילך. מידע נוסף על השימוש זמין במאמרים בנושא prepareStatement,‏ executeQuery,‏ BoundStatement ו-ResultSet ב-Javadoc.

  static void query(BigtableDataClient client) {
    // Prepare once for queries that will be run multiple times, and reuse
    // the PreparedStatement for each request. Use query parameters to
    // construct PreparedStatements that can be reused.
    PreparedStatement preparedStatement = client.prepareStatement(
      "SELECT cf1['bytesCol'] AS bytesCol, CAST(cf2['stringCol'] AS STRING) AS stringCol, cf3 FROM myTable WHERE _key=@keyParam",
      // For queries with parameters, set the parameter names and types here.
      Map.of("keyParam", SqlType.bytes())
    );

    // For each request, create a BoundStatement with your query parameters set.
    BoundStatement boundStatement = preparedStatement.bind()
      .setBytesParam("keyParam", ByteString.copyFromUtf8("mykey"))
      .build();

    try (ResultSet resultSet = client.executeQuery(boundStatement)) {
      while (resultSet.next()) {
        ByteString byteValue = resultSet.getBytes("bytesCol");
        String stringValue = resultSet.getString("stringCol");
        Map<ByteString, ByteString> cf3Value =
            resultSet.getMap("cf3", SqlType.mapOf(SqlType.bytes(), SqlType.bytes()));
        // Do something with the data.
      }
    }
  }

‫Python asyncio

כדי להשתמש בתכונה הזו, צריך להשתמש בגרסה 2.30.1 ואילך של python-bigtable.

  from google.cloud.bigtable.data import BigtableDataClientAsync

  async def execute_query(project_id, instance_id, table_id):
      async with BigtableDataClientAsync(project=project_id) as client:
          query = (
            "SELECT cf1['bytesCol'] AS bytesCol, CAST(cf2['stringCol'] AS STRING) AS stringCol,"
            " cf3 FROM {table_id} WHERE _key='mykey'"
          )
          async for row in await client.execute_query(query, instance_id):
            print(row["_key"], row["bytesCol"], row["stringCol"], row["cf3"])

שימוש ב-SELECT *

יכול להיות ששאילתות SELECT * יחוו שגיאות זמניות כשמוסיפים או מוחקים קבוצת עמודות מהטבלה שנשאלה. לכן, כדי לעבד עומסי עבודה של ייצור, מומלץ לציין את כל מזהי משפחות העמודות בשאילתה, במקום להשתמש ב-SELECT *. לדוגמה, צריך להשתמש ב-SELECT cf1, cf2, cf3 במקום ב-SELECT *.

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

• למסמכי העזרה של GoogleSQL for Bigtable
• מידע נוסף על Bigtable Studio
• איך מפתחים אפליקציות עם GoogleSQL ל-Bigtable