יצירת טבלאות מחולקות למחיצות

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

לסקירה כללית, קראו את המאמר מבוא לטבלאות מחולקות למחיצות.

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

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

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

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

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

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

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

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

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

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

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

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

יצירת טבלה ריקה מחולקת למחיצות

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

יצירת טבלה מחולקת למחיצות לפי עמודת יחידת זמן

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

המסוף

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

   כניסה לדף BigQuery

2. בחלונית הימנית, לוחצים על Explorer.
3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ובוחרים מערך נתונים.
4. בקטע Dataset info, לוחצים על Create table.
5. בחלונית Create table, מציינים את הפרטים הבאים:
1. בקטע Source, בוחרים באפשרות Empty table ברשימה Create table from.
2. בקטע Destination, מציינים את הפרטים הבאים:
   1. בשדה Dataset, בוחרים את מערך הנתונים שבו רוצים ליצור את הטבלה.
   2. בשדה Table, מזינים את שם הטבלה שרוצים ליצור.
   3. מוודאים שהשדה Table type מוגדר ל-Native table.
3. בקטע Schema, מזינים את הגדרת הסכימה. הסכימה חייבת לכלול עמודה מסוג DATE, TIMESTAMP או DATETIME בשביל עמודת החלוקה למחיצות. מידע נוסף זמין במאמר הגדרת סכימה. אפשר להזין את פרטי הסכימה באופן ידני באחת מהשיטות הבאות:
   • אפשרות 1: לוחצים על Edit as text ומדביקים את הסכימה בצורה של מערך JSON. כשמשתמשים במערך JSON, יוצרים את הסכימה באותו תהליך שמשמש ליצירת קובץ סכימה של JSON. כדי להציג את הסכימה של טבלה קיימת בפורמט JSON, מזינים את הפקודה הבאה:

         bq show --format=prettyjson dataset.table
         

   • אפשרות 2: לוחצים על Add field ומזינים את סכימת הטבלה. מציינים את הערכים של השדות Name,‏ Type ו-Mode.
4. בקטע Partition and cluster settings, ברשימה Partitioning בוחרים באפשרות Partition by field ואז בוחרים את עמודת החלוקה למחיצות. האפשרות הזו זמינה רק אם הסכימה מכילה עמודה מסוג DATE, TIMESTAMP או DATETIME.
5. אופציונלי: כדי לדרוש מסנן מחיצה בכל השאילתות בטבלה הזו, מסמנים את התיבה Require partition filter. מסנן מחיצות יכול להפחית את העלות ולשפר את הביצועים. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.
6. בוחרים את סוג החלוקה למחיצות.
7. אופציונלי: בקטע Advanced options, אם רוצים להשתמש במפתח הצפנה בניהול הלקוח, בוחרים באפשרות Use a customer-managed encryption key (CMEK). כברירת מחדל, BigQuery מצפין תוכן של לקוחות שמאוחסן במצב מנוחה באמצעות Google-owned and Google-managed encryption key.
8. לוחצים על Create table.

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

SQL

כדי ליצור טבלה שמחולקת למחיצות לפי עמודת יחידת זמן, משתמשים בהצהרת DDL של CREATE TABLE עם סעיף PARTITION BY.

בדוגמה הבאה נוצרת טבלה עם מחיצות יומיות על סמך העמודה transaction_date:

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

   כניסה ל-BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64, transaction_date DATE)
   PARTITION BY
     transaction_date
     OPTIONS (
       partition_expiration_days = 3,
       require_partition_filter = TRUE);

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

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

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

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

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_date DATE)
PARTITION BY
  DATE_TRUNC(transaction_date, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

אפשר גם לציין עמודה מסוג TIMESTAMP או DATETIME כעמודת החלוקה למחיצות. במקרה כזה, צריך לכלול את הפונקציה TIMESTAMP_TRUNC או DATETIME_TRUNC בסעיף PARTITION BY כדי לציין את סוג המחיצה. לדוגמה, ההצהרה הבאה יוצרת טבלה עם מחיצות יומיות על סמך עמודת TIMESTAMP:

CREATE TABLE
  mydataset.newtable (transaction_id INT64, transaction_ts TIMESTAMP)
PARTITION BY
  TIMESTAMP_TRUNC(transaction_ts, DAY)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

BQ

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. משתמשים בפקודה bq mk עם הדגל --table (או קיצור הדרך -t):

   bq mk \
      --table \
      --schema SCHEMA \
      --time_partitioning_field COLUMN \
      --time_partitioning_type UNIT_TIME \
      --time_partitioning_expiration EXPIRATION_TIME \
      --require_partition_filter=BOOLEAN
      PROJECT_ID:DATASET.TABLE

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

   • ‫SCHEMA: הגדרת סכימה בפורמט column:data_type,column:data_type או הנתיב לקובץ סכימה בפורמט JSON במחשב המקומי. מידע נוסף זמין במאמר הגדרת סכימה.
   • ‫COLUMN: שם עמודת החלוקה למחיצות. בסכימת הטבלה, העמודה הזו חייבת להיות מסוג TIMESTAMP,‏ DATETIME או DATE.
   • ‫UNIT_TIME: סוג החלוקה למחיצות. הערכים הנתמכים כוללים את DAY,‏ HOUR,‏ MONTH או YEAR.
   • ‫EXPIRATION_TIME: זמן התפוגה של המחיצות בטבלה, בשניות. הדגל --time_partitioning_expiration הוא אופציונלי. מידע נוסף זמין במאמר הגדרת תפוגה למחיצה.
   • ‫BOOLEAN: אם הערך הוא true, השאילתות בטבלה הזו חייבות לכלול מסנן מחיצות. הדגל --require_partition_filter הוא אופציונלי. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.
   • ‫PROJECT_ID: מזהה הפרויקט. אם לא מציינים פרויקט, המערכת משתמשת בפרויקט שמוגדר כברירת מחדל.
   • ‫DATASET: השם של מערך נתונים בפרויקט.
   • ‫TABLE: שם הטבלה שרוצים ליצור.

   אפשרויות אחרות של שורת הפקודה מפורטות במאמר bq mk.

   בדוגמה הבאה נוצרת טבלה בשם mytable שמחולקת למחיצות לפי העמודה ts, באמצעות חלוקה למחיצות לפי שעה. תפוגת המחיצה היא 259,200 שניות (3 ימים).

   bq mk \
      -t \
      --schema 'ts:TIMESTAMP,qtr:STRING,sales:FLOAT' \
      --time_partitioning_field ts \
      --time_partitioning_type HOUR \
      --time_partitioning_expiration 259200  \
      mydataset.mytable

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"

  time_partitioning {
    type          = "DAY"
    field         = "Created"
    expiration_ms = 432000000 # 5 days
  }
  require_partition_filter = true

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

}

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

הכנת Cloud Shell

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

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

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

   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

קוראים ל-method‏ tables.insert עם משאב טבלה מוגדר שמציין את המאפיין timePartitioning ואת המאפיין schema.

המשך

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

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

import (
	"context"
	"fmt"
	"time"

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

// createTablePartitioned demonstrates creating a table and specifying a time partitioning configuration.
func createTablePartitioned(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: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.IntegerFieldType},
		{Name: "date", Type: bigquery.DateFieldType},
	}
	metadata := &bigquery.TableMetadata{
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "date",
			Expiration: 90 * 24 * time.Hour,
		},
		Schema: sampleSchema,
	}
	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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;

// Sample to create a partition table
public class CreatePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING),
            Field.of("date", StandardSQLTypeName.DATE));
    createPartitionedTable(datasetName, tableName, schema);
  }

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

      TimePartitioning partitioning =
          TimePartitioning.newBuilder(TimePartitioning.Type.DAY)
              .setField("date") //  name of column to use for partitioning
              .setExpirationMs(7776000000L) // 90 days
              .build();

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

      bigquery.create(tableInfo);
      System.out.println("Partitioned table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Partitioned 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
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTablePartitioned() {
  // Creates a new partitioned 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, Post_Abbr:string, Date:date';

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

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);
  console.log(`Table ${table.id} created with partitioning: `);
  console.log(table.metadata.timePartitioning);
}

Python

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

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

from google.cloud import bigquery

client = bigquery.Client()

# Use format "your-project.your_dataset.your_table_name" for table_id
table_id = your_fully_qualified_table_id
schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
    bigquery.SchemaField("date", "DATE"),
]
table = bigquery.Table(table_id, schema=schema)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="date",  # name of column to use for partitioning
    expiration_ms=1000 * 60 * 60 * 24 * 90,
)  # 90 days

table = client.create_table(table)

print(
    f"Created table {table.project}.{table.dataset_id}.{table.table_id}, "
    f"partitioned on column {table.time_partitioning.field}."
)

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

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

המסוף

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

   כניסה לדף BigQuery

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

3. מרחיבים את האפשרות Actions ולוחצים על Open.

4. בחלונית הפרטים, לוחצים על Create table .

5. בדף Create table, בקטע Source, בוחרים באפשרות Empty table.

6. בקטע יעד:

   • בקטע Dataset name, בוחרים את מערך הנתונים המתאים.
   • בשדה Table name, מזינים את שם הטבלה.
   • מוודאים שהשדה Table type מוגדר ל-Native table.

7. בקטע Schema, מזינים את הגדרת הסכימה.

8. בקטע Partition and cluster settings, לוחצים על Partition by ingestion time בשדה Partitioning.

9. (אופציונלי) כדי לדרוש מסנן מחיצה בכל השאילתות בטבלה הזו, מסמנים את התיבה Require partition filter. דרישה למסנן מחיצות יכולה להפחית את העלות ולשפר את הביצועים. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.

10. לוחצים על Create table.

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

SQL

כדי ליצור טבלה מחולקת למחיצות לפי זמני הטמעת הנתונים, משתמשים בהצהרה CREATE TABLE עם משפט PARTITION BY שמחלק למחיצות לפי _PARTITIONDATE.

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

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

   כניסה ל-BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64)
   PARTITION BY
     _PARTITIONDATE
     OPTIONS (
       partition_expiration_days = 3,
       require_partition_filter = TRUE);

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

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

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

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

CREATE TABLE
  mydataset.newtable (transaction_id INT64)
PARTITION BY
  DATE_TRUNC(_PARTITIONTIME, MONTH)
  OPTIONS (
    partition_expiration_days = 3,
    require_partition_filter = TRUE);

BQ

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. משתמשים בפקודה bq mk עם הדגל --table (או קיצור הדרך -t):

   bq mk \
      --table \
      --schema SCHEMA \
      --time_partitioning_type UNIT_TIME \
      --time_partitioning_expiration EXPIRATION_TIME \
      --require_partition_filter=BOOLEAN  \
      PROJECT_ID:DATASET.TABLE

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

   • ‫SCHEMA: הגדרה בפורמט column:data_type,column:data_type או הנתיב לקובץ סכימת JSON במחשב המקומי. מידע נוסף זמין במאמר הגדרת סכימה.
   • ‫UNIT_TIME: סוג החלוקה למחיצות. הערכים הנתמכים כוללים את DAY,‏ HOUR,‏ MONTH או YEAR.
   • ‫EXPIRATION_TIME: זמן התפוגה של המחיצות בטבלה, בשניות. הדגל --time_partitioning_expiration הוא אופציונלי. מידע נוסף זמין במאמר הגדרת תפוגה למחיצה.
   • ‫BOOLEAN: אם הערך הוא true, השאילתות בטבלה הזו חייבות לכלול מסנן מחיצות. הדגל --require_partition_filter הוא אופציונלי. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.
   • ‫PROJECT_ID: מזהה הפרויקט. אם לא מציינים פרויקט, המערכת משתמשת בפרויקט שמוגדר כברירת מחדל.
   • ‫DATASET: השם של מערך נתונים בפרויקט.
   • ‫TABLE: שם הטבלה שרוצים ליצור.

   אפשרויות אחרות של שורת הפקודה מפורטות במאמר bq mk.

   בדוגמה הבאה נוצרת טבלה מחולקת למחיצות (Partitions) לפי זמני כתיבת הנתונים בשם mytable. הטבלה מחולקת למחיצות יומיות, עם תפוגת מחיצה של 259,200 שניות (3 ימים).

   bq mk \
      -t \
      --schema qtr:STRING,sales:FLOAT,year:STRING \
      --time_partitioning_type DAY \
      --time_partitioning_expiration 259200 \
      mydataset.mytable

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"

  time_partitioning {
    type          = "MONTH"
    expiration_ms = 604800000 # 7 days
  }
  require_partition_filter = true

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

}

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

הכנת Cloud Shell

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

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

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

   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

קוראים ל-method‏ tables.insert עם משאב טבלה מוגדר שמציין את המאפיין timePartitioning ואת המאפיין schema.

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

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

המסוף

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

   כניסה לדף BigQuery

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

3. מרחיבים את האפשרות Actions ולוחצים על Open.

4. בחלונית הפרטים, לוחצים על Create table .

5. בדף Create table, בקטע Source, בוחרים באפשרות Empty table.

6. בקטע יעד:

   • בקטע Dataset name, בוחרים את מערך הנתונים המתאים.
   • בשדה Table name, מזינים את שם הטבלה.
   • מוודאים שהשדה Table type מוגדר ל-Native table.

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

8. בקטע Partition and cluster settings, ברשימה הנפתחת Partitioning בוחרים באפשרות Partition by field ובוחרים את עמודת החלוקה למחיצות. האפשרות הזו זמינה רק אם הסכימה מכילה עמודה מסוג INTEGER.

9. מזינים ערכים בשדות התחלה, סיום ומרווח:

   • התחלה היא ההתחלה של טווח המחיצה הראשון (כולל).
   • ‫End הוא הסוף של טווח המחיצה האחרון (לא כולל).
   • מרווח הוא הרוחב של כל טווח חלוקה.

   ערכים מחוץ לטווחים האלה נכנסים למחיצה מיוחדת של __UNPARTITIONED__.

10. (אופציונלי) כדי לדרוש מסנן מחיצה בכל השאילתות בטבלה הזו, מסמנים את התיבה Require partition filter. דרישה למסנן מחיצות יכולה להפחית את העלות ולשפר את הביצועים. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.

11. לוחצים על Create table.

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

SQL

כדי ליצור טבלה שמחולקת למחיצות לפי טווח של מספרים שלמים, משתמשים בהצהרת DDL של CREATE TABLE עם סעיף PARTITION BY.

בדוגמה הבאה נוצרת טבלה שמחולקת למחיצות לפי העמודה customer_id, עם ערך התחלה 0, ערך סיום 100 ומרווח 10:

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

   כניסה ל-BigQuery

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

   CREATE TABLE mydataset.newtable (customer_id INT64, date1 DATE)
   PARTITION BY
     RANGE_BUCKET(customer_id, GENERATE_ARRAY(0, 100, 10))
     OPTIONS (
       require_partition_filter = TRUE);

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

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

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

BQ

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. משתמשים בפקודה bq mk עם הדגל --table (או קיצור הדרך -t):

   bq mk \
      --schema schema \
      --range_partitioning=COLUMN_NAME,START,END,INTERVAL \
      --require_partition_filter=BOOLEAN  \
      PROJECT_ID:DATASET.TABLE

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

   • ‫SCHEMA: הגדרת סכימה בתוך השורה בפורמט column:data_type,column:data_type או הנתיב לקובץ סכימת JSON במחשב המקומי. מידע נוסף זמין במאמר הגדרת סכימה.
   • ‫COLUMN_NAME: שם העמודה של החלוקה למחיצות. בסכימת הטבלה, העמודה הזו חייבת להיות מסוג INTEGER.
   • ‫START: ההתחלה של טווח המחיצה הראשון (כולל).
   • END: הסוף של טווח המחיצות האחרון (לא כולל).
   • ‫INTERVAL: הרוחב של כל טווח מחיצות.
   • ‫BOOLEAN: אם הערך הוא true, השאילתות בטבלה הזו חייבות לכלול מסנן מחיצות. הדגל --require_partition_filter הוא אופציונלי. מידע נוסף זמין במאמר הגדרת דרישות למסנן מחיצות.
   • ‫PROJECT_ID: מזהה הפרויקט. אם לא מציינים פרויקט, המערכת משתמשת בפרויקט שמוגדר כברירת מחדל.
   • ‫DATASET: השם של מערך נתונים בפרויקט.
   • ‫TABLE: שם הטבלה שרוצים ליצור.

   ערכים מחוץ לטווח המחיצה נכנסים למחיצה מיוחדת של __UNPARTITIONED__.

   אפשרויות אחרות של שורת הפקודה מפורטות במאמר bq mk.

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

   bq mk \
      -t \
      --schema 'customer_id:INTEGER,qtr:STRING,sales:FLOAT' \
      --range_partitioning=customer_id,0,100,10 \
      mydataset.mytable

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"

  range_partitioning {
    field = "ID"
    range {
      start    = 0
      end      = 1000
      interval = 10
    }
  }
  require_partition_filter = true

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

}

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

הכנת Cloud Shell

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

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

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

   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

קוראים ל-method‏ tables.insert עם משאב טבלה מוגדר שמציין את המאפיין rangePartitioning ואת המאפיין schema.

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.RangePartitioning;
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;

// Sample to create a range partitioned table
public class CreateRangePartitionedTable {

  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";
    Schema schema =
        Schema.of(
            Field.of("integerField", StandardSQLTypeName.INT64),
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL),
            Field.of("dateField", StandardSQLTypeName.DATE));
    createRangePartitionedTable(datasetName, tableName, schema);
  }

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

      // Note: The field must be a top- level, NULLABLE/REQUIRED field.
      // The only supported type is INTEGER/INT64
      RangePartitioning partitioning =
          RangePartitioning.newBuilder()
              .setField("integerField")
              .setRange(
                  RangePartitioning.Range.newBuilder()
                      .setStart(1L)
                      .setInterval(2L)
                      .setEnd(10L)
                      .build())
              .build();

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

      bigquery.create(tableInfo);
      System.out.println("Range partitioned table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Range partitioned 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
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTableRangePartitioned() {
  // Creates a new integer range partitioned 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: 'fullName', type: 'STRING'},
    {name: 'city', type: 'STRING'},
    {name: 'zipcode', type: 'INTEGER'},
  ];

  // To use integer range partitioning, select a top-level REQUIRED or
  // NULLABLE column with INTEGER / INT64 data type. Values that are
  // outside of the range of the table will go into the UNPARTITIONED
  // partition. Null values will be in the NULL partition.
  const rangePartition = {
    field: 'zipcode',
    range: {
      start: 0,
      end: 100000,
      interval: 10,
    },
  };

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

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

  console.log(`Table ${table.id} created with integer range partitioning: `);
  console.log(table.metadata.rangePartitioning);
}

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.range_partitioning = bigquery.RangePartitioning(
    # To use integer range partitioning, select a top-level REQUIRED /
    # NULLABLE column with INTEGER / INT64 data type.
    field="zipcode",
    range_=bigquery.PartitionRange(start=0, end=100000, interval=10),
)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

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

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

• ב-SQL, משתמשים בהצהרה CREATE TABLE ... AS SELECT. אפשר להשתמש בגישה הזו כדי ליצור טבלה שמחולקת למחיצות לפי עמודה של יחידת זמן או טווח של מספרים שלמים, אבל לא לפי זמן הטמעה.
• כדי להגדיר טבלת יעד לשאילתה, משתמשים בכלי שורת הפקודה של BigQuery או ב-BigQuery API. כשהשאילתה פועלת, BigQuery כותב את התוצאות בטבלת היעד. אפשר להשתמש בגישה הזו לכל סוג של חלוקה למחיצות.

• מפעילים את ה-method‏ jobs.insert ב-API ומציינים את החלוקה למחיצות במאפיין timePartitioning או במאפיין rangePartitioning.

SQL

משתמשים בהצהרה CREATE TABLE. כדי להגדיר את החלוקה למחיצות, צריך לכלול סעיף PARTITION BY.

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

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

   כניסה ל-BigQuery

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

   CREATE TABLE
     mydataset.newtable (transaction_id INT64, transaction_date DATE)
   PARTITION BY
     transaction_date
   AS (
     SELECT
       transaction_id, transaction_date
     FROM
       mydataset.mytable
   );

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

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

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

BQ

1. מפעילים את Cloud Shell במסוף Google Cloud .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Google Cloud יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. כדי ליצור טבלה מחולקת למחיצות משאילתה, משתמשים בפקודה bq query עם הדגל --destination_table והדגל --time_partitioning_type.

   חלוקה למחיצות לפי עמודת יחידת זמן:

   bq query \
      --use_legacy_sql=false \
      --destination_table TABLE_NAME \
      --time_partitioning_field COLUMN \
      --time_partitioning_type UNIT_TIME \
      'QUERY_STATEMENT'

   חלוקה למחיצות לפי זמן הטמעה:

   bq query \
      --use_legacy_sql=false \
      --destination_table TABLE_NAME \
      --time_partitioning_type UNIT_TIME \
      'QUERY_STATEMENT'

   חלוקה למחיצות לפי טווח של מספרים שלמים:

   bq query \
      --use_legacy_sql=false \
      --destination_table PROJECT_ID:DATASET.TABLE \
      --range_partitioning COLUMN,START,END,INTERVAL \
      'QUERY_STATEMENT'

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

   • ‫PROJECT_ID: מזהה הפרויקט. אם לא מציינים פרויקט, המערכת משתמשת בפרויקט שמוגדר כברירת מחדל.
   • ‫DATASET: השם של מערך נתונים בפרויקט.
   • ‫TABLE: שם הטבלה שרוצים ליצור.
   • ‫COLUMN: שם עמודת החלוקה למחיצות.
   • ‫UNIT_TIME: סוג החלוקה למחיצות. הערכים הנתמכים כוללים את DAY,‏ HOUR,‏ MONTH או YEAR.
   • ‫START: תחילת החלוקה למחיצות לפי טווח, כולל.
   • ‫END: סוף טווח החלוקה למחיצות, לא כולל.
   • ‫INTERVAL: הרוחב של כל טווח בתוך המחיצה.
   • ‫QUERY_STATEMENT: השאילתה ששימשה לאכלוס הטבלה.

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

   bq query \
      --use_legacy_sql=false \
      --destination_table mydataset.newtable \
      --time_partitioning_field transaction_date \
      --time_partitioning_type MONTH \
      'SELECT transaction_id, transaction_date FROM mydataset.mytable'

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

   bq query \
      --use_legacy_sql=false \
      --destination_table mydataset.newtable \
      --range_partitioning customer_id,0,100,10 \
      'SELECT * FROM mydataset.ponies'

   בטבלאות שמחולקות למחיצות לפי זמני הטמעת הנתונים, אפשר גם לטעון נתונים למחיצה ספציפית באמצעות מעצב מחיצות. בדוגמה הבאה יוצרים טבלה חדשה שמחולקת למחיצות לפי זמני הטעינה, וטוענים נתונים למחיצה 20180201 (1 בפברואר 2018):

   bq query \
      --use_legacy_sql=false  \
      --time_partitioning_type=DAY \
      --destination_table='newtable$20180201' \
      'SELECT * FROM mydataset.mytable'

API

כדי לשמור את תוצאות השאילתה בטבלה מחולקת למחיצות, צריך להפעיל את ה-method‏ jobs.insert. מגדירים משימה ב-query. מציינים את טבלת היעד ב-destinationTable. מציינים את החלוקה למחיצות במאפיין timePartitioning או במאפיין rangePartitioning.

המרת טבלאות עם חלוקה לפי תאריכים לטבלאות מחולקות למחיצות (Partitions) לפי זמני הטמעת הנתונים

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

bq --location=LOCATION partition \
    --time_partitioning_type=PARTITION_TYPE \
    --time_partitioning_expiration INTEGER \
    PROJECT_ID:SOURCE_DATASET.SOURCE_TABLE \
    PROJECT_ID:DESTINATION_DATASET.DESTINATION_TABLE

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

• ‫LOCATION: שם המיקום. הדגל --location הוא אופציונלי.
• ‫PARTITION_TYPE: סוג המחיצה. הערכים האפשריים כוללים את DAY,‏ HOUR,‏ MONTH או YEAR.
• ‫INTEGER: זמן התפוגה של המחיצה, בשניות. אין ערך מינימלי. זמן התפוגה מחושב לפי תאריך ה-UTC של המחיצה בתוספת ערך המספר השלם. הדגל time_partitioning_expiration הוא אופציונלי.
• ‫PROJECT_ID: מזהה הפרויקט.
• ‫SOURCE_DATASET: קבוצת הנתונים שמכילה את הטבלאות שמחולקות לפי תאריכים.
• SOURCE_TABLE: הקידומת של הטבלאות שמחולקות לפי תאריכים.
• ‫DESTINATION_DATASET: מערך הנתונים של הטבלה החדשה עם המחיצות.
• ‫DESTINATION_TABLE: השם של הטבלה המפוצלת שרוצים ליצור.

הפקודה partition לא תומכת בדגלים --label,‏ --expiration,‏ --add_tags או --description. אחרי שיוצרים את הטבלה, אפשר להוסיף לה תוויות, תאריך תפוגה, תגים ותיאור.

כשמריצים את הפקודה partition, ‏BigQuery יוצר משימת העתקה שמייצרת מחיצות מהטבלאות המפוצלות.

בדוגמה הבאה יוצרים טבלה מחולקת למחיצות (Partitions) לפי זמני כתיבת הנתונים בשם mytable_partitioned, מקבוצה של טבלאות עם חלוקה לפי תאריכים עם הקידומת sourcetable_. הטבלה החדשה מחולקת למחיצות מדי יום, עם תפוגת מחיצה של 259,200 שניות (3 ימים).

bq partition \
    --time_partitioning_type=DAY \
    --time_partitioning_expiration 259200 \
    mydataset.sourcetable_ \
    mydataset.mytable_partitioned

אם הטבלאות עם חלוקה לפי תאריכים היו sourcetable_20180126 ו-sourcetable_20180127, הפקודה הזו הייתה יוצרת את המחיצות הבאות: mydataset.mytable_partitioned$20180126 ו-mydataset.mytable_partitioned$20180127.

אבטחה של טבלאות מחולקות למחיצות (Partitions)

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

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

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