יצירה של טבלאות ושימוש בהן

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

• יצירת טבלאות עם חלוקה למחיצות
• יצירה של טבלאות מקובצות ושימוש בהן

אחרי שיוצרים טבלה, אפשר:

• שליטה בגישה לנתוני הטבלה.
• קבלת מידע על הטבלאות.
• הצגת רשימה של הטבלאות במערך נתונים.
• אחזור מטא-נתונים של טבלה.

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

לפני שמתחילים

הקצאת תפקידים של ניהול זהויות והרשאות גישה (IAM) שמעניקים למשתמשים את ההרשאות הדרושות לביצוע כל משימה שמופיעה במאמר הזה.

התפקידים הנדרשים

כדי לקבל את ההרשאות שדרושות ליצירת טבלה, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים:

• ‫BigQuery Job User (roles/bigquery.jobUser) בפרויקט אם יוצרים טבלה על ידי טעינת נתונים או על ידי שמירת תוצאות של שאילתה בטבלה.
• ‫BigQuery Data Editor (roles/bigquery.dataEditor) במערך הנתונים שבו יוצרים את הטבלה.

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

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

ההרשאות הנדרשות

כדי ליצור טבלה, צריך את ההרשאות הבאות:

• bigquery.tables.create במערך הנתונים שבו אתם יוצרים את הטבלה.
• bigquery.tables.getData בכל הטבלאות והתצוגות שהשאילתה מפנה אליהן, אם שומרים את תוצאות השאילתה כטבלה.
• bigquery.jobs.create בפרויקט אם יוצרים את הטבלה על ידי טעינת נתונים או על ידי שמירת תוצאות של שאילתה בטבלה.
• bigquery.tables.updateData בטבלה אם מוסיפים לטבלה או מחליפים אותה בתוצאות של שאילתה.

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

הערה: אם יש לכם הרשאת bigquery.datasets.create, אתם יכולים ליצור טבלאות במערכי הנתונים שאתם יוצרים.

מתן שמות לטבלאות

כשיוצרים טבלה ב-BigQuery, שם הטבלה צריך להיות ייחודי לכל מערך נתונים. שם הטבלה יכול:

• להכיל תווים עם סך של עד 1,024 בייטים בקידוד UTF-8.
• להכיל תווים ב-Unicode בקטגוריות L (אות), M (סימן), N (מספר), Pc (מחבר, כולל קו תחתון), Pd (מקף), Zs (רווח). מידע נוסף זמין במאמר בנושא קטגוריה כללית.

השמות הבאים הם דוגמאות לשמות תקינים של טבלאות: table 01, ग्राहक, 00_お客様, étudiant-01.

הערות:

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

• אם כוללים כמה אופרטורים של נקודה (.) ברצף, המערכת מסירה באופן משתמע את האופרטורים הכפולים.

  לדוגמה, כך: project_name....dataset_name..table_name

  הופך ל: project_name.dataset_name.table_name

יצירת טבלאות

אפשר ליצור טבלה ב-BigQuery בדרכים הבאות:

• באופן ידני באמצעות מסוף Google Cloud או כלי שורת הפקודה של BigQuery, הפקודה bq mk.
• באופן פרוגרמטי באמצעות קריאה ל-method של ה-API ‏tables.insert.
• באמצעות ספריות לקוח.
• מתוצאות השאילתה.
• על ידי הגדרת טבלה שמפנה למקור נתונים חיצוני.
• כשאתם טוענים נתונים.
• באמצעות הצהרה של CREATE TABLE שפת הגדרת נתונים (DDL).

יצירת טבלה ריקה עם הגדרת סכימה

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

• מזינים את הסכימה באמצעות המסוף Google Cloud .
• מספקים את הסכימה בשורה באמצעות כלי שורת הפקודה של BigQuery.
• שולחים קובץ סכימת JSON באמצעות כלי שורת הפקודה של BigQuery.
• כשמפעילים את השיטה tables.insert של ממשקי ה-API, צריך לספק את הסכימה במשאב של טבלה.

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

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

כדי ליצור טבלה ריקה עם הגדרת סכימה:

המסוף

1. במסוף Google Cloud , עוברים לדף BigQuery.

   כניסה לדף BigQuery

2. בחלונית הימנית, לוחצים על כלי הניתוחים.
3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ובוחרים מערך נתונים.
4. בקטע פרטי מערך הנתונים, לוחצים על יצירת טבלה.
5. בחלונית Create table, מציינים את הפרטים הבאים:
1. בקטע מקור, בוחרים באפשרות טבלה ריקה ברשימה יצירת טבלה מ.
2. בקטע יעד, מציינים את הפרטים הבאים:
   1. בקטע Dataset (מערך נתונים), בוחרים את מערך הנתונים שבו רוצים ליצור את הטבלה.
   2. בשדה Table (טבלה), מזינים את השם של הטבלה שרוצים ליצור.
   3. מוודאים שהשדה Table type (סוג הטבלה) מוגדר ל-Native table (טבלה מקורית).
3. בקטע Schema (סכימה), מזינים את הגדרת הסכימה. אפשר להזין את פרטי הסכימה באופן ידני באחת מהשיטות הבאות:
   • אפשרות 1: לוחצים על עריכה כטקסט ומדביקים את הסכימה בצורה של מערך JSON. כשמשתמשים במערך JSON, יוצרים את הסכימה באותו תהליך שבו יוצרים קובץ סכימת JSON. כדי לראות את הסכימה של טבלה קיימת בפורמט JSON, מזינים את הפקודה הבאה:

         bq show --format=prettyjson dataset.table
         

   • אפשרות 2: לוחצים על הוספת שדה ומזינים את סכימת הטבלה. מציינים את השם, הסוג, והמצב של כל שדה.
4. אופציונלי: מציינים הגדרות של מחיצה ושל אשכול. מידע נוסף זמין במאמרים בנושא יצירת טבלאות עם חלוקה למחיצות ויצירה ושימוש בטבלאות מקובצות.
5. אופציונלי: בקטע Advanced options, אם רוצים להשתמש במפתח הצפנה בניהול הלקוח, בוחרים באפשרות Use a customer-managed encryption key (CMEK). כברירת מחדל, BigQuery מצפין את תוכן הלקוחות שמאוחסן במצב מנוחה באמצעות Google-owned and Google-managed encryption key.
6. לוחצים על יצירת טבלה.

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

Google Cloud

SQL

בדוגמה הבאה נוצרת טבלה בשם newtable שתוקף שלה יפוג ב-1 בינואר 2023:

1. במסוף Google Cloud , עוברים לדף BigQuery.

   כניסה ל-BigQuery

2. מזינים את ההצהרה הבאה בעורך השאילתות:

   CREATE TABLE mydataset.newtable (
     x INT64 OPTIONS (description = 'An optional INTEGER field'),
     y STRUCT <
       a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'),
       b BOOL
     >
   ) OPTIONS (
       expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC',
       description = 'a table that expires in 2023',
       labels = [('org_unit', 'development')]);

3. לוחצים על הפעלה.

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

BQ

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. משתמשים בפקודה bq mk עם הדגל --table או -t. אפשר לספק את פרטי סכימת הטבלה בשורה או באמצעות קובץ סכימת JSON. רשימה מלאה של הפרמטרים זמינה בחומר העזר בנושא bq mk --table. פרמטרים אופציונליים לדוגמה:

   • --expiration
   • --description
   • --time_partitioning_field
   • --time_partitioning_type
   • --range_partitioning
   • --clustering_fields
   • --destination_kms_key
   • --label

   התכונות --time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields וגם --destination_kms_key לא מוצגות כאן. מידע נוסף על הפרמטרים האופציונליים האלה זמין בקישורים הבאים:

   • מידע נוסף על --time_partitioning_field,‏ --time_partitioning_type ו---range_partitioning זמין במאמר בנושא טבלאות עם חלוקה למחיצות.
   • מידע נוסף על --clustering_fields זמין במאמר בנושא טבלאות מקובצות.
   • מידע נוסף על --destination_kms_key זמין במאמר בנושא מפתחות הצפנה בניהול הלקוח.

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

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

   bq mk \
   --table \
   --expiration=integer \
   --description=description \
   --label=key_1:value_1 \
   --label=key_2:value_2 \
   --add_tags=key_3:value_3[,...] \
   project_id:dataset.table \
   schema

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫integer הוא משך החיים שמוגדר כברירת מחדל (בשניות) לטבלה. הערך המינימלי הוא 3,600 שניות (שעה אחת). מועד התפוגה הוא השעה הנוכחית בשעון UTC בתוספת הערך השלם. אם מגדירים את זמן התפוגה כשיוצרים טבלה, הגדרת ברירת המחדל של זמן התפוגה של הטבלה במערך הנתונים מתעלמת.
   • ‫description: תיאור של הטבלה במירכאות.
   • ‫key_1:value_1 ו-key_2:value_2 הם זוגות של מפתח וערך שמציינים תוויות.
   • ‫key_3:value_3 הם זוגות של מפתח וערך שמציינים תגים. מוסיפים כמה תגים לאותו דגל, ומפרידים בין צמדי מפתח:ערך באמצעות פסיקים.
   • ‫project_id הוא מזהה הפרויקט.
   • ‫dataset הוא מערך נתונים בפרויקט.
   • ‫table הוא שם הטבלה שאתם יוצרים.
   • ‫schema היא הגדרה של סכימה מוטבעת בפורמט field:data_type,field:data_type או הנתיב לקובץ סכימת JSON במחשב המקומי.

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

   דוגמאות:

   מזינים את הפקודה הבאה כדי ליצור טבלה באמצעות הגדרת סכימה מוטמעת. הפקודה הזו יוצרת טבלה בשם mytable ב-mydataset בפרויקט ברירת המחדל. תפוגת הטבלה מוגדרת ל-3,600 שניות (שעה אחת), התיאור מוגדר ל-This is my table והתווית מוגדרת ל-organization:development. בפקודה נעשה שימוש בקיצור הדרך -t במקום ב---table. הסכימה מצוינת בשורה כ: qtr:STRING,sales:FLOAT,year:STRING.

   bq mk \
    -t \
    --expiration 3600 \
    --description "This is my table" \
    --label organization:development \
    mydataset.mytable \
    qtr:STRING,sales:FLOAT,year:STRING

   מזינים את הפקודה הבאה כדי ליצור טבלה באמצעות קובץ סכימת JSON. הפקודה הזו יוצרת טבלה בשם mytable ב-mydataset בפרויקט שמוגדר כברירת מחדל. תאריך התפוגה של הטבלה מוגדר ל-3,600 שניות (שעה אחת), התיאור מוגדר ל-This is my table והתווית מוגדרת ל-organization:development. הנתיב לקובץ הסכימה הוא /tmp/myschema.json.

   bq mk \
    --table \
    --expiration 3600 \
    --description "This is my table" \
    --label organization:development \
    mydataset.mytable \
    /tmp/myschema.json

   מזינים את הפקודה הבאה כדי ליצור טבלה באמצעות קובץ סכימת JSON. הפקודה הזו יוצרת טבלה בשם mytable ב-mydataset ב-myotherproject. תאריך התפוגה של הטבלה מוגדר ל-3,600 שניות (שעה אחת), התיאור מוגדר ל-This is my table והתווית מוגדרת ל-organization:development. הנתיב לקובץ הסכימה הוא /tmp/myschema.json.

   bq mk \
    --table \
    --expiration 3600 \
    --description "This is my table" \
    --label organization:development \
    myotherproject:mydataset.mytable \
    /tmp/myschema.json

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

Terraform

משתמשים במשאב google_bigquery_table.

הערה: כדי ליצור אובייקטים של BigQuery באמצעות Terraform, צריך להפעיל את Cloud Resource Manager API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

יצירת טבלה

בדוגמה הבאה נוצרת טבלה בשם mytable:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

יצירה של טבלה והענקת גישה אליה

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

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:[e-mail]",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

יצירת טבלה עם מפתח הצפנה בניהול הלקוח

בדוגמה הבאה נוצרת טבלה בשם mytable, ונעשה שימוש במשאבים google_kms_crypto_key ו-google_kms_key_ring כדי לציין מפתח של Cloud Key Management Service לטבלה. לפני שמריצים את הדוגמה הזו, צריך להפעיל את Cloud Key Management Service API.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

כדי להחיל את ההגדרות של Terraform בפרויקט ב- Google Cloud , מבצעים את השלבים בקטעים הבאים.

הכנת Cloud Shell

1. מפעילים את Cloud Shell.

2. מגדירים את פרויקט ברירת המחדל שבו רוצים להחיל את ההגדרות של Terraform. Google Cloud

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

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

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

הכנת הספרייה

לכל קובץ תצורה של Terraform צריכה להיות ספרייה משלו (שנקראת גם מודול ברמה הבסיסית).

1. יוצרים ספרייה חדשה ב-Cloud Shell ובה יוצרים קובץ חדש. שם הקובץ חייב לכלול את הסיומת .tf, למשל main.tf. במדריך הזה, הקובץ נקרא main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. אם אתם עוקבים אחרי המדריך, תוכלו להעתיק את הקוד לדוגמה בכל קטע או שלב.

   מעתיקים את הקוד לדוגמה בקובץ main.tf החדש שיצרתם.

   לחלופין, אפשר גם להעתיק את הקוד מ-GitHub. כדאי לעשות את זה כשקטע הקוד של Terraform הוא חלק מפתרון מקצה לקצה.

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

   terraform init

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

   terraform init -upgrade

החלה של השינויים

1. בודקים את ההגדרות ומוודאים שהמשאבים שמערכת Terraform תיצור או תעדכן תואמים לציפיות שלכם:

   terraform plan

   מתקנים את ההגדרות לפי הצורך.

2. מריצים את הפקודה הבאה ומזינים yes בהודעה שמופיעה, כדי להחיל את הגדרות Terraform:

   terraform apply

   ממתינים עד שב-Terraform תוצג ההודעה "Apply complete!‎".

3. פותחים את Google Cloud הפרויקט כדי לראות את התוצאות. במסוף Google Cloud , נכנסים למשאבים בממשק המשתמש כדי לוודא שהם נוצרו או עודכנו ב-Terraform.

הערה: בדרך כלל הנחת העבודה בדוגמאות של Terraform היא שממשקי ה-API הנדרשים מופעלים ב Google Cloud פרויקט.

API

מבצעים קריאה ל-tables.insert עם משאב טבלה מוגדר.

C#‎

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי C#הוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery C# API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

using Google.Cloud.BigQuery.V2;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

// Import the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי PHPהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery PHP API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Rubyהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Ruby API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

יצירת טבלה ריקה בלי הגדרת סכימה

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a table without schema
public class CreateTableWithoutSchema {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createTableWithoutSchema(datasetName, tableName);
  }

  public static void createTableWithoutSchema(String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

יצירת טבלה מתוצאת שאילתה

כדי ליצור טבלה מתוצאת שאילתה, כותבים את התוצאות לטבלת יעד.

המסוף

1. פותחים את הדף BigQuery במסוף Google Cloud .

   לדף BigQuery

2. בחלונית הימנית, לוחצים על כלי הניתוחים:

   

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

3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ואז בוחרים מערך נתונים.

4. מזינים שאילתת SQL תקינה בעורך השאילתות.

5. לוחצים על עוד ואז על הגדרות שאילתה.

   

6. בוחרים באפשרות הגדרת טבלת יעד לתוצאות השאילתה.

   

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

8. בקטע העדפת כתיבה לטבלת היעד, בוחרים באחת מהאפשרויות הבאות:

   • Write if empty (כתיבה אם ריק) – כתיבת תוצאות השאילתה לטבלה רק אם הטבלה ריקה.
   • הוספה לטבלה – הוספת תוצאות השאילתה לטבלה קיימת.
   • ‫Overwrite table (החלפת טבלה) – מחליף טבלה קיימת עם אותו שם בתוצאות השאילתה.

9. אופציונלי: בשדה Data location (מיקום הנתונים), בוחרים את המיקום הרצוי.

10. כדי לעדכן את הגדרות השאילתה, לוחצים על שמירה.

11. לוחצים על Run. הפעולה הזו יוצרת עבודת שאילתה שכותבת את תוצאות השאילתה לטבלה שצוינה.

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

SQL

בדוגמה הבאה נעשה שימוש בהצהרה CREATE TABLE כדי ליצור את הטבלה trips מנתונים בטבלה הציבורית bikeshare_trips:

1. במסוף Google Cloud , עוברים לדף BigQuery.

   כניסה ל-BigQuery

2. מזינים את ההצהרה הבאה בעורך השאילתות:

   CREATE TABLE mydataset.trips AS (
     SELECT
       bike_id,
       start_time,
       duration_minutes
     FROM
       bigquery-public-data.austin_bikeshare.bikeshare_trips
   );

3. לוחצים על הפעלה.

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

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

BQ

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. מזינים את הפקודה bq query ומציינים את הדגל --destination_table כדי ליצור טבלה קבועה על סמך תוצאות השאילתה. מציינים את הדגל use_legacy_sql=false כדי להשתמש בתחביר GoogleSQL. כדי לכתוב את תוצאות השאילתה לטבלה שלא נמצאת בפרויקט ברירת המחדל, מוסיפים את מזהה הפרויקט לשם מערך הנתונים בפורמט הבא: project_id:dataset.

   אופציונלי: מציינים את הדגל --location ומגדירים את הערך למיקום.

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

   • ‫--append_table: אם טבלת היעד קיימת, תוצאות השאילתה מצורפות אליה.

   • ‫--replace: אם טבלת היעד קיימת, היא מוחלפת בתוצאות השאילתה.

     bq --location=location query \
     --destination_table project_id:dataset.table \
     --use_legacy_sql=false 'query'

     מחליפים את מה שכתוב בשדות הבאים:

   • ‫location הוא שם המיקום שמשמש לעיבוד השאילתה. הדגל --location הוא אופציונלי. לדוגמה, אם אתם משתמשים ב-BigQuery באזור טוקיו, אתם יכולים להגדיר את הערך של הדגל ל-asia-northeast1. כדי להגדיר ערך ברירת מחדל למיקום, משתמשים בקובץ .bigqueryrc.

   • ‫project_id הוא מזהה הפרויקט.

   • ‫dataset הוא השם של מערך הנתונים שמכיל את הטבלה שאליה נכתבות תוצאות השאילתה.

   • ‫table הוא שם הטבלה שאליה נכתבות תוצאות השאילתה.

   • ‫query היא שאילתה בתחביר GoogleSQL.

     אם לא מצוין דגל של פעולת כתיבה, התנהגות ברירת המחדל היא כתיבת התוצאות לטבלה רק אם היא ריקה. אם הטבלה קיימת והיא לא ריקה, השגיאה הבאה מוחזרת: BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1: Already Exists: Table project_id:dataset.table.

     דוגמאות:

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

     מזינים את הפקודה הבאה כדי לכתוב את תוצאות השאילתה לטבלת יעד בשם mytable ב-mydataset. מערך הנתונים נמצא בפרויקט ברירת המחדל שלכם. מכיוון שלא צוין דגל של פעולת כתיבה בפקודה, הטבלה צריכה להיות חדשה או ריקה. אחרת, מוחזרת שגיאת Already exists. השאילתה שולפת נתונים ממערך הנתונים הציבורי USA Name Data.

     bq query \
     --destination_table mydataset.mytable \
     --use_legacy_sql=false \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'

     מזינים את הפקודה הבאה כדי להשתמש בתוצאות של שאילתה כדי להחליף טבלת יעד בשם mytable ב-mydataset. מערך הנתונים נמצא בפרויקט ברירת המחדל שלכם. בפקודה נעשה שימוש בדגל --replace כדי להחליף את טבלת היעד.

     bq query \
     --destination_table mydataset.mytable \
     --replace \
     --use_legacy_sql=false \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'

     מזינים את הפקודה הבאה כדי לצרף את תוצאות השאילתה לטבלת יעד בשם mytable ב-mydataset. מערך הנתונים נמצא בmy-other-project, ולא בפרויקט ברירת המחדל שלכם. הפקודה משתמשת בדגל --append_table כדי לצרף את תוצאות השאילתה לטבלת היעד.

     bq query \
     --append_table \
     --use_legacy_sql=false \
     --destination_table my-other-project:mydataset.mytable \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'

     הפלט של כל אחת מהדוגמאות האלה נראה כך. כדי לשפר את הקריאות, חלק מהפלט נחתך.

     Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
     +---------+--------+
     |  name   | number |
     +---------+--------+
     | Robert  |  10021 |
     | John    |   9636 |
     | Robert  |   9297 |
     | ...              |
     +---------+--------+
     

API

כדי לשמור את תוצאות השאילתה בטבלה קבועה, מפעילים את השיטה jobs.insert, מגדירים משימת query וכוללים ערך למאפיין destinationTable. כדי לשלוט בהגדרת הכתיבה של טבלת יעד קיימת, מגדירים את המאפיין writeDisposition.

כדי לשלוט במיקום העיבוד של עבודת השאילתה, מציינים את המאפיין location בקטע jobReference של משאב העבודה.

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"
	"io"

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

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

כדי לשמור את תוצאות השאילתה בטבלה קבועה, מגדירים את טבלת היעד לTableId הרצוי ב-QueryJobConfiguration.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \n" + e.toString());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

כדי לשמור את תוצאות השאילתה בטבלה קבועה, צריך ליצור QueryJobConfig ולהגדיר את היעד ל-TableReference הרצוי. מעבירים את הגדרות המשימה אל השיטה query.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

יצירת טבלה שמפנה למקור נתונים חיצוני

מקור נתונים חיצוני הוא מקור נתונים שאפשר להריץ עליו שאילתות ישירות מ-BigQuery, גם אם הנתונים לא מאוחסנים באחסון של BigQuery. לדוגמה, יכול להיות שיש לכם נתונים במסד נתונים אחר Google Cloud , בקבצים ב-Cloud Storage או במוצר ענן אחר לגמרי שאתם רוצים לנתח ב-BigQuery, אבל אתם לא מוכנים להעביר אותם.

מידע נוסף זמין במאמר מבוא למקורות נתונים חיצוניים.

יצירת טבלה כשמטעינים נתונים

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

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

מידע נוסף על טעינת נתונים זמין במאמר מבוא לטעינת נתונים ל-BigQuery.

יצירת טבלה מולטימודאלית

גרסת טרום-השקה

השימוש במוצר הזה או בתכונה הזו כפוף לתנאי השימוש במוצרים בגרסת טרום-GA, שמפורטים בחלק "תנאים כלליים לשירות" של התנאים הספציפיים לשירות. השימוש בתכונות ובמוצרים בגרסת טרום-GA הוא "כפי שהם" (As is), ויכול להיות שהתמיכה בהם תהיה מוגבלת. אתם יכולים לקרוא מידע נוסף בקטע תיאור שלבי ההשקה.

הערה: כדי לשלוח משוב או לבקש תמיכה בנוגע לתכונה הזו, אפשר לשלוח אימייל לכתובת [e-mail].

אתם יכולים ליצור טבלה עם עמודה אחת או יותר של ObjectRef כדי לאחסן מטא-נתונים על נתונים לא מובְנים שקשורים לנתונים המובְנים האחרים בטבלה. לדוגמה, בטבלת מוצרים, אפשר ליצור ObjectRef עמודה לאחסון פרטי תמונות של מוצרים לצד נתוני המוצרים האחרים. הנתונים הלא מובנים עצמם מאוחסנים ב-Cloud Storage, וזמינים ב-BigQuery באמצעות טבלת אובייקטים.

כדי ללמוד איך ליצור טבלה מרובת-אופנים, אפשר לעיין במאמר בנושא ניתוח נתונים מרובי-אופנים באמצעות פונקציות מוגדרות על ידי המשתמש (UDF) ב-SQL וב-Python.

שליטה בגישה לטבלאות

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

• רמה גבוהה בGoogle Cloud היררכיית המשאבים, כמו רמת הפרויקט, התיקייה או הארגון
• ברמת מערך הנתונים
• רמת הטבלה או התצוגה

אפשר גם להגביל את הגישה לנתונים בטבלאות באמצעות השיטות הבאות:

• אבטחה ברמת העמודה
• אנונימיזציה של נתוני עמודות
• אבטחה ברמת השורה

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

הענקת תפקידי IAM ברמה גבוהה יותר בGoogle Cloudהיררכיית המשאבים, כמו ברמת הפרויקט, התיקייה או הארגון, מעניקה לישות גישה למגוון רחב של משאבים. לדוגמה, אם נותנים לישות תפקיד ברמת הפרויקט, הישות מקבלת הרשאות שחלות על כל מערכי הנתונים בפרויקט.

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

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

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

אי אפשר להגדיר הרשאת 'דחייה' במשאב כלשהו שמוגן על ידי IAM.

מידע נוסף על תפקידים והרשאות זמין במאמר הסבר על תפקידים במסמכי התיעוד של IAM ובמאמר תפקידים והרשאות של IAM ב-BigQuery.

קבלת מידע על טבלאות

אפשר לקבל מידע או מטא-נתונים על טבלאות בדרכים הבאות:

• באמצעות מסוף Google Cloud .
• שימוש בפקודה bq show של כלי שורת הפקודה של BigQuery.
• קריאה ל-API method ‏tables.get.
• שימוש בספריות לקוח.
• שליחת שאילתה לתצוגה INFORMATION_SCHEMA.VIEWS.

ההרשאות הנדרשות

כדי לקבל מידע על טבלאות, אתם צריכים לקבל לפחות הרשאות bigquery.tables.get. תפקידי ה-IAM המוגדרים מראש הבאים כוללים את ההרשאות bigquery.tables.get:

• bigquery.metadataViewer
• bigquery.dataViewer
• bigquery.dataOwner
• bigquery.dataEditor
• bigquery.admin

בנוסף, אם למשתמש יש הרשאות bigquery.datasets.create, כשהוא יוצר מערך נתונים, הוא מקבל גישת bigquery.dataOwner אליו. גישת bigquery.dataOwner מאפשרת למשתמש לאחזר מטא-נתונים של טבלה.

מידע נוסף על תפקידים והרשאות ב-IAM ב-BigQuery זמין במאמר בקרת גישה.

קבלת מידע על טבלה

כדי לקבל מידע על טבלאות:

המסוף

1. בחלונית הניווט, בקטע Resources, מרחיבים את הפרויקט ואז בוחרים מערך נתונים.

2. לוחצים על השם של מערך הנתונים כדי להרחיב אותו. הטבלאות והתצוגות במערך הנתונים מופיעות.

3. לוחצים על שם הטבלה.

4. בחלונית Details, לוחצים על Details כדי להציג את תיאור הטבלה ופרטי הטבלה.

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

BQ

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. מריצים את הפקודה bq show כדי להציג את כל המידע בטבלה. משתמשים בדגל --schema כדי להציג רק מידע על סכימת הטבלה. אפשר להשתמש בדגל --format כדי לשלוט בפלט.

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

   bq show \
   --schema \
   --format=prettyjson \
   project_id:dataset.table

   כאשר:

   • ‫project_id הוא מזהה הפרויקט.
   • ‫dataset הוא שם מערך הנתונים.
   • ‫table הוא שם הטבלה.

   דוגמאות:

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

   bq show --format=prettyjson mydataset.mytable

   מזינים את הפקודה הבאה כדי להציג את כל המידע על mytable בmydataset. ‫mydataset נמצא ב-myotherproject, ולא בפרויקט ברירת המחדל.

   bq show --format=prettyjson myotherproject:mydataset.mytable

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

   bq show --schema --format=prettyjson myotherproject:mydataset.mytable

API

מבצעים קריאה לשיטה tables.get ומספקים את כל הפרמטרים הרלוונטיים.

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

  public static void getTable(String projectId, String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \n" + e.toString());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי PHPהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery PHP API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
//$projectId = 'The Google project ID';
//$datasetId = 'The BigQuery dataset ID';
//$tableId   = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

קבלת מידע על טבלה באמצעות INFORMATION_SCHEMA

‫INFORMATION_SCHEMA היא סדרה של תצוגות שמאפשרות גישה למטא-נתונים על מערכי נתונים, שגרות, טבלאות, תצוגות, משימות, הזמנות ונתונים בסטרימינג.

אפשר להריץ שאילתות בתצוגות הבאות כדי לקבל מידע על הטבלה:

• אפשר להשתמש בתצוגות INFORMATION_SCHEMA.TABLES ו-INFORMATION_SCHEMA.TABLE_OPTIONS כדי לאחזר מטא-נתונים על טבלאות ותצוגות בפרויקט.
• משתמשים בתצוגות INFORMATION_SCHEMA.COLUMNS ו-INFORMATION_SCHEMA.COLUMN_FIELD_PATHS כדי לאחזר מטא-נתונים על העמודות (השדות) בטבלה.
• אפשר להשתמש בתצוגות INFORMATION_SCHEMA.TABLE_STORAGE כדי לאחזר מטא-נתונים על נפח האחסון הנדרש הנוכחי וההיסטורי לפי טבלה.

בתצוגות TABLES ו-TABLE_OPTIONS מוצג גם מידע כללי על הצפיות. למידע מפורט, אפשר להריץ שאילתה בתצוגה INFORMATION_SCHEMA.VIEWS.

צפייה אחת (TABLES)

כששולחים שאילתה לתצוגה INFORMATION_SCHEMA.TABLES, תוצאות השאילתה מכילות שורה אחת לכל טבלה או תצוגה במערך נתונים. לקבלת מידע מפורט על תצוגות, אפשר להריץ שאילתה על INFORMATION_SCHEMA.VIEWSview.

לתצוגה INFORMATION_SCHEMA.TABLES יש את הסכימה הבאה:

שם העמודה	סוג נתונים	ערך
table_catalog	STRING	מזהה הפרויקט שמכיל את מערך הנתונים.
table_schema	STRING	השם של מערך הנתונים שמכיל את הטבלה או התצוגה. נקרא גם datasetId.
table_name	STRING	השם של הטבלה או התצוגה. נקרא גם tableId.
table_type	STRING	סוג הטבלה, יכול להיות אחד מהערכים הבאים: ‫BASE TABLE: טבלה רגילה ‫CLONE: A table clone ‫SNAPSHOT: A table snapshot VIEW: A view ‫MATERIALIZED VIEW: A תצוגה ממוטבת או רפליקה של תצוגה ממוטבת ‫EXTERNAL: טבלה שמפנה אל מקור נתונים חיצוני
managed_table_type	STRING	העמודה הזו נמצאת בגרסת טרום-השקה (Preview). סוג הטבלה המנוהלת, אחת מהאפשרויות הבאות: ‫NATIVE: טבלה רגילה ‫BIGLAKE: טבלת BigLake של Apache Iceberg ב-BigQuery
is_insertable_into	STRING	‫YES או NO בהתאם לשאלה אם הטבלה תומכת בפקודות DML INSERT
is_fine_grained_mutations_enabled	STRING	‫YES או NO, בהתאם להגדרה של שינויים מפורטים ב-DML בטבלה
is_typed	STRING	הערך הוא תמיד NO
is_change_history_enabled	STRING	YES או NO, בהתאם למצב ההפעלה של היסטוריית השינויים
creation_time	TIMESTAMP	מועד היצירה של הטבלה
base_table_catalog	STRING	עבור שיבוטים של טבלאות ותמונות מצב של טבלאות, הפרויקט של טבלת הבסיס. רלוונטי רק לטבלאות שבהן table_type מוגדר כ-CLONE או כ-SNAPSHOT.
base_table_schema	STRING	במקרה של שיבוטים של טבלאות ותמונות מצב של טבלאות, מערך הנתונים של טבלת הבסיס. רלוונטי רק לטבלאות שבהן table_type מוגדר כ-CLONE או כ-SNAPSHOT.
base_table_name	STRING	במקרה של שיבוטים של טבלאות ותמונות מצב של טבלאות, השם של טבלת הבסיס. רלוונטי רק לטבלאות שבהן table_type מוגדר כ-CLONE או כ-SNAPSHOT.
snapshot_time_ms	TIMESTAMP	במקרה של שיבוטים של טבלאות ותמונות מצב של טבלאות, השעה שבה בוצעה הפעולה שיבוט או תמונת מצב בטבלת הבסיס כדי ליצור את הטבלה הזו. אם נעשה שימוש במסע בזמן, השדה הזה מכיל את חותמת הזמן של המסע בזמן. אחרת, הערך בשדה snapshot_time_ms יהיה זהה לערך בשדה creation_time. רלוונטי רק לטבלאות שבהן table_type מוגדר כ-CLONE או כ-SNAPSHOT.
replica_source_catalog	STRING	במקרה של עותקים של תצוגות מהותיות, הפרויקט של התצוגה המהותית הבסיסית.
replica_source_schema	STRING	במקרה של עותקים של תצוגות מהותיות, מערך הנתונים של התצוגה המהותית הבסיסית.
replica_source_name	STRING	עבור עותקים של תצוגות מהותיות, שם התצוגה המהותית הבסיסית.
replication_status	STRING	עבור רפליקות של תצוגות מהותיות, סטטוס הרפליקציה מהתצוגה המהותית הבסיסית לרפליקה של התצוגה המהותית. אחת מהאפשרויות הבאות: REPLICATION_STATUS_UNSPECIFIED ‫ACTIVE: השכפול פעיל ללא שגיאות ‫SOURCE_DELETED: התצוגה המהותית של המקור נמחקה ‫PERMISSION_DENIED: לא בוצעה הרשאה לתצוגה החומרית של המקור במערך הנתונים שמכיל את טבלאות Amazon S3 BigLake של המקור שנעשה בהן שימוש בשאילתה שיצרה את התצוגה החומרית. ‫UNSUPPORTED_CONFIGURATION: יש בעיה בדרישות המוקדמות של העותק, מלבד הרשאה לתצוגה חומרית של המקור.
replication_error	STRING	אם replication_status מציין בעיה ברפליקציה של רפליקה של תצוגה מהותית, replication_error מספק פרטים נוספים על הבעיה.
ddl	STRING	הצהרת DDL שאפשר להשתמש בה כדי ליצור מחדש את הטבלה, כמו CREATE TABLE או CREATE VIEW
default_collation_name	STRING	השם של הגדרת ברירת המחדל של איסוף נתונים, אם היא קיימת. אחרת, NULL.
sync_status	JSON	הסטטוס של הסנכרון בין הרפליקות הראשיות והמשניות של מערכי נתונים של רפליקציה בין אזורים ושל תוכנית התאוששות מאסון (DR). הפונקציה מחזירה NULL אם העותק הוא עותק ראשי או אם מערך הנתונים לא משתמש בשכפול.
upsert_stream_apply_watermark	TIMESTAMP	בטבלאות שמשתמשות בסימון נתונים שהשתנו (CDC), השעה שבה השינויים בשורה הוחלו לאחרונה. מידע נוסף זמין במאמר בנושא מעקב אחרי התקדמות של פעולת upsert בטבלה.

דוגמאות

דוגמה 1:

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

mydataset מכיל את הטבלאות הבאות:

• ‫mytable1: טבלה רגילה ב-BigQuery
• ‫myview1: תצוגה ב-BigQuery

כדי להריץ את השאילתה על פרויקט שאינו פרויקט ברירת המחדל, מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view. לדוגמה: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

הערה: שמות התצוגות המפורטות INFORMATION_SCHEMA הם תלויי אותיות רישיות.

SELECT
  table_catalog, table_schema, table_name, table_type,
  is_insertable_into, creation_time, ddl
FROM
  mydataset.INFORMATION_SCHEMA.TABLES;

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

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` |
|                |               |                |            |                    |                     | (                                           |
|                |               |                |            |                    |                     |   id INT64                                  |
|                |               |                |            |                    |                     | );                                          |
| myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1`   |
|                |               |                |            |                    |                     | AS SELECT 100 as id;                        |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+

דוגמה 2:

בדוגמה הבאה מתבצע אחזור של מטא-נתונים של טבלה לכל הטבלאות מסוג CLONE או SNAPSHOT מהתצוגה INFORMATION_SCHEMA.TABLES. המטא-נתונים שמוחזרים הם של טבלאות ב-mydataset בפרויקט ברירת המחדל שלכם.

כדי להריץ את השאילתה על פרויקט שאינו פרויקט ברירת המחדל, מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view. לדוגמה: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

  SELECT
    table_name, table_type, base_table_catalog,
    base_table_schema, base_table_name, snapshot_time_ms
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'CLONE'
  OR
    table_type = 'SNAPSHOT';

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

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | table_name   | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms    |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | items_clone  | CLONE      | myproject          | mydataset         | items           | 2018-10-31 22:40:05 |
  | orders_bk    | SNAPSHOT   | myproject          | mydataset         | orders          | 2018-11-01 08:22:39 |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+

דוגמה 3:

בדוגמה הבאה מאחזרים את העמודות table_name ו-ddl מהתצוגה INFORMATION_SCHEMA.TABLES של הטבלה population_by_zip_2010 במערך הנתונים census_bureau_usa. מערך הנתונים הזה הוא חלק מתוכנית מערכי הנתונים הציבוריים של BigQuery.

מכיוון שהטבלה שאתם מחפשים באמצעות שאילתה נמצאת בפרויקט אחר, אתם מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view. בדוגמה הזו, הערך הוא `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

SELECT
  table_name, ddl
FROM
  `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
WHERE
  table_name = 'population_by_zip_2010';

התוצאה אמורה להיראות כך:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       table_name       |                                                                                                            ddl                                                                                                             |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010`                                                                                                                                               |
|                        | (                                                                                                                                                                                                                          |
|                        |   geo_id STRING OPTIONS(description="Geo code"),                                                                                                                                                                           |
|                        |   zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"),                                                                                                                          |
|                        |   population INT64 OPTIONS(description="The total count of the population for this segment."),                                                                                                                             |
|                        |   minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."),                                                          |
|                        |   maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), |
|                        |   gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.")                                                                                                                    |
|                        | )                                                                                                                                                                                                                          |
|                        | OPTIONS(                                                                                                                                                                                                                   |
|                        |   labels=[("freebqcovid", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  

צפייה אחת (TABLE_OPTIONS)

כשמריצים שאילתה בתצוגה INFORMATION_SCHEMA.TABLE_OPTIONS, תוצאות השאילתה מכילות שורה אחת לכל אפשרות, לכל טבלה או תצוגה במערך נתונים. למידע מפורט על תצוגות, אפשר להריץ שאילתה על התצוגה INFORMATION_SCHEMA.VIEWS.

לתצוגה INFORMATION_SCHEMA.TABLE_OPTIONS יש את הסכימה הבאה:

שם העמודה	סוג נתונים	ערך
table_catalog	STRING	מזהה הפרויקט שמכיל את מערך הנתונים
table_schema	STRING	השם של מערך הנתונים שמכיל את הטבלה או התצוגה, שנקרא גם datasetId
table_name	STRING	השם של הטבלה או התצוגה, שנקרא גם tableId
option_name	STRING	אחד מערכי השם בטבלת האפשרויות
option_type	STRING	אחד מערכי סוג הנתונים בטבלת האפשרויות
option_value	STRING	אחת מאפשרויות הערכים בטבלת האפשרויות

טבלת אפשרויות

OPTION_NAME	OPTION_TYPE	OPTION_VALUE
description	STRING	תיאור של הטבלה
enable_refresh	BOOL	אם הרענון האוטומטי מופעל בתצוגה חומרית
expiration_timestamp	TIMESTAMP	השעה שבה יפוג התוקף של הטבלה הזו
friendly_name	STRING	השם התיאורי של הטבלה
kms_key_name	STRING	השם של מפתח Cloud KMS שמשמש להצפנת הטבלה
labels	ARRAY<STRUCT<STRING, STRING>>	מערך של STRUCT שמייצג את התוויות בטבלה
max_staleness	INTERVAL	הערך המקסימלי של נתוני הטבלה שהוגדרה בעדכונים של נתוני שינוי (CDC) ב-BigQuery
partition_expiration_days	FLOAT64	משך החיים שמוגדר כברירת מחדל, בימים, של כל המחיצות בטבלה מחולקת למחיצות
refresh_interval_minutes	FLOAT64	התדירות שבה תצוגה חומרית מתרעננת
require_partition_filter	BOOL	האם שאילתות בטבלה דורשות מסנן מחיצה
tags	ARRAY<STRUCT<STRING, STRING>>	תגים שמצורפים לטבלה בתחביר <key, value> במרחב שמות. מידע נוסף זמין במאמר בנושא תגים וגישה מותנית.

בטבלאות חיצוניות, האפשרויות הן:

אפשרויות
allow_jagged_rows	BOOL אם הערך הוא true, המערכת מאפשרת שורות שחסרות בהן עמודות אופציונליות בסוף. ההגדרה חלה על נתוני CSV.
allow_quoted_newlines	BOOL אם true, מאפשרים בקובץ קטעי נתונים עם מרכאות שמכילים תווים של שורה חדשה. ההגדרה חלה על נתוני CSV.
bigtable_options	STRING נדרש רק כשיוצרים טבלה חיצונית של Bigtable. מציין את הסכימה של הטבלה החיצונית ב-Bigtable בפורמט JSON. רשימת האפשרויות להגדרת טבלאות Bigtable מופיעה במאמר בנושא BigtableOptionsבהפניית API בארכיטקטורת REST.
column_name_character_map	STRING מגדיר את היקף התווים הנתמכים בשמות העמודות ואת אופן הטיפול בתווים לא נתמכים. ההגדרה שמוגדרת כברירת מחדל היא STRICT, כלומר תווים לא נתמכים גורמים ל-BigQuery להחזיר שגיאות. ‫V1 ו-V2 מחליפים כל תו לא נתמך בקו תחתון. הערכים הנתמכים כוללים: ‫STRICT. מאפשר שמות עמודות גמישים. זה ערך ברירת המחדל. טעינת משימות עם תווים לא נתמכים בשמות של עמודות נכשלת ומוצגת הודעת שגיאה. כדי להגדיר החלפה של תווים לא נתמכים בקו תחתון כדי שעבודת הטעינה תצליח, צריך לציין את הגדרת התצורה default_column_name_character_map. V1. שמות העמודות יכולים להכיל רק תווים סטנדרטיים של שמות עמודות. תווים לא נתמכים (חוץ מנקודות בשמות של עמודות בקובץ Parquet) מוחלפים בקו תחתון. זוהי התנהגות ברירת המחדל של טבלאות שנוצרו לפני ההשקה של column_name_character_map. ‫V2. בנוסף לתווים בשמות עמודות רגילים, המערכת תומכת גם בשמות עמודות גמישים. תווים לא נתמכים (חוץ מנקודות בשמות של עמודות בקובץ Parquet) מוחלפים בקו תחתון. האפשרות הזו חלה על נתונים בפורמט CSV ו-Parquet.
compression	STRING סוג הדחיסה של מקור הנתונים. הערכים הנתמכים כוללים: GZIP. אם לא מציינים, מקור הנתונים לא דחוס. ההגדרה חלה על נתוני CSV ו-JSON.
decimal_target_types	ARRAY<STRING> ההגדרה קובעת איך להמיר סוג Decimal. שווה ערך ל-ExternalDataConfiguration.decimal_target_types דוגמה: ["NUMERIC", "BIGNUMERIC"]
description	STRING תיאור של הטבלה.
enable_list_inference	BOOL אם true, נעשה שימוש בהסקת סכימה באופן ספציפי עבור סוג לוגי של רשימת Parquet. ההגדרה חלה על נתונים בפורמט Parquet.
enable_logical_types	BOOL אם true, ממירים סוגים לוגיים של Avro לסוגי ה-SQL התואמים שלהם. מידע נוסף זמין במאמר בנושא סוגים לוגיים. ההגדרה חלה על נתוני Avro.
encoding	STRING קידוד התווים של הנתונים. הערכים הנתמכים כוללים: UTF8 (או UTF-8),‏ ISO_8859_1 (או ISO-8859-1),‏ UTF-16BE,‏ UTF-16LE,‏ UTF-32BE או UTF-32LE. ערך ברירת המחדל הוא UTF-8. ההגדרה חלה על נתוני CSV.
enum_as_string	BOOL אם true, המערכת מסיקה שסוג הנתונים הלוגי Parquet ENUM הוא STRING במקום BYTES כברירת מחדל. ההגדרה חלה על נתונים בפורמט Parquet.
expiration_timestamp	TIMESTAMP הזמן שבו תוקף הטבלה יפוג. אם לא מציינים תאריך תפוגה, הטבלה לא תפוג. דוגמה: "2025-01-01 00:00:00 UTC"
field_delimiter	STRING התו המפריד בין השדות בקובץ CSV. ההגדרה חלה על נתוני CSV.
format	STRING הפורמט של הנתונים החיצוניים. הערכים הנתמכים של CREATE EXTERNAL TABLE כוללים: AVRO, ‏ CLOUD_BIGTABLE, ‏ CSV,‏ DATASTORE_BACKUP, ‏ DELTA_LAKE (גרסת Preview),‏ GOOGLE_SHEETS, ‏ NEWLINE_DELIMITED_JSON (או JSON), ‏ ORC, ‏ PARQUET. הערכים הנתמכים של LOAD DATA כוללים: AVRO, ‏ CSV,‏ DELTA_LAKE (גרסת טרום-השקה),‏ NEWLINE_DELIMITED_JSON (או JSON),‏ ORC ו-PARQUET. הערך JSON שווה לערך NEWLINE_DELIMITED_JSON.
hive_partition_uri_prefix	STRING קידומת משותפת לכל מזהי ה-URI של המקור לפני שמתחיל קידוד מפתח המחיצה. ההגדרה חלה רק על טבלאות חיצוניות עם חלוקה למחיצות ב-Hive. ההגדרה הזו חלה על נתוני Avro,‏ CSV,‏ JSON,‏ Parquet ו-ORC. דוגמה: "gs://bucket/path"
file_set_spec_type	STRING מציין איך לפרש כתובות URI של מקורות למשימות טעינה ולטבלאות חיצוניות. הערכים הנתמכים כוללים: ‫FILE_SYSTEM_MATCH. מרחיב את מזהי ה-URI של המקור על ידי הצגת רשימה של קבצים ממאגר האובייקטים. זו התנהגות ברירת המחדל אם לא מוגדר FileSetSpecType. ‫NEW_LINE_DELIMITED_MANIFEST. מציין שכתובות ה-URI שסופקו הן קובצי מניפסט שמופרדים באמצעות תווי שורה חדשה, עם כתובת URI אחת בכל שורה. כתובות URI עם תווים כלליים לא נתמכות בקובצי המניפסט, וכל קובצי הנתונים שמפנים אליהם צריכים להיות באותו מאגר כמו קובץ המניפסט. לדוגמה, אם ה-URI של המקור הוא "gs://bucket/path/file" וה-file_set_spec_type הוא FILE_SYSTEM_MATCH, הקובץ ישמש ישירות כקובץ נתונים. אם הערך של file_set_spec_type הוא NEW_LINE_DELIMITED_MANIFEST, כל שורה בקובץ מפורשת כ-URI שמפנה לקובץ נתונים.
ignore_unknown_values	BOOL אם true, המערכת מתעלמת מערכים נוספים שלא מיוצגים בסכימת הטבלה, בלי להחזיר שגיאה. ההגדרה חלה על נתוני CSV ו-JSON.
json_extension	STRING לנתוני JSON, מציין פורמט מסוים של חילופי JSON. אם לא מציינים את הפורמט, BigQuery קורא את הנתונים כרשומות JSON כלליות. הערכים הנתמכים כוללים: GEOJSON. נתוני GeoJSON שמופרדים בתו שורה חדשה. מידע נוסף זמין במאמר בנושא יצירת טבלה חיצונית מקובץ GeoJSON מופרד בשורות חדשות.
max_bad_records	INT64 המספר המקסימלי של רשומות פגומות להתעלמות בזמן קריאת הנתונים. רלוונטי לנתוני CSV,‏ JSON ו-Google Sheets.
max_staleness	INTERVAL האפשרות הזו רלוונטית לטבלאות BigLake ולטבלאות אובייקטים. המדיניות הזו מציינת אם פעולות שמתבצעות בטבלה משתמשות במטא-נתונים ששמורים במטמון, ומה רמת העדכניות של המטא-נתונים ששמורים במטמון שנדרשת כדי שהפעולה תוכל להשתמש בהם. כדי להשבית את השמירה במטמון של המטא-נתונים, מציינים את הערך 0. (זוהי ברירת המחדל) כדי להפעיל שמירת מטא-נתונים במטמון, צריך לציין ערך של מילול לציון מרווח בין 30 דקות ל-7 ימים. לדוגמה, כדי להגדיר את מרווח הזמן של הנתונים הלא עדכניים ל-4 שעות, מציינים INTERVAL 4 HOUR. אם הערך הזה קיים, פעולות שמתבצעות בטבלה משתמשות במטא נתונים ששמורים במטמון, אם הם רעננו ב-4 השעות האחרונות. אם המטא-נתונים שנשמרו במטמון ישנים יותר, הפעולה חוזרת לאחזור מטא-נתונים מ-Cloud Storage.
null_marker	STRING המחרוזת שמייצגת ערכים של NULL בקובץ CSV. ההגדרה חלה על נתוני CSV.
null_markers	ARRAY<STRING> רשימת המחרוזות שמייצגות ערכים של NULL בקובץ CSV. אי אפשר להשתמש באפשרות הזו עם האפשרות null_marker. ההגדרה חלה על נתוני CSV.
object_metadata	STRING נדרש רק כשיוצרים טבלת אובייקטים. מגדירים את הערך של האפשרות הזו כ-SIMPLE כשיוצרים טבלת אובייקטים.
preserve_ascii_control_characters	BOOL אם true, אז תווי הבקרה המוטמעים מסוג ASCII שמופיעים ב-32 התווים הראשונים בטבלת ASCII, בטווח ‎'\x00' עד ‎ '\x1F', נשמרים. ההגדרה חלה על נתוני CSV.
projection_fields	STRING רשימה של מאפייני ישות לטעינה. ההגדרה חלה על נתונים ב-Datastore.
quote	STRING המחרוזת שמשמשת לציטוט של קטעי נתונים בקובץ CSV. אם הנתונים שלכם מכילים תווי שורה חדשה שמוקפים במירכאות, צריך להגדיר את המאפיין allow_quoted_newlines גם לערך true. ההגדרה חלה על נתוני CSV.
reference_file_schema_uri	STRING קובץ עזר שסופק על ידי המשתמש עם סכימת הטבלה. רלוונטי לנתונים בפורמט Parquet/ORC/AVRO. דוגמה: "gs://bucket/path/reference_schema_file.parquet"
require_hive_partition_filter	BOOL אם true, כל השאילתות בטבלה הזו דורשות מסנן מחיצות שאפשר להשתמש בו כדי להסיר מחיצות כשקוראים נתונים. ההגדרה חלה רק על טבלאות חיצוניות עם חלוקה למחיצות ב-Hive. ההגדרה הזו חלה על נתוני Avro,‏ CSV,‏ JSON,‏ Parquet ו-ORC.
sheet_range	STRING הטווח של גיליון אלקטרוני ב-Google Sheets שממנו רוצים לשלוף נתונים. המידע מתייחס לנתונים ב-Google Sheets. דוגמה: "sheet1!A1:B20",
skip_leading_rows	INT64 מספר השורות בחלק העליון של הקובץ שצריך לדלג עליהן כשקוראים את הנתונים. ההגדרה הזו חלה על נתונים ב-CSV וב-Google Sheets.
source_column_match	STRING ההגדרה הזו קובעת את השיטה שבה המערכת משתמשת כדי להתאים בין העמודות שנטענו לבין הסכימה. אם לא מציינים ערך, ברירת המחדל מבוססת על האופן שבו הסכימה מסופקת. אם ההגדרה 'זיהוי אוטומטי' מופעלת, התנהגות ברירת המחדל היא התאמת עמודות לפי שם. אחרת, ברירת המחדל היא התאמה בין העמודות לפי המיקום שלהן. השינוי הזה נעשה כדי לשמור על תאימות לאחור. הערכים הנתמכים כוללים: ‫POSITION: התאמות לפי מיקום. באפשרות הזו מניחים שהעמודות מסודרות באותו אופן כמו הסכימה. ‫NAME: התאמות לפי שם. האפשרות הזו קוראת את שורת הכותרת כשמות של עמודות ומסדרת מחדש את העמודות כך שיתאימו לשמות השדות בסכימה. שמות העמודות נקראים מהשורה האחרונה שדילגתם עליה, על סמך המאפיין skip_leading_rows.
tags	<ARRAY<STRUCT<STRING, STRING>>> מערך של תגי IAM לטבלה, שמוצגים כצמדי מפתח/ערך. המפתח צריך להיות שם המפתח במרחב השמות, והערך צריך להיות השם המקוצר.
time_zone	STRING אזור הזמן שמוגדר כברירת מחדל, שיחול כשמנתחים ערכים של חותמות זמן שלא הוגדר להם אזור זמן ספציפי. בודקים את השמות התקינים של אזורי הזמן. אם הערך הזה לא מופיע, המערכת מנתחת את ערכי חותמת הזמן ללא אזור זמן ספציפי באמצעות אזור הזמן שמוגדר כברירת מחדל UTC. ההגדרה חלה על נתוני CSV ו-JSON.
date_format	STRING רכיבי פורמט שמגדירים את הפורמט של ערכי התאריך בקובצי הקלט (לדוגמה, MM/DD/YYYY). אם הערך הזה קיים, זהו הפורמט היחיד התואם של DATE. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה DATE על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, המערכת מנתחת את שדה התאריך באמצעות פורמטים שמוגדרים כברירת מחדל. ההגדרה חלה על נתוני CSV ו-JSON.
datetime_format	STRING רכיבי פורמט שמגדירים את הפורמט של ערכי DATETIME בקובצי הקלט (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה קיים, זהו הפורמט היחיד התואם של DATETIME. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה DATETIME על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה DATETIME מנותח באמצעות פורמטים שמוגדרים כברירת מחדל. ההגדרה חלה על נתוני CSV ו-JSON.
time_format	STRING רכיבי פורמט שמגדירים את הפורמט של ערכי השעה בקובצי הקלט (לדוגמה, HH24:MI:SS.FF3). אם הערך הזה קיים, הפורמט הזה הוא הפורמט היחיד התואם של TIME. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIME על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIME מנותח באמצעות פורמטי ברירת המחדל. ההגדרה חלה על נתוני CSV ו-JSON.
timestamp_format	STRING רכיבי פורמט שמגדירים איך ערכי חותמת הזמן מפורמטים בקובצי הקלט (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה קיים, הפורמט הזה הוא פורמט חותמת הזמן התואם היחיד. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIMESTAMP על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIMESTAMP מנותח באמצעות פורמטים שמוגדרים כברירת מחדל. ההגדרה חלה על נתוני CSV ו-JSON.
uris	בטבלאות חיצוניות, כולל טבלאות אובייקטים, שאינן טבלאות Bigtable: ARRAY<STRING> מערך של מזהי URI מוגדרים במלואם למיקומי הנתונים החיצוניים. כל URI יכול להכיל כוכבית אחת (*), תו כללי, שחייבת להופיע אחרי שם הקטגוריה. כשמציינים ערכים של uris שמטרגטים כמה קבצים, לכל הקבצים האלה צריכה להיות סכימה תואמת. בדוגמאות הבאות מוצגים ערכים חוקיים של uris: ['gs://bucket/path1/myfile.csv'] ['gs://bucket/path1/*.csv'] ['gs://bucket/path1/*', 'gs://bucket/path2/file00*'] לטבלאות Bigtable: STRING כתובת ה-URI שמזהה את טבלת Bigtable שבה רוצים להשתמש כמקור נתונים. אפשר לציין רק URI אחד של Bigtable. דוגמה: https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name מידע נוסף על יצירת URI של Bigtable זמין במאמר בנושא אחזור ה-URI של Bigtable.

דוגמאות

דוגמה 1:

בדוגמה הבאה מאחזרים את זמני התפוגה של טבלאות ברירת המחדל לכל הטבלאות ב-mydataset בפרויקט ברירת המחדל (myproject) על ידי שאילתה של התצוגה INFORMATION_SCHEMA.TABLE_OPTIONS.

כדי להריץ את השאילתה על פרויקט שאינו פרויקט ברירת המחדל, מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view. לדוגמה: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

הערה: שמות התצוגות המפורטות INFORMATION_SCHEMA הם תלויי אותיות רישיות.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'expiration_timestamp';

התוצאה אמורה להיראות כך:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

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

דוגמה 2:

בדוגמה הבאה מאחזרים מטא-נתונים על כל הטבלאות ב-mydataset שמכילות נתוני בדיקה. השאילתה משתמשת בערכים באפשרות description כדי למצוא טבלאות שמכילות את המחרוזת 'test' בכל מקום בתיאור. ‫mydataset נמצא בפרויקט ברירת המחדל שלכם – myproject.

כדי להריץ את השאילתה בפרויקט שאינו פרויקט ברירת המחדל, מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view; לדוגמה: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'description'
    AND option_value LIKE '%test%';

התוצאה אמורה להיראות כך:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

צפייה אחת (COLUMNS)

כשמריצים שאילתה בתצוגה INFORMATION_SCHEMA.COLUMNS, תוצאות השאילתה מכילות שורה אחת לכל עמודה (שדה) בטבלה.

לתצוגה INFORMATION_SCHEMA.COLUMNS יש את הסכימה הבאה:

שם העמודה	סוג נתונים	ערך
table_catalog	STRING	מזהה הפרויקט שמכיל את מערך הנתונים.
table_schema	STRING	שם מערך הנתונים שמכיל את הטבלה, שנקרא גם datasetId.
table_name	STRING	השם של הטבלה או התצוגה, שנקרא גם tableId.
column_name	STRING	שם העמודה.
ordinal_position	INT64	ההיסט של העמודה בטבלה, מבוסס על אינדקס שמתחיל מ-1. אם זו עמודה וירטואלית כמו _PARTITIONTIME או _PARTITIONDATE, הערך הוא NULL.
is_nullable	STRING	‫YES או NO, בהתאם למצב של העמודה שמאפשר ערכי NULL.
data_type	STRING	סוג הנתונים ב-GoogleSQL של העמודה.
is_generated	STRING	הערך הוא ALWAYS אם העמודה היא עמודת הטמעה שנוצרה באופן אוטומטי. אחרת, הערך הוא NEVER.
generation_expression	STRING	הערך הוא ביטוי הדור שמשמש להגדרת העמודה אם העמודה היא עמודת הטמעה שנוצרת באופן אוטומטי. אחרת, הערך הוא NULL.
is_stored	STRING	הערך הוא YES אם העמודה היא עמודת הטמעה שנוצרה באופן אוטומטי, אחרת הערך הוא NULL.
is_hidden	STRING	‫YES או NO, בהתאם לשאלה אם העמודה היא עמודה פסאודו כמו ‎_PARTITIONTIME או ‎_PARTITIONDATE.
is_updatable	STRING	הערך הוא תמיד NULL.
is_system_defined	STRING	‫YES או NO, בהתאם לשאלה אם העמודה היא עמודה פסאודו כמו ‎_PARTITIONTIME או ‎_PARTITIONDATE.
is_partitioning_column	STRING	‫YES או NO, בהתאם לשאלה אם העמודה היא עמודת חלוקה.
clustering_ordinal_position	INT64	ההיסט של העמודה בטבלה, מבוסס על אינדקס של 1, בתוך עמודות האשכולות של הטבלה. הערך הוא NULL אם הטבלה לא מסודרת באשכולות.
collation_name	STRING	השם של הגדרת ה-collation אם היא קיימת, אחרת, NULL. אם מועבר STRING או ARRAY<STRING>, מוחזרת הגדרת ה-collation אם היא קיימת. אחרת, מוחזר NULL.
column_default	STRING	ערך ברירת המחדל של העמודה אם היא קיימת, אחרת הערך הוא NULL.
rounding_mode	STRING	אופן העיגול שמשמש לעיגול ערכים שנכתבים בשדה אם הסוג שלו הוא NUMERIC או BIGNUMERIC עם פרמטרים. אחרת, הערך הוא NULL.
data_policies.name	STRING	רשימת מדיניות הנתונים שמצורפת לעמודה כדי לשלוט בגישה ובהסתרת נתונים. השדה הזה נמצא בגרסת טרום-השקה (Preview).
policy_tags	ARRAY<STRING>	רשימת תגי המדיניות שמצורפים לעמודה.

דוגמאות

בדוגמה הבאה מאחזרים מטא-נתונים מהתצוגה INFORMATION_SCHEMA.COLUMNS של הטבלה population_by_zip_2010 במערך הנתונים census_bureau_usa. מערך הנתונים הזה הוא חלק מתוכנית מערכי הנתונים הציבוריים של BigQuery.

מכיוון שהטבלה שאתם שולחים לה שאילתה נמצאת בפרויקט אחר, פרויקט bigquery-public-data, אתם מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view; לדוגמה, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

העמודה הבאה לא נכללת בתוצאות השאילתה:

• IS_UPDATABLE

הערה: שמות התצוגות המפורטות INFORMATION_SCHEMA הם תלויי אותיות רישיות.

  SELECT
    * EXCEPT(is_updatable)
  FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
  WHERE
    table_name = 'population_by_zip_2010';

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

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position | policy_tags |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
  

צפייה אחת (COLUMN_FIELD_PATHS)

כשמבצעים שאילתה בתצוגה INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, התוצאות של השאילתה מכילות שורה אחת לכל עמודה מוטמעת בעמודה RECORD (או STRUCT).

לתצוגה INFORMATION_SCHEMA.COLUMN_FIELD_PATHS יש את הסכימה הבאה:

שם העמודה	סוג נתונים	ערך
table_catalog	STRING	מזהה הפרויקט שמכיל את מערך הנתונים.
table_schema	STRING	שם מערך הנתונים שמכיל את הטבלה, שנקרא גם datasetId.
table_name	STRING	השם של הטבלה או התצוגה, שנקרא גם tableId.
column_name	STRING	שם העמודה.
field_path	STRING	הנתיב לעמודה nested בתוך עמודה מסוג `RECORD` או `STRUCT`.
data_type	STRING	סוג הנתונים ב-GoogleSQL של העמודה.
description	STRING	התיאור של העמודה.
collation_name	STRING	השם של הגדרת ה-collation אם היא קיימת, אחרת, NULL. אם מועבר שדה STRING, ARRAY<STRING> או STRING ב-STRUCT, מוחזרת הגדרת האיסוף אם היא קיימת. אחרת, מוחזר NULL.
rounding_mode	STRING	אופן העיגול שבו משתמשים כשמחילים דיוק וקנה מידה על ערכים של פרמטרים NUMERIC או BIGNUMERIC. אחרת, הערך הוא NULL.
data_policies.name	STRING	רשימת מדיניות הנתונים שמצורפת לעמודה כדי לשלוט בגישה ובהסתרת נתונים. השדה הזה נמצא בגרסת טרום-השקה (Preview).
policy_tags	ARRAY<STRING>	רשימת תגי המדיניות שמצורפים לעמודה.

דוגמאות

בדוגמה הבאה מאחזרים מטא-נתונים מהתצוגה INFORMATION_SCHEMA.COLUMN_FIELD_PATHS של הטבלה commits במערך הנתונים github_repos. מערך הנתונים הזה הוא חלק מתוכנית מערכי הנתונים הציבוריים של BigQuery.

מכיוון שהטבלה שאתם שולחים לה שאילתה נמצאת בפרויקט אחר, פרויקט bigquery-public-data, אתם מוסיפים את מזהה הפרויקט למערך הנתונים בפורמט הבא: `project_id`.dataset.INFORMATION_SCHEMA.view; לדוגמה, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

הטבלה commits מכילה את העמודות המקוננות והחוזרות הבאות:

• ‫author: עמודה RECORD מוצבת בתוך עמודה אחרת
• ‫committer: עמודה RECORD מוצבת בתוך עמודה אחרת
• ‫trailer: עמודה מקוננת וחוזרת RECORD
• ‫difference: עמודה מקוננת וחוזרת RECORD

כדי לראות את המטא-נתונים של העמודות author ו-difference, מריצים את השאילתה הבאה.

הערה: שמות התצוגות המפורטות INFORMATION_SCHEMA הם תלויי אותיות רישיות.

SELECT
  *
FROM
  `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE
  table_name = 'commits'
  AND (column_name = 'author' OR column_name = 'difference');

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

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description | policy_tags |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        | 0 rows      |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        | 0 rows      |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        | 0 rows      |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        | 0 rows      |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  

צפייה אחת (TABLE_STORAGE)

לתצוגות TABLE_STORAGE ו-TABLE_STORAGE_BY_ORGANIZATION יש את הסכימה הבאה:

שם העמודה	סוג נתונים	ערך
project_id	STRING	מזהה הפרויקט שמכיל את מערך הנתונים.
project_number	INT64	מספר הפרויקט שמכיל את מערך הנתונים.
table_catalog	STRING	מזהה הפרויקט שמכיל את מערך הנתונים.
table_schema	STRING	שם מערך הנתונים שמכיל את הטבלה או את התצוגה החומרית, שנקרא גם datasetId.
table_name	STRING	השם של הטבלה או התצוגה החומרית, שנקראת גם tableId.
creation_time	TIMESTAMP	זמן היצירה של הטבלה.
total_rows	INT64	המספר הכולל של השורות בטבלה או בתצוגה החומרית.
total_partitions	INT64	מספר המחיצות שקיימות בטבלה או בתצוגה החומרית. טבלאות לא מחולקות מחזירות 0.
total_logical_bytes	INT64	המספר הכולל של בייטים לוגיים (לא דחוסים) בטבלה או בתצוגה החומרית.
active_logical_bytes	INT64	מספר הבייטים הלוגיים (לא דחוסים) שנוצרו לפני פחות מ-90 ימים.
long_term_logical_bytes	INT64	מספר הבייטים הלוגיים (לא דחוסים) שנוצרו לפני יותר מ-90 ימים.
current_physical_bytes	INT64	המספר הכולל של בייטים פיזיים לאחסון הנוכחי של הטבלה בכל המחיצות.
total_physical_bytes	INT64	המספר הכולל של בייטים פיזיים (דחוסים) שמשמשים לאחסון, כולל בייטים של נתונים פעילים, נתונים לטווח ארוך ונתונים של Time Travel (נתונים שנמחקו או שונו). לא נכללים בחישוב בייטים של נתונים שמוחקים או משנים אותם אחרי חלון הזמן של השחזור.
active_physical_bytes	INT64	מספר הבייטים הפיזיים (דחוסים) שגילם פחות מ-90 ימים, כולל בייטים של נתונים שנמחקו או שונו.
long_term_physical_bytes	INT64	מספר הבייטים הפיזיים (דחוסים) שנוצרו לפני יותר מ-90 ימים.
time_travel_physical_bytes	INT64	מספר הבייטים הפיזיים (דחוסים) שנעשה בהם שימוש באחסון של Time Travel (נתונים שנמחקו או שונו).
storage_last_modified_time	TIMESTAMP	השעה האחרונה שבה נכתבו נתונים בטבלה. הפונקציה מחזירה NULL אם לא קיימים נתונים.
deleted	BOOLEAN	מציין אם הטבלה נמחקה או לא.
table_type	STRING	סוג הטבלה. לדוגמה, BASE TABLE.
managed_table_type	STRING	העמודה הזו נמצאת בגרסת טרום-השקה (Preview). הסוג המנוהל של הטבלה. לדוגמה, NATIVE או BIGLAKE.
fail_safe_physical_bytes	INT64	מספר הבייטים הפיזיים (דחוסים) שנעשה בהם שימוש באחסון בטוח מפני כשלים (נתונים שנמחקו או שונו).
last_metadata_index_refresh_time	TIMESTAMP	השעה שבה בוצע רענון אחרון של אינדקס המטא-נתונים של הטבלה.
table_deletion_reason	STRING	הסיבה למחיקת הטבלה אם הערך בשדה deleted הוא true. הערכים האפשריים הם: טבלה אחת (TABLE_EXPIRATION:) נמחקה אחרי שתם הזמן שהוגדר לתפוגה קבוצת נתונים אחת (DATASET_DELETION:) נמחקה על ידי המשתמש משתמש מחק טבלה אחת (USER_DELETED:)
table_deletion_time	TIMESTAMP	השעה שבה הטבלה נמחקה.

דוגמאות

דוגמה 1:

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

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

התוצאה אמורה להיראות כך:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+

דוגמה 2:

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

SELECT
  table_schema AS dataset_name,
  -- Logical
  SUM(total_logical_bytes) / power(1024, 3) AS total_logical_gib,  
  SUM(active_logical_bytes) / power(1024, 3) AS active_logical_gib, 
  SUM(long_term_logical_bytes) / power(1024, 3) AS long_term_logical_gib, 
  -- Physical
  SUM(total_physical_bytes) / power(1024, 3) AS total_physical_gib,
  SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
  SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
  SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
  SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
  SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib 
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE 
WHERE 
  table_type ='BASE TABLE'
GROUP BY 
  table_schema  
ORDER BY 
  dataset_name 

דוגמה 3:

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

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

1. פותחים את הדף BigQuery במסוף Google Cloud .

   לדף BigQuery

2. מזינים את שאילתת GoogleSQL הבאה בתיבה עורך השאילתות. נדרש תחביר GoogleSQL ל-INFORMATION_SCHEMA. ‫GoogleSQL היא התחביר שמוגדר כברירת מחדל במסוף Google Cloud .

   DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
   DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
   DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
   DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;
   
   WITH
    storage_sizes AS (
      SELECT
        table_schema AS dataset_name,
        -- Logical
        SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
        SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
        -- Physical
        SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
        SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
        SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
        -- Restorable previously deleted physical
        SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
        SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
      FROM
        `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
      WHERE total_physical_bytes + fail_safe_physical_bytes > 0
        -- Base the forecast on base tables only for highest precision results
        AND table_type  = 'BASE TABLE'
        GROUP BY 1
    )
   SELECT
     dataset_name,
     -- Logical
     ROUND(active_logical_gib, 2) AS active_logical_gib,
     ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
     -- Physical
     ROUND(active_physical_gib, 2) AS active_physical_gib,
     ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
     ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
     ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
     -- Compression ratio
     ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
     ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
     -- Forecast costs logical
     ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
     ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
     -- Forecast costs physical
     ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
     ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
     -- Forecast costs total
     ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
        (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
   FROM
     storage_sizes
   ORDER BY
     (forecast_active_logical_cost + forecast_active_physical_cost) DESC;

   הערה: שמות התצוגות המפורטות הם תלויי אותיות רישיות.
   INFORMATION_SCHEMA

3. לוחצים על Run.

התוצאה אמורה להיראות כך:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |

הצגת רשימה של טבלאות במערך נתונים

אפשר לראות את רשימת הטבלאות במערכי נתונים בדרכים הבאות:

• באמצעות מסוף Google Cloud .
• שימוש בפקודה bq ls של כלי שורת הפקודה של BigQuery.
• קריאה ל-API method ‏tables.list.
• שימוש בספריות לקוח.

ההרשאות הנדרשות

כדי להציג רשימה של טבלאות במערך נתונים, אתם צריכים לקבל לפחות הרשאות bigquery.tables.list. תפקידי ה-IAM המוגדרים מראש הבאים כוללים את ההרשאות bigquery.tables.list:

• bigquery.user
• bigquery.metadataViewer
• bigquery.dataViewer
• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

מידע נוסף על תפקידים והרשאות ב-IAM ב-BigQuery זמין במאמר בקרת גישה.

הצגת רשימת הטבלאות

כדי להציג רשימה של הטבלאות במערך נתונים:

המסוף

1. במסוף Google Cloud , בחלונית הניווט, לוחצים על מערך הנתונים כדי להרחיב אותו. יוצגו הטבלאות והתצוגות במערך הנתונים.

2. גוללים ברשימה כדי לראות את הטבלאות במערך הנתונים. טבלאות ותצוגות מזוהות באמצעות סמלים שונים.

BQ

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. מריצים את הפקודה bq ls. אפשר להשתמש בדגל --format כדי לשלוט בפלט. אם אתם מציגים רשימה של טבלאות בפרויקט שאינו פרויקט ברירת המחדל שלכם, צריך להוסיף את מזהה הפרויקט למערך הנתונים בפורמט הבא: project_id:dataset.

   דגלים נוספים:

   • ‫--max_results או -n: מספר שלם שמציין את המספר המקסימלי של תוצאות. ערך ברירת המחדל הוא 50.

   bq ls \
   --format=pretty \
   --max_results integer \
   project_id:dataset

   כאשר:

   • ‫integer הוא מספר שלם שמייצג את מספר הטבלאות שיוצגו.
   • ‫project_id הוא מזהה הפרויקט.
   • ‫dataset הוא שם מערך הנתונים.

   כשמריצים את הפקודה, בשדה Type מוצגת האפשרות TABLE או VIEW. לדוגמה:

   +-------------------------+-------+----------------------+-------------------+
   |         tableId         | Type  |        Labels        | Time Partitioning |
   +-------------------------+-------+----------------------+-------------------+
   | mytable                 | TABLE | department:shipping  |                   |
   | myview                  | VIEW  |                      |                   |
   +-------------------------+-------+----------------------+-------------------+
   

   דוגמאות:

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

      bq ls --format=pretty mydataset

   מזינים את הפקודה הבאה כדי לקבל יותר מ-50 טבלאות (ברירת המחדל) מהפלט של mydataset. ‫mydataset נמצא בפרויקט ברירת המחדל שלכם.

      bq ls --format=pretty --max_results 60 mydataset

   מזינים את הפקודה הבאה כדי להציג את הטבלאות במערך הנתונים mydataset ב-myotherproject.

      bq ls --format=pretty myotherproject:mydataset

API

כדי להציג רשימה של טבלאות באמצעות ה-API, קוראים ל-method‏ tables.list.

C#‎

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי C#הוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery C# API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Go API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import (
	"context"
	"fmt"
	"io"

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

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Java API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

  public static void listTables(String projectId, String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + e.toString());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Node.js API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function listTables() {
  // Lists tables in 'my_dataset'.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

PHP

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי PHPהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery PHP API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

Python

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Pythonהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Python API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Rubyהוראות ההגדרה שבמדריך למתחילים של BigQuery באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של BigQuery Ruby API.

כדי לבצע אימות ב-BigQuery, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לספריות לקוח.

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

היסטוריה של טבלת הביקורת

כדי לבדוק את ההיסטוריה של טבלאות BigQuery, אפשר להריץ שאילתות ביומני הביקורת של Cloud ב-Logs Explorer. היומנים האלה עוזרים לעקוב אחרי מועדי היצירה, העדכון או המחיקה של טבלאות, ולזהות את המשתמש או חשבון השירות שביצעו את השינויים.

ההרשאות הנדרשות

כדי לעיין ביומני הביקורת, צריך את התפקיד roles/logging.privateLogViewer. במאמר בקרת גישה באמצעות IAM מוסבר בהרחבה על תפקידים והרשאות ב-IAM ב-Cloud Logging.

קבלת נתוני ביקורת

אפשר לגשת למידע על ביקורת דרך מסוף Google Cloud , שורת הפקודה gcloud, API בארכיטקטורת REST וכל השפות הנתמכות באמצעות ספריות לקוח. אפשר להשתמש במסנן הרישום ביומן שמוצג בדוגמה הבאה, בלי קשר לשיטה שבה משתמשים.

1. נכנסים לדף Logging במסוף Google Cloud .

   כניסה לרישום ביומן

2. כדי לגשת לנתוני הביקורת, משתמשים בשאילתה הבאה:

   logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity"
   AND resource.type = "bigquery_dataset"
   AND timestamp >= "STARTING_TIMESTAMP"
   AND protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog"
   AND (
     protoPayload.metadata.tableCreation :*
     OR protoPayload.metadata.tableChange :*
     OR protoPayload.metadata.tableDeletion :*
   )
   AND protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/"
   

מחליפים את מה שכתוב בשדות הבאים:

• ‫PROJECT_ID: הפרויקט שמכיל את מערכי הנתונים והטבלאות שמעניינים אתכם.
• ‫STARTING_TIMESTAMP: היומנים הכי ישנים שרוצים לראות. צריך להשתמש בפורמט ISO 8601, כמו 2025-01-01 או 2025-02-03T04:05:06Z.
• ‫DATASET_ID: מערך הנתונים שרוצים לסנן לפי.

פירוש התוצאות

בחלונית התוצאות של Logs Explorer, מרחיבים את הרשומה שמעניינת אתכם ואז לוחצים על Expand nested fields כדי להציג את ההודעה כולה.

רשומת הרישום מכילה רק אחד מהאובייקטים הבאים כדי לציין את הפעולה שבוצעה:

• ‫protoPayload.metadata.tableCreation: נוצרה טבלה.
• ‫protoPayload.metadata.tableChange: מטא-נתונים של הטבלה השתנו, למשל עדכון סכימה, שינוי תיאור או החלפת הטבלה.
• ‫protoPayload.metadata.tableDeletion: נמחקה טבלה.

התוכן של האובייקטים האלה מתאר את הפעולה המבוקשת. תיאור מפורט זמין במאמר BigQueryAuditMetadata.

הסבר על השאילתה

• ‫logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity": השורה הזו מסננת את יומני הביקורת של פעילות האדמין בתוך הפרויקט Google Cloud. ביומנים האלה מתועדות קריאות ל-API ופעולות שמשנות את ההגדרות או את המטא-נתונים של המשאבים.
• ‫resource.type = "bigquery_dataset": מצמצם את החיפוש לאירועים שקשורים למערכי נתונים ב-BigQuery, שבהם מתועדות פעולות בטבלה.
• ‫timestamp >= "STARTING_TIMESTAMP": מסנן את רשומות היומן כך שיוצגו רק אלה שנוצרו בתאריך או אחרי חותמת הזמן שצוינה.
• protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog": מוודא שהודעת היומן תואמת למבנה הסטנדרטי של יומן הביקורת של Cloud.
• ‫( ... ): הבלוק הזה מקבץ תנאים כדי למצוא סוגים שונים של אירועים בטבלה, כמו שמתואר בקטע הקודם. האופרטור :* מציין שהמפתח חייב להיות קיים. אם אתם מעוניינים רק באירוע אחד, כמו יצירת טבלה, אתם יכולים להסיר מהבלוק הזה את התנאים המיותרים.

• ‫protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/": בחירת רשומות ביומן שתואמות לטבלאות שנכללות במערך הנתונים שצוין. האופרטור נקודתיים (:) מבצע חיפוש של מחרוזת משנה.

  • כדי לסנן רשומות בטבלה אחת, מחליפים את התנאי בתנאי הבא: protoPayload.resourceName = "projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_NAME".
  • כדי לכלול את כל הטבלאות בכל מערכי הנתונים בפרויקט הספציפי, מסירים את התנאי הזה.

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

אבטחת טבלאות

כדי לשלוט בגישה לטבלאות ב-BigQuery, אפשר לעיין במאמר בנושא שליטה בגישה למשאבים באמצעות IAM.

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

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

נסו בעצמכם

אנחנו ממליצים למשתמשים חדשים ב-Google Cloud ליצור חשבון כדי שיוכלו להעריך את הביצועים של BigQuery בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300 $להרצה, לבדיקה ולפריסה של עומסי העבודה.

מתנסים ב-BigQuery בחינם