טעינת נתוני JSON מ-Cloud Storage

המסוף

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

   כניסה לדף BigQuery

2. בחלונית הימנית, לוחצים על explore כלי הניתוחים.
3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ובוחרים מערך נתונים.
4. בקטע פרטי מערך הנתונים, לוחצים על add_box יצירת טבלה.
5. בחלונית Create table, מציינים את הפרטים הבאים:
1. בקטע מקור, בוחרים באפשרות Google Cloud Storage ברשימה יצירת טבלה מ. לאחר מכן, מבצעים את הפעולות הבאות:
   1. בוחרים קובץ מתוך קטגוריה של Cloud Storage או מזינים את ה-URI של Cloud Storage. אי אפשר לכלול כמה כתובות URI במסוף Cloud de Confiance , אבל אפשר להשתמש בתווים כלליים לחיפוש. הקטגוריה של Cloud Storage צריכה להיות באותו מיקום כמו מערך הנתונים שמכיל את הטבלה שרוצים ליצור, להוסיף לה נתונים או להחליף אותה.
   2. בקטע פורמט קובץ, בוחרים באפשרות JSONL (פורמט JSON שמופרד בתו שורה חדשה).
2. בקטע יעד, מציינים את הפרטים הבאים:
   1. בקטע Dataset (מערך נתונים), בוחרים את מערך הנתונים שבו רוצים ליצור את הטבלה.
   2. בשדה Table, מזינים את השם של הטבלה שרוצים ליצור.
   3. מוודאים שהשדה Table type (סוג הטבלה) מוגדר ל-Native table (טבלה מקורית).
3. בקטע Schema, מזינים את הגדרת הסכימה. כדי להפעיל זיהוי אוטומטי של סכימה, בוחרים באפשרות Auto detect. אפשר להזין את פרטי הסכימה באופן ידני באחת מהשיטות הבאות:
   • אפשרות 1: לוחצים על Edit as text (עריכה כטקסט) ומדביקים את הסכימה כ-JSON array. כשמשתמשים במערך JSON, יוצרים את הסכימה באותו תהליך שבו יוצרים קובץ סכימת JSON. כדי לראות את הסכימה של טבלה קיימת בפורמט JSON, מזינים את הפקודה הבאה:

         bq show --format=prettyjson dataset.table
         

   • אפשרות 2: לוחצים על add_box הוספת שדה ומזינים את סכימת הטבלה. מציינים את השם, הסוג, והמצב של כל שדה.
4. אופציונלי: מציינים הגדרות של מחיצה ושל אשכול. מידע נוסף זמין במאמרים בנושא יצירה של טבלאות עם חלוקה למחיצות ויצירה של טבלאות מקובצות ושימוש בהן.
5. לוחצים על אפשרויות מתקדמות ומבצעים את הפעולות הבאות:
   • בקטע העדפת כתיבה, משאירים את האפשרות כתיבה אם ריק מסומנת. האפשרות הזו יוצרת טבלה חדשה וטוענת לתוכה את הנתונים.
   • בקטע מספר השגיאות המותר, מאשרים את ערך ברירת המחדל 0 או מזינים את המספר המקסימלי של שורות שמכילות שגיאות שאפשר להתעלם מהן. אם מספר השורות עם שגיאות גדול מהערך הזה, העבודה תסתיים בהודעה invalid ותיכשל. האפשרות הזו רלוונטית רק לקובצי CSV ו-JSON.
   • בשדה אזור זמן, מזינים את אזור הזמן שמוגדר כברירת מחדל ויחול על ניתוח של ערכי חותמות זמן שלא צוין לגביהם אזור זמן ספציפי. כאן אפשר למצוא רשימה של שמות אזורי זמן תקינים. אם הערך הזה לא מופיע, המערכת מנתחת את ערכי חותמות הזמן שלא צוין לגביהם אזור זמן ספציפי באמצעות אזור הזמן שמוגדר כברירת מחדל, UTC.
   • בשדה Date Format (פורמט תאריך), מזינים את רכיבי הפורמט שמגדירים איך ערכי התאריך מעוצבים בקובצי הקלט. בשדה הזה מצפים לפורמט בסגנון SQL (לדוגמה, MM/DD/YYYY). אם הערך הזה קיים, זהו פורמט התאריך התואם היחיד. זיהוי אוטומטי של הסכימה יקבע גם את סוג העמודה DATE על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא קיים, השדה DATE ינותח באמצעות פורמטי ברירת המחדל.
   • בשדה Datetime Format (פורמט תאריך ושעה), מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי התאריך והשעה בקובצי הקלט. בשדה הזה צריך להזין פורמט בסגנון SQL (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה מופיע, הפורמט הזה הוא הפורמט היחיד של תאריך ושעה שנתמך. זיהוי אוטומטי של הסכימה יקבע גם את סוג העמודה של תאריך ושעה על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה של תאריך ושעה ינותח באמצעות פורמטי ברירת המחדל.
   • בשדה Time Format, מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי השעה בקובצי הקלט. הפורמט שצריך להזין בשדה הזה הוא פורמט בסגנון SQL (לדוגמה, HH24:MI:SS.FF3). אם הערך הזה מופיע, זהו פורמט הזמן היחיד שניתן להשתמש בו. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIME על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIME מנותח באמצעות פורמטי ברירת המחדל.
   • בשדה פורמט חותמת הזמן, מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי חותמת הזמן בקובצי הקלט. הפורמט שצריך להזין בשדה הזה הוא פורמט בסגנון SQL (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה קיים, זהו פורמט חותמת הזמן היחיד שתואם. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIMESTAMP על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIMESTAMP מנותח באמצעות פורמטים שמוגדרים כברירת מחדל.
   • אם רוצים להתעלם מערכים בשורה שלא מופיעים בסכימה של הטבלה, צריך לבחור באפשרות ערכים לא ידועים.
   • בקטע הצפנה, לוחצים על מפתח בניהול הלקוח כדי להשתמש במפתח של Cloud Key Management Service. אם לא משנים את ההגדרה Google Cloud-powered key,‏ BigQuery יצפין את הנתונים במנוחה.
6. לוחצים על יצירת טבלה.

SQL

משתמשים בהצהרת DDL‏ LOAD DATA. בדוגמה הבאה, קובץ JSON נטען לטבלה החדשה mytable:

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

   כניסה ל-BigQuery

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

   LOAD DATA OVERWRITE mydataset.mytable
   (x INT64,y STRING)
   FROM FILES (
     format = 'JSON',
     uris = ['gs://bucket/path/file.json']);

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

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

BQ

משתמשים בפקודה bq load, מציינים את NEWLINE_DELIMITED_JSON באמצעות הדגל --source_format וכוללים URI של Cloud Storage. אפשר לכלול URI יחיד, רשימה מופרדת בפסיקים של מזהי URI או URI שמכיל תו כללי. מספקים את הסכימה בשורה, בקובץ הגדרת סכימה או משתמשים בזיהוי אוטומטי של סכימה.

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

דגלים אופציונליים אחרים:

• ‫--max_bad_records: מספר שלם שמציין את המספר המקסימלי של רשומות פגומות שמותרות לפני שהעבודה כולה נכשלת. ערך ברירת המחדל הוא 0. מוחזרות לכל היותר חמש שגיאות מכל סוג, ללא קשר לערך של --max_bad_records.
• ‫--ignore_unknown_values: אם מציינים את האפשרות הזו, המערכת מתעלמת מערכים נוספים ולא מוכרים בנתוני CSV או JSON.
• ‫--time_zone: (תצוגה מקדימה) אזור זמן ברירת מחדל אופציונלי שיחול על ניתוח של ערכי חותמות זמן שלא צוין להם אזור זמן ספציפי בנתוני CSV או JSON.
• ‫--date_format: (תצוגה מקדימה) מחרוזת מותאמת אישית אופציונלית שמגדירה את הפורמט של ערכי התאריך בנתוני CSV או JSON.
• ‫--datetime_format: (תצוגה מקדימה) מחרוזת אופציונלית בהתאמה אישית שמגדירה את הפורמט של ערכי התאריך והשעה בנתוני CSV או JSON.
• ‫--time_format: (תצוגה מקדימה) מחרוזת אופציונלית בהתאמה אישית שמגדירה את הפורמט של ערכי TIME בנתוני CSV או JSON.
• ‫--timestamp_format: (תצוגה מקדימה) מחרוזת מותאמת אישית אופציונלית שמגדירה את הפורמט של ערכי חותמת הזמן בנתוני CSV או JSON.
• ‫--autodetect: אם מציינים את האפשרות הזו, המערכת מפעילה זיהוי אוטומטי של סכימה לנתוני CSV ו-JSON.
• ‫--time_partitioning_type: מאפשר חלוקה למחיצות לפי זמן בטבלה ומגדיר את סוג המחיצה. הערכים האפשריים הם HOUR,‏ DAY,‏ MONTH ו-YEAR. הדגל הזה הוא אופציונלי כשיוצרים טבלה שמחולקת למחיצות לפי עמודה מסוג DATE,‏ DATETIME או TIMESTAMP. סוג המחיצה שמוגדר כברירת מחדל לחלוקה למחיצות לפי זמן הוא DAY. אי אפשר לשנות את הגדרות החלוקה למחיצות בטבלה קיימת.
• ‫--time_partitioning_expiration: מספר שלם שמציין (בשניות) מתי צריך למחוק מחיצה שמבוססת על זמן. תוקף המחיצה מסתיים בתאריך UTC של המחיצה בתוספת הערך המספרי.
• ‫--time_partitioning_field: העמודה DATE או TIMESTAMP שמשמשת ליצירת טבלה מחולקת למחיצות. אם מפעילים חלוקה למחיצות לפי זמן בלי הערך הזה, נוצרת טבלה מחולקת למחיצות לפי זמני כתיבת הנתונים.
• ‫--require_partition_filter: כשמפעילים את האפשרות הזו, המשתמשים צריכים לכלול פסקה של WHERE שמציינת את המחיצות שרוצים לשלוח עליהן שאילתה. דרישה של מסנן מחיצה יכולה להפחית את העלות ולשפר את הביצועים. מידע נוסף זמין במאמר דרישה של מסנן מחיצה בשאילתות.
• ‫--clustering_fields: רשימה מופרדת בפסיקים של עד ארבעה שמות עמודות שמשמשים ליצירת טבלה מסודרת באשכולות.

• ‫--destination_kms_key: מפתח Cloud KMS להצפנה של נתוני הטבלה.

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

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

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

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

  מידע נוסף על הצפנת טבלאות

  • הגנה על נתונים באמצעות מפתחות Cloud KMS

כדי לטעון נתוני JSON ל-BigQuery, מזינים את הפקודה הבאה:

bq --location=LOCATION load \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

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

• ‫LOCATION: המיקום שלכם. הדגל --location הוא אופציונלי. לדוגמה, אם אתם משתמשים ב-BigQuery באזור טוקיו, אתם יכולים להגדיר את הערך של הדגל כ-asia-northeast1. אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: מערך נתונים קיים.
• ‫TABLE: שם הטבלה שאליה טוענים את הנתונים.
• ‫PATH_TO_SOURCE: URI של Cloud Storage מוגדר במלואו או רשימה מופרדת בפסיקים של מזהי URI. יש תמיכה גם בתווים כלליים לחיפוש.
• ‫SCHEMA: סכימה תקינה. הסכימה יכולה להיות קובץ JSON מקומי, או שאפשר להקליד אותה בשורה כחלק מהפקודה. אם משתמשים בקובץ סכימה, לא צריך לתת לו סיומת. אפשר גם להשתמש בדגל --autodetect במקום לספק הגדרת סכימה.

דוגמאות:

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json לטבלה בשם mytable ב-mydataset. הסכימה מוגדרת בקובץ סכימה מקומי בשם myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json לטבלה חדשה מסוג טבלה מחולקת למחיצות (Partitions) לפי זמני כתיבת הנתונים בשם mytable ב-mydataset. הסכימה מוגדרת בקובץ סכימה מקומי בשם myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json לטבלה עם חלוקה למחיצות בשם mytable ב-mydataset. הטבלה מחולקת למחיצות (Partitions) לפי העמודה mytimestamp. הסכימה מוגדרת בקובץ סכימה מקומי בשם myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json לטבלה בשם mytable ב-mydataset. הסכימה מזוהה באופן אוטומטי.

    bq load \
    --autodetect \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json לטבלה בשם mytable ב-mydataset. הסכימה מוגדרת בשורה בפורמט FIELD:DATA_TYPE, FIELD:DATA_TYPE.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    qtr:STRING,sales:FLOAT,year:STRING

הפקודה הבאה טוענת נתונים מכמה קבצים ב-gs://mybucket/ לטבלה בשם mytable ב-mydataset. ה-URI של Cloud Storage משתמש בתו כללי. הסכימה מזוהה באופן אוטומטי.

    bq load \
    --autodetect \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata*.json

הפקודה הבאה טוענת נתונים מכמה קבצים ב-gs://mybucket/ לטבלה בשם mytable ב-mydataset. הפקודה כוללת רשימה מופרדת בפסיקים של מזהי URI של Cloud Storage עם תווים כלליים. הסכימה מוגדרת בקובץ סכימה מקומי בשם myschema.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    "gs://mybucket/00/*.json","gs://mybucket/01/*.json" \
    ./myschema

API

1. יוצרים משימת load שמפנה לנתוני המקור ב-Cloud Storage.

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

3. המאפיין source URIs צריך להיות מוגדר במלואו, בפורמט gs://BUCKET/OBJECT. כל URI יכול להכיל תו כללי אחד לחיפוש '*' .

4. מציינים את פורמט הנתונים JSON על ידי הגדרת המאפיין sourceFormat לערך NEWLINE_DELIMITED_JSON.

5. כדי לבדוק את סטטוס העבודה, קוראים ל-jobs.get(JOB_ID*) ומחליפים את JOB_ID במזהה העבודה שהוחזר מהבקשה הראשונית.

   • אם התוצאה היא status.state = DONE, העבודה הושלמה בהצלחה.
   • אם מאפיין status.errorResult קיים, הבקשה נכשלה והאובייקט הזה כולל מידע שמתאר מה השתבש. אם הבקשה נכשלת, לא נוצרת טבלה ולא נטענים נתונים.
   • אם status.errorResult לא מופיע, העבודה הסתיימה בהצלחה. עם זאת, יכול להיות שהיו כמה שגיאות לא קריטיות, כמו בעיות בייבוא של כמה שורות. שגיאות לא חמורות מפורטות במאפיין status.errors של אובייקט המשימה שמוחזר.

הערות לגבי ה-API:

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

• מומלץ ליצור מזהה ייחודי ולהעביר אותו כ-jobReference.jobId כשקוראים ל-jobs.insert כדי ליצור משימת טעינה. הגישה הזו עמידה יותר בפני כשלים ברשת, כי הלקוח יכול לבצע סקר או לנסות שוב לפי מזהה המשימה הידוע.

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

C#‎

using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsJson
{
    public void LoadTableGcsJson(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.NewlineDelimitedJson
        };
        // Create and run job
        BigQueryJob loadJob = client.CreateLoadJob(
            sourceUri: gcsURI, destination: destinationTableRef,
            schema: schema, options: jobOptions);
        loadJob = loadJob.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

המשך

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
	}
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	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

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

// Sample to load JSON data from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCS {

  public static void runLoadJsonFromGCS() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCS(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCS(
      String datasetName, String tableName, String sourceUri, 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);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Json from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the json file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCS() {
  // Imports a GCS file into a table with manually defined schema.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

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

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table('us_states');

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->sourceFormat('NEWLINE_DELIMITED_JSON');
$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

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(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    table_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

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

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

require "google/cloud/bigquery"

def load_table_gcs_json dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, format: "json" do |schema|
    schema.string "name"
    schema.string "post_abbr"
  end
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

המסוף

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

   כניסה לדף BigQuery

2. בחלונית הימנית, לוחצים על explore כלי הניתוחים.
3. בחלונית Explorer, מרחיבים את הפרויקט, לוחצים על Datasets ובוחרים מערך נתונים.
4. בקטע פרטי מערך הנתונים, לוחצים על add_box יצירת טבלה.
5. בחלונית Create table, מציינים את הפרטים הבאים:
1. בקטע מקור, בוחרים באפשרות Google Cloud Storage ברשימה יצירת טבלה מ. לאחר מכן, מבצעים את הפעולות הבאות:
   1. בוחרים קובץ מתוך קטגוריה של Cloud Storage או מזינים את ה-URI של Cloud Storage. אי אפשר לכלול כמה כתובות URI במסוף Cloud de Confiance , אבל אפשר להשתמש בתווים כלליים לחיפוש. הקטגוריה של Cloud Storage צריכה להיות באותו מיקום כמו מערך הנתונים שמכיל את הטבלה שרוצים ליצור, להוסיף לה נתונים או להחליף אותה.
   2. בקטע פורמט קובץ, בוחרים באפשרות JSONL (פורמט JSON שמופרד בתו שורה חדשה).
2. בקטע יעד, מציינים את הפרטים הבאים:
   1. בקטע Dataset (מערך נתונים), בוחרים את מערך הנתונים שבו רוצים ליצור את הטבלה.
   2. בשדה Table, מזינים את השם של הטבלה שרוצים ליצור.
   3. מוודאים שהשדה Table type (סוג הטבלה) מוגדר ל-Native table (טבלה מקורית).
3. בקטע Schema, מזינים את הגדרת הסכימה. כדי להפעיל זיהוי אוטומטי של סכימה, בוחרים באפשרות Auto detect. אפשר להזין את פרטי הסכימה באופן ידני באחת מהשיטות הבאות:
   • אפשרות 1: לוחצים על Edit as text (עריכה כטקסט) ומדביקים את הסכימה כ-JSON array. כשמשתמשים במערך JSON, יוצרים את הסכימה באותו תהליך שבו יוצרים קובץ סכימת JSON. כדי לראות את הסכימה של טבלה קיימת בפורמט JSON, מזינים את הפקודה הבאה:

         bq show --format=prettyjson dataset.table
         

   • אפשרות 2: לוחצים על add_box הוספת שדה ומזינים את סכימת הטבלה. מציינים את השם, הסוג, והמצב של כל שדה.
4. אופציונלי: מציינים הגדרות של מחיצה ושל אשכול. מידע נוסף זמין במאמרים בנושא יצירה של טבלאות עם חלוקה למחיצות ויצירה של טבלאות מקובצות ושימוש בהן. אי אפשר להמיר טבלה לטבלה מחולקת או לטבלה מסודרת באשכולות על ידי הוספה או החלפה שלה. Cloud de Confiance מסוף Google Cloud לא תומך בהוספה לטבלאות מחולקות או מקובצות או בהחלפה שלהן בעבודת טעינה.
5. לוחצים על אפשרויות מתקדמות ומבצעים את הפעולות הבאות:
   • בקטע Write preference (העדפת כתיבה), בוחרים באפשרות Append to table (הוספה לטבלה) או Overwrite table (החלפת הטבלה).
   • בקטע מספר השגיאות המותר, מאשרים את ערך ברירת המחדל 0 או מזינים את המספר המקסימלי של שורות שמכילות שגיאות שאפשר להתעלם מהן. אם מספר השורות עם שגיאות גדול מהערך הזה, העבודה תסתיים בהודעה invalid ותיכשל. האפשרות הזו רלוונטית רק לקובצי CSV ו-JSON.
   • בשדה אזור זמן, מזינים את אזור הזמן שמוגדר כברירת מחדל ויחול על ניתוח של ערכי חותמות זמן שלא צוין לגביהם אזור זמן ספציפי. כאן אפשר למצוא רשימה של שמות אזורי זמן תקינים. אם הערך הזה לא מופיע, המערכת מנתחת את ערכי חותמות הזמן שלא צוין לגביהם אזור זמן ספציפי באמצעות אזור הזמן שמוגדר כברירת מחדל, UTC.
   • בשדה Date Format (פורמט תאריך), מזינים את רכיבי הפורמט שמגדירים איך ערכי התאריך מעוצבים בקובצי הקלט. בשדה הזה מצפים לפורמט בסגנון SQL (לדוגמה, MM/DD/YYYY). אם הערך הזה קיים, זהו פורמט התאריך התואם היחיד. זיהוי אוטומטי של הסכימה יקבע גם את סוג העמודה DATE על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא קיים, השדה DATE ינותח באמצעות פורמטי ברירת המחדל.
   • בשדה פורמט תאריך ושעה, מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי התאריך והשעה בקובצי הקלט. הפורמט שצריך להזין בשדה הזה הוא פורמט בסגנון SQL (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה מופיע, זהו פורמט התאריך והשעה היחיד שמתאים. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה DATETIME על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה DATETIME מנותח באמצעות פורמטים שמוגדרים כברירת מחדל.
   • בשדה Time Format, מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי השעה בקובצי הקלט. הפורמט שצריך להזין בשדה הזה הוא פורמט בסגנון SQL (לדוגמה, HH24:MI:SS.FF3). אם הערך הזה מופיע, זהו פורמט הזמן היחיד שניתן להשתמש בו. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIME על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIME מנותח באמצעות פורמטי ברירת המחדל.
   • בשדה פורמט חותמת הזמן, מזינים את רכיבי הפורמט שמגדירים את הפורמט של ערכי חותמת הזמן בקובצי הקלט. הפורמט שצריך להזין בשדה הזה הוא פורמט בסגנון SQL (לדוגמה, MM/DD/YYYY HH24:MI:SS.FF3). אם הערך הזה קיים, זהו פורמט חותמת הזמן היחיד שתואם. זיהוי אוטומטי של סכימה יקבע גם את סוג העמודה TIMESTAMP על סמך הפורמט הזה במקום הפורמט הקיים. אם הערך הזה לא מופיע, השדה TIMESTAMP מנותח באמצעות פורמטים שמוגדרים כברירת מחדל.
   • אם רוצים להתעלם מערכים בשורה שלא מופיעים בסכימה של הטבלה, צריך לבחור באפשרות ערכים לא ידועים.
   • בקטע הצפנה, לוחצים על מפתח בניהול הלקוח כדי להשתמש במפתח של Cloud Key Management Service. אם לא משנים את ההגדרה Google Cloud-powered key,‏ BigQuery יצפין את הנתונים במנוחה.
6. לוחצים על יצירת טבלה.

SQL

משתמשים בLOAD DATA הצהרת DDL. בדוגמה הבאה, קובץ JSON מצורף לטבלה mytable:

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

   כניסה ל-BigQuery

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

   LOAD DATA INTO mydataset.mytable
   FROM FILES (
     format = 'JSON',
     uris = ['gs://bucket/path/file.json']);

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

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

BQ

משתמשים בפקודה bq load, מציינים NEWLINE_DELIMITED_JSON באמצעות הדגל --source_format וכוללים URI של Cloud Storage. אפשר לכלול URI יחיד, רשימה מופרדת בפסיקים של URI או URI שמכיל תו כללי.

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

מציינים את הדגל --replace כדי להחליף את הטבלה. משתמשים בדגל --noreplace כדי לצרף נתונים לטבלה. אם לא מציינים דגל, ברירת המחדל היא הוספת נתונים.

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

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

דגלים אופציונליים אחרים:

• ‫--max_bad_records: מספר שלם שמציין את המספר המקסימלי של רשומות פגומות שמותרות לפני שהעבודה כולה נכשלת. ערך ברירת המחדל הוא 0. מוחזרות לכל היותר חמש שגיאות מכל סוג, ללא קשר לערך של --max_bad_records.
• ‫--ignore_unknown_values: אם מציינים את האפשרות הזו, המערכת מתעלמת מערכים נוספים ולא מוכרים בנתוני CSV או JSON.
• ‫--time_zone: (תצוגה מקדימה) אזור זמן ברירת מחדל אופציונלי שיחול על ניתוח של ערכי חותמות זמן שלא צוין להם אזור זמן ספציפי בנתוני CSV או JSON.
• ‫--date_format: (תצוגה מקדימה) מחרוזת מותאמת אישית אופציונלית שמגדירה את הפורמט של ערכי התאריך בנתוני CSV או JSON.
• ‫--datetime_format: (תצוגה מקדימה) מחרוזת אופציונלית בהתאמה אישית שמגדירה את הפורמט של ערכי התאריך והשעה בנתוני CSV או JSON.
• ‫--time_format: (תצוגה מקדימה) מחרוזת אופציונלית בהתאמה אישית שמגדירה את הפורמט של ערכי TIME בנתוני CSV או JSON.
• ‫--timestamp_format: (תצוגה מקדימה) מחרוזת מותאמת אישית אופציונלית שמגדירה את הפורמט של ערכי חותמת הזמן בנתוני CSV או JSON.
• ‫--autodetect: אם מציינים את האפשרות הזו, המערכת מפעילה זיהוי אוטומטי של סכימה לנתוני CSV ו-JSON.
• ‫--destination_kms_key: מפתח Cloud KMS להצפנה של נתוני הטבלה.

bq --location=LOCATION load \
--[no]replace \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

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

• LOCATION: המיקום שלכם. הדגל --location הוא אופציונלי. אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: מערך נתונים קיים.
• ‫TABLE: שם הטבלה שאליה טוענים את הנתונים.
• ‫PATH_TO_SOURCE: URI של Cloud Storage מוגדר במלואו או רשימה מופרדת בפסיקים של מזהי URI. יש תמיכה גם בתווים כלליים לחיפוש.
• ‫SCHEMA: סכימה תקינה. הסכימה יכולה להיות קובץ JSON מקומי, או שאפשר להקליד אותה בשורה כחלק מהפקודה. אפשר גם להשתמש בדגל --autodetect במקום לספק הגדרת סכימה.

דוגמאות:

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json ומחליפה טבלה בשם mytable ב-mydataset. הסכימה מוגדרת באמצעות זיהוי אוטומטי של סכימה.

    bq load \
    --autodetect \
    --replace \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json

הפקודה הבאה טוענת נתונים מ-gs://mybucket/mydata.json ומצרפת נתונים לטבלה בשם mytable ב-mydataset. הסכימה מוגדרת באמצעות קובץ סכימת JSON – myschema.

    bq load \
    --noreplace \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema

API

1. יוצרים משימת load שמפנה לנתוני המקור ב-Cloud Storage.

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

3. המאפיין source URIs צריך להיות מוגדר במלואו, בפורמט gs://BUCKET/OBJECT. אפשר לכלול כמה כתובות URI כרשימה מופרדת בפסיקים. יש גם תמיכה בתווים כלליים לחיפוש.

4. מגדירים את פורמט הנתונים באמצעות הנכס configuration.load.sourceFormat עם הערך NEWLINE_DELIMITED_JSON.

5. מגדירים את מאפיין configuration.load.writeDisposition לערך WRITE_TRUNCATE או WRITE_APPEND כדי לציין את העדפת הכתיבה.

המשך

import (
	"context"
	"fmt"

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

// importJSONTruncate demonstrates loading data from newline-delimeted JSON data in Cloud Storage
// and overwriting/truncating data in the existing table.
func importJSONTruncate(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteTruncate

	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

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

// Sample to overwrite the BigQuery table data by loading a JSON file from GCS
public class LoadJsonFromGCSTruncate {

  public static void runLoadJsonFromGCSTruncate() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCSTruncate(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCSTruncate(
      String datasetName, String tableName, String sourceUri, 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);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Table is successfully overwritten by JSON file loaded from GCS");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the JSON file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCSTruncate() {
  /**
   * Imports a GCS file into a table and overwrites
   * table data if table already exists.
   */

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

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

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$table = $bigQuery->dataset($datasetId)->table($tableId);

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('NEWLINE_DELIMITED_JSON')->writeDisposition('WRITE_TRUNCATE');
$job = $table->runJob($loadConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});

// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

כדי להחליף את השורות בטבלה קיימת, מגדירים את המאפיין LoadJobConfig.write_disposition למחרוזת WRITE_TRUNCATE.

import io

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(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
)

body = io.BytesIO(b"Washington,WA")
client.load_table_from_file(body, table_id, job_config=job_config).result()
previous_rows = client.get_table(table_id).num_rows
assert previous_rows > 0

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

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

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

כדי להחליף את השורות בטבלה קיימת, מגדירים את הפרמטר write של Table.load_job() לערך "WRITE_TRUNCATE".

require "google/cloud/bigquery"

def load_table_gcs_json_truncate dataset_id = "your_dataset_id",
                                 table_id   = "your_table_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

  load_job = dataset.load_job table_id,
                              gcs_uri,
                              format: "json",
                              write:  "truncate"
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end