יצירת טבלאות מסודרות באשכולות

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

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

למידע נוסף, קראו את המאמרים הבאים:

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

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

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

כדי לקבל את ההרשאות שדרושות ליצירת טבלה, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-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, שם הטבלה צריך להיות ייחודי לכל מערך נתונים. שם הטבלה יכול:

• להכיל תווים עם סך של עד 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, אפשר לציין את העמודות שמשמשות ליצירת הטבלה המסודרת באשכולות. אחרי שיוצרים את הטבלה, אפשר לשנות את העמודות שמשמשות ליצירת הטבלה המסודרת באשכולות. פרטים נוספים זמינים במאמר בנושא שינוי מפרט האשכול.

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

• BIGNUMERIC
• BOOL
• DATE
• DATETIME
• GEOGRAPHY
• INT64
• NUMERIC
• RANGE
• STRING
• TIMESTAMP

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

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

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

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

המסוף

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. לוחצים על יצירת טבלה.

SQL

משתמשים בפקודה CREATE TABLE DDL statement עם האפשרות CLUSTER BY. בדוגמה הבאה נוצרת טבלה מסודרת באשכולות בשם myclusteredtable ב-mydataset:

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

   כניסה ל-BigQuery

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

   CREATE TABLE mydataset.myclusteredtable
   (
     customer_id STRING,
     transaction_amount NUMERIC
   )
   CLUSTER BY
     customer_id
     OPTIONS (
       description = 'a table clustered by customer_id');

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

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

BQ

משתמשים בפקודה bq mk עם הדגלים הבאים:

• ‫--table (או קיצור הדרך -t).
• ‫--schema. אפשר לספק את הגדרת הסכימה של הטבלה בשורה או להשתמש בקובץ סכימת JSON.
• --clustering_fields. אפשר לציין עד ארבע עמודות לאשכולות.

פרמטרים אופציונליים כוללים את --expiration,‏ --description,‏ --time_partitioning_type,‏ --time_partitioning_field,‏ --time_partitioning_expiration,‏ --destination_kms_key ו---label.

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

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

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

bq mk \
    --table \
    --expiration INTEGER1 \
    --schema SCHEMA \
    --clustering_fields CLUSTER_COLUMNS \
    --description "DESCRIPTION" \
    --label KEY:VALUE,KEY:VALUE \
    PROJECT_ID:DATASET.TABLE

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

• ‫INTEGER1: משך החיים שמוגדר כברירת מחדל לטבלה, בשניות. הערך המינימלי הוא 3,600 שניות (שעה אחת). מועד התפוגה הוא השעה הנוכחית בשעון UTC בתוספת הערך השלם. אם מגדירים את זמן התפוגה של הטבלה כשיוצרים אותה, הגדרת ברירת המחדל של זמן התפוגה של הטבלה במערך הנתונים מתעלמת מההגדרה הזו. הגדרת הערך הזה תמחק את הטבלה אחרי הזמן שצוין.
• ‫SCHEMA: הגדרה מוטבעת של סכימה בפורמט COLUMN:DATA_TYPE,COLUMN:DATA_TYPE או הנתיב לקובץ סכימת ה-JSON במחשב המקומי.
• ‫CLUSTER_COLUMNS: רשימה מופרדת בפסיקים של עד ארבע עמודות לאשכולות. הרשימה לא יכולה להכיל רווחים.
• ‫DESCRIPTION: תיאור של הטבלה, במירכאות.
• ‫KEY:VALUE: צמד מפתח/ערך שמייצג תווית. אפשר להזין כמה תוויות באמצעות רשימה שמופרדת בפסיקים.
• PROJECT_ID: מזהה הפרויקט.
• ‫DATASET: מערך נתונים בפרויקט.
• ‫TABLE: השם של הטבלה שיוצרים.

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

דוגמאות:

מזינים את הפקודה הבאה כדי ליצור טבלה מסודרת באשכולות בשם myclusteredtable ב-mydataset בפרויקט ברירת המחדל. תוקף הטבלה מוגדר ל-2,592,000 (חודש אחד של 30 יום), התיאור מוגדר ל-This is my clustered table והתווית מוגדרת ל-organization:development. בפקודה נעשה שימוש בקיצור הדרך -t במקום ב---table.

הסכימה מצוינת בשורה כ: timestamp:timestamp,customer_id:string,transaction_amount:float. שדה האשכול שצוין customer_id משמש לאשכול של הטבלה.

bq mk \
    -t \
    --expiration 2592000 \
    --schema 'timestamp:timestamp,customer_id:string,transaction_amount:float' \
    --clustering_fields customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    mydataset.myclusteredtable

מזינים את הפקודה הבאה כדי ליצור טבלה מסודרת באשכולות בשם myclusteredtable בפרויקט myotherproject, ולא בפרויקט ברירת המחדל. התיאור מוגדר ל-This is my clustered table והתווית מוגדרת ל-organization:development. בפקודה נעשה שימוש בקיצור הדרך -t במקום ב---table. בפקודה הזו לא מצוין תאריך תפוגה לטבלה. אם לערכת הנתונים יש תאריך תפוגה של טבלה שמוגדר כברירת מחדל, הוא יחול. אם למערך הנתונים לא מוגדר תאריך תפוגה של טבלה כברירת מחדל, תוקף הטבלה לא יפוג לעולם.

הסכימה מצוינת בקובץ JSON מקומי: /tmp/myschema.json. השדה customer_id משמש ליצירת אשכולות בטבלה.

bq mk \
    -t \
    --expiration 2592000 \
    --schema /tmp/myschema.json \
    --clustering_fields=customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    myotherproject:mydataset.myclusteredtable

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

Terraform

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

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

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

בדוגמה הבאה נוצרת טבלה בשם mytable עם אשכולים בעמודות ID ו-Created:

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"

  clustering = ["ID", "Created"]

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

}

כדי להחיל את ההגדרות של 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 עם משאב טבלה מוגדר שמציין את המאפיין clustering.fields ואת המאפיין schema.

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"),
    bigquery.SchemaField("city", "STRING"),
    bigquery.SchemaField("zipcode", "INTEGER"),
]

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

Go

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

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

import (
	"context"
	"fmt"
	"time"

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

// createTableClustered demonstrates creating a BigQuery table with advanced properties like
// partitioning and clustering features.
func createTableClustered(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: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	metaData := &bigquery.TableMetadata{
		Schema: sampleSchema,
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "timestamp",
			Expiration: 90 * 24 * time.Hour,
		},
		Clustering: &bigquery.Clustering{
			Fields: []string{"origin", "destination"},
		},
	}
	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.Clustering;
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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class CreateClusteredTable {
  public static void runCreateClusteredTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createClusteredTable(datasetName, tableName);
  }

  public static void createClusteredTable(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);

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      StandardTableDefinition tableDefinition =
          StandardTableDefinition.newBuilder()
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

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

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

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

• כותבים את התוצאות לטבלת יעד חדשה ומציינים את עמודות האשכולות.
• באמצעות הצהרת DDL CREATE TABLE AS SELECT. מידע נוסף על השיטה הזו זמין במאמר יצירת טבלה מסודרת באשכולות מתוצאה של שאילתה בדף שימוש בהצהרות של שפת הגדרת נתונים.

אפשר ליצור טבלה מסודרת באשכולות על ידי שליחת שאילתה לטבלה מחולקת למחיצות (Partitions) או לטבלה ללא מחיצות. אי אפשר לשנות טבלה קיימת לטבלה מסודרת באשכולות באמצעות תוצאות של שאילתה.

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

SQL

כדי ליצור טבלה מסודרת באשכולות מתוצאת שאילתה, משתמשים בהצהרת DDL‏ CREATE TABLE עם האפשרות CLUSTER BY. בדוגמה הבאה נוצרת טבלה חדשה עם אשכול לפי customer_id על ידי שאילתה של טבלה קיימת ללא אשכול:

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

   כניסה ל-BigQuery

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

   CREATE TABLE mydataset.clustered_table
   (
     customer_id STRING,
     transaction_amount NUMERIC
   )
   CLUSTER BY
     customer_id
   AS (
     SELECT * FROM mydataset.unclustered_table
   );

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

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

BQ

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

bq --location=LOCATION query \
    --use_legacy_sql=false 'QUERY'

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

• ‫LOCATION: שם המיקום. הדגל --location הוא אופציונלי. לדוגמה, אם אתם משתמשים ב-BigQuery באזור טוקיו, אתם יכולים להגדיר את הערך של הדגל ל-asia-northeast1. אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.
• ‫QUERY: שאילתה בתחביר GoogleSQL. אי אפשר להשתמש ב-SQL מדור קודם כדי לשלוח שאילתות לטבלאות מקובצות או כדי לכתוב תוצאות של שאילתות בטבלאות מקובצות. השאילתה יכולה להכיל הצהרת CREATE TABLE DDL שמציינת את האפשרויות ליצירת הטבלה המסודרת באשכולות. אפשר להשתמש ב-DDL במקום לציין את הדגלים הנפרדים של שורת הפקודה.

דוגמאות:

מזינים את הפקודה הבאה כדי לכתוב את תוצאות השאילתה לטבלת יעד עם אשכולות בשם myclusteredtable ב-mydataset. ‫mydataset נמצא בפרויקט ברירת המחדל שלכם. השאילתה מאחזרת נתונים מטבלה שלא חולקה למחיצות: mytable. העמודה customer_id בטבלה משמשת לאשכול הטבלה. העמודה timestamp בטבלה משמשת ליצירת טבלה מחולקת למחיצות (Partitions).

bq query --use_legacy_sql=false \
    'CREATE TABLE
       mydataset.myclusteredtable
     PARTITION BY
       DATE(timestamp)
     CLUSTER BY
       customer_id
     AS (
       SELECT
         *
       FROM
         `mydataset.mytable`
     );'

API

כדי לשמור את תוצאות השאילתה בטבלה מסודרת באשכולות, קוראים לשיטה jobs.insert, מגדירים משימת query וכוללים הצהרת CREATE TABLE DDL שיוצרת את הטבלה המסודרת באשכולות.

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

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

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

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

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

SQL

משתמשים בהצהרה LOAD DATA. בדוגמה הבאה נטען נתונים בפורמט AVRO כדי ליצור טבלה שמחולקת למחיצות לפי השדה transaction_date ומקובצת לפי השדה customer_id. היא גם מגדירה את המחיצות כך שהתוקף שלהן יפוג אחרי שלושה ימים.

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

   כניסה ל-BigQuery

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

   LOAD DATA INTO mydataset.mytable
   PARTITION BY transaction_date
   CLUSTER BY customer_id
     OPTIONS (
       partition_expiration_days = 3)
   FROM FILES(
     format = 'AVRO',
     uris = ['gs://bucket/path/file.avro']);

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

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

API

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

Go

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

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

import (
	"context"
	"fmt"

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

// importClusteredTable demonstrates creating a table from a load job and defining partitioning and clustering
// properties.
func importClusteredTable(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
	loader.TimePartitioning = &bigquery.TimePartitioning{
		Field: "timestamp",
	}
	loader.Clustering = &bigquery.Clustering{
		Fields: []string{"origin", "destination"},
	}
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.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.Clustering;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class LoadTableClustered {

  public static void runLoadTableClustered() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    loadTableClustered(datasetName, tableName, sourceUri);
  }

  public static void loadTableClustered(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();

      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).build());

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Data successfully loaded into clustered table during load job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Data not loaded into clustered table during load job \n" + e.toString());
    }
  }
}

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"

job_config = bigquery.LoadJobConfig(
    skip_leading_rows=1,
    source_format=bigquery.SourceFormat.CSV,
    schema=[
        bigquery.SchemaField("timestamp", bigquery.SqlTypeNames.TIMESTAMP),
        bigquery.SchemaField("origin", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("destination", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("amount", bigquery.SqlTypeNames.NUMERIC),
    ],
    time_partitioning=bigquery.TimePartitioning(field="timestamp"),
    clustering_fields=["origin", "destination"],
)

job = client.load_table_from_uri(
    ["gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv"],
    table_id,
    job_config=job_config,
)

job.result()  # Waits for the job to complete.

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

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

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