הרצת שאילתה

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

סוגי שאילתות

אתם יכולים להריץ שאילתות על נתוני BigQuery באמצעות אחד מסוגי משימות השאילתות הבאים:

• משימות של שאילתות אינטראקטיביות. כברירת מחדל, BigQuery מריץ שאילתות כמשימות של שאילתות אינטראקטיביות, שמיועדות להתחיל לפעול כמה שיותר מהר.

• משימות של שאילתות באצווה. לשאילתות אצווה יש עדיפות נמוכה יותר מאשר לשאילתות אינטראקטיביות. כשפרויקט או הזמנה משתמשים בכל משאבי ה-Compute הזמינים, סביר יותר ששאילתות באצ' יתווספו לתור וישארו בו. אחרי שמתחילים להריץ שאילתה באצווה, היא פועלת כמו שאילתה אינטראקטיבית. מידע נוסף זמין במאמר בנושא תורים של שאילתות.

• עבודות של שאילתות מתמשכות. בעזרת המשימות האלה, השאילתה פועלת באופן רציף, ומאפשרת לכם לנתח נתונים נכנסים ב-BigQuery בזמן אמת, ואז לכתוב את התוצאות בטבלה ב-BigQuery או לייצא את התוצאות ל-Bigtable או ל-Pub/Sub. אתם יכולים להשתמש ביכולת הזו כדי לבצע משימות רגישות לזמן, כמו יצירת תובנות ופעולה מיידית על בסיסן, הפעלת הסקה של למידת מכונה (ML) בזמן אמת ויצירת צינורות נתונים מבוססי-אירועים.

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

• לכתוב ולהריץ שאילתה במסוףGoogle Cloud .
• מריצים את הפקודה bq query בכלי שורת הפקודה של BigQuery.
• קוראים באופן פרוגרמטי ל-method‏ jobs.query או ל-method‏ jobs.insert ב-API בארכיטקטורת REST‏ של BigQuery.
• שימוש בספריות הלקוח של BigQuery.

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

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

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

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

• ‫BigQuery Job User (roles/bigquery.jobUser) בפרויקט.
• ‫BigQuery Data Viewer (roles/bigquery.dataViewer) בכל הטבלאות והתצוגות שהשאילתה מתייחסת אליהן. כדי לשלוח שאילתות לתצוגות, צריך גם את התפקיד הזה בכל הטבלאות והתצוגות הבסיסיות. אם אתם משתמשים בתצוגות מורשות או בקבוצות נתונים מורשות, אתם לא צריכים גישה לנתוני המקור הבסיסיים.

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

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

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

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

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

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

פתרון בעיות

Access Denied: Project [project_id]: User does not have bigquery.jobs.create
permission in project [project_id].

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

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

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

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

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

המסוף

1. עוברים לדף BigQuery.

   כניסה ל-BigQuery

2. לוחצים על שאילתת SQL.

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

   לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery usa_names כדי לזהות את השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

   לחלופין, אפשר להשתמש בחלונית הפניה כדי ליצור שאילתות חדשות.

4. אופציונלי: כדי להציג באופן אוטומטי הצעות לקוד כשמקלידים שאילתה, לוחצים על Tools (כלים) > Parser-based auto-completion (השלמה אוטומטית מבוססת-מנתח). אם לא רוצים הצעות להשלמה אוטומטית, מבטלים את הסימון של האפשרות השלמה אוטומטית מבוססת-ניתוח. הפעולה הזו משביתה גם את ההצעות למילוי אוטומטי של שם הפרויקט.

5. אופציונלי: כדי לבחור הגדרות נוספות של שאילתות, לוחצים על עריכה > הגדרות שאילתה.

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

   אם לא מציינים טבלת יעד, עבודת השאילתה כותבת את הפלט לטבלה זמנית (מטמון).

   עכשיו אפשר לעיין בתוצאות השאילתה בכרטיסייה Results בחלונית Query results.

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

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

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

   במקרה של תרשימי קו, עמודות או פיזור, המימדים הנתמכים הם סוגי הנתונים INT64, FLOAT64, NUMERIC, BIGNUMERIC, TIMESTAMP, DATE, DATETIME, TIME ו-STRING, והמדדים הנתמכים הם סוגי הנתונים INT64, FLOAT64, NUMERIC ו-BIGNUMERIC.

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

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

BQ

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

   הפעלת Cloud Shell

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

2. משתמשים בפקודה bq query. בדוגמה הבאה, הדגל --use_legacy_sql=false מאפשר להשתמש בתחביר של GoogleSQL.

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

   מחליפים את QUERY בשאילתת GoogleSQL תקינה. לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery‏ usa_names כדי לקבוע מהם השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   bq query \
       --use_legacy_sql=false \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   משימת השאילתה כותבת את הפלט לטבלה זמנית (מטמון).

   אפשר גם לציין את טבלת היעד ואת המיקום של תוצאות השאילתה. כדי לכתוב את התוצאות לטבלה קיימת, צריך לכלול את הדגל המתאים כדי לצרף (--append_table=true) או להחליף (--replace=true) את הטבלה.

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

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

   • ‫LOCATION: האזור או האזור המרובה של טבלת היעד, לדוגמה US

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

     אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.

   • ‫TABLE: שם טבלת היעד, למשל myDataset.myTable

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

     אם הטבלה לא נמצאת בפרויקט הנוכחי, צריך להוסיף אתGoogle Cloud מזהה הפרויקט בפורמט PROJECT_ID:DATASET.TABLE – לדוגמה, myProject:myDataset.myTable. אם לא מציינים את --destination_table, נוצרת משימת שאילתה שכותבת את הפלט לטבלה זמנית.

Terraform

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

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

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

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

# Generate a unique job ID.
resource "random_string" "job_id" {
  lower   = true
  length  = 16
  special = false

  keepers = {
    uuid = uuid()
  }
}

# Create a query using the generated job ID.
resource "google_bigquery_job" "my_query_job" {
  job_id = random_string.job_id.id

  query {
    query = "SELECT name, SUM(number) AS total FROM `bigquery-public-data.usa_names.usa_1910_2013` GROUP BY name ORDER BY total DESC LIMIT 100;"
  }
}

כדי להחיל את הגדרות 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

כדי להריץ שאילתה באמצעות ה-API, מוסיפים משימה חדשה ומאכלסים את מאפיין ההגדרה של המשימה query. אפשר גם לציין את המיקום במאפיין location בקטע jobReference של משאב המשרה.

שולחים בקשת בדיקה לתוצאות באמצעות קריאה ל-getQueryResults. שולחים בקשת בדיקה עד ש-jobComplete שווה ל-true. בודקים אם יש שגיאות ואזהרות ברשימה errors.

C#‎

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

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

using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryQuery
{
    public void Query(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        string query = @"
            SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013`
            WHERE state = 'TX'
            LIMIT 100";
        BigQueryJob job = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: new QueryOptions { UseQueryCache = false });
        // Wait for the job to complete.
        job = job.PollUntilCompleted().ThrowOnAnyError();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

המשך

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

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

import (
	"context"
	"fmt"
	"io"

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

// queryBasic demonstrates issuing a query and reading results.
func queryBasic(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(
		"SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
			"WHERE state = \"TX\" " +
			"LIMIT 100")
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

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

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

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

public class SimpleQuery {

  public static void main(String[] args) {
    // TODO(developer): Replace this query before running the sample.
    String query =
        "SELECT name, SUM(number) as total_people "
            + "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
            + "WHERE state = 'TX' "
            + "GROUP BY name, state "
            + "ORDER BY total_people DESC "
            + "LIMIT 100;";
    simpleQuery(query);
  }

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

      // Create the query job.
      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

      // Execute the query.
      TableResult result = bigquery.query(queryConfig);

      // Print the results.
      result
          .iterateAll()
          .forEach(
              row -> {
                System.out.print("name:" + row.get("name").getStringValue());
                System.out.print(", count:" + row.get("total_people").getLongValue());
                System.out.println();
              });

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

כדי להריץ שאילתה עם שרת proxy, אפשר לעיין במאמר בנושא הגדרת שרת proxy.

Node.js

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

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

// Import the Google Cloud client library using default credentials
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();
async function query() {
  // Queries the U.S. given names dataset for the state of Texas.

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

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

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

  // Wait for the query to finish
  const [rows] = await job.getQueryResults();

  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

PHP

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

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

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

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$jobConfig = $bigQuery->query($query);
$job = $bigQuery->startQuery($jobConfig);

$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);
    }
});
$queryResults = $job->queryResults();

$i = 0;
foreach ($queryResults as $row) {
    printf('--- Row %s ---' . PHP_EOL, ++$i);
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, json_encode($value));
    }
}
printf('Found %s row(s)' . PHP_EOL, $i);

Python

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

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

from google.cloud import bigquery

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

query = """
    SELECT name, SUM(number) as total_people
    FROM `bigquery-public-data.usa_names.usa_1910_2013`
    WHERE state = 'TX'
    GROUP BY name, state
    ORDER BY total_people DESC
    LIMIT 20
"""
rows = client.query_and_wait(query)  # Make an API request.

print("The query data:")
for row in rows:
    # Row values can be accessed by field name or index.
    print("name={}, count={}".format(row[0], row["total_people"]))

Ruby

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

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

require "google/cloud/bigquery"

def query
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " \
        "WHERE state = 'TX' " \
        "LIMIT 100"

  # Location must match that of the dataset(s) referenced in the query.
  results = bigquery.query sql do |config|
    config.location = "US"
  end

  results.each do |row|
    puts row.inspect
  end
end

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

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

המסוף

1. עוברים לדף BigQuery.

   כניסה ל-BigQuery

2. לוחצים על שאילתת SQL.

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

   לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery usa_names כדי לזהות את השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

4. לוחצים על עריכה > הגדרות שאילתה.

5. בקטע ניהול משאבים, בוחרים באפשרות Batch.

6. אופציונלי: משנים את הגדרות השאילתה.

7. לוחצים על Save.

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

   אם לא מציינים טבלת יעד, עבודת השאילתה כותבת את הפלט לטבלה זמנית (מטמון).

BQ

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

   הפעלת Cloud Shell

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

2. משתמשים בפקודה bq query ומציינים את הדגל --batch. בדוגמה הבאה, הדגל --use_legacy_sql=false מאפשר להשתמש בתחביר של GoogleSQL.

   bq query \
       --batch \
       --use_legacy_sql=false \
       'QUERY'

   מחליפים את QUERY בשאילתת GoogleSQL תקינה. לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery‏ usa_names כדי לקבוע מהם השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   bq query \
       --batch \
       --use_legacy_sql=false \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   משימת השאילתה כותבת את הפלט לטבלה זמנית (מטמון).

   אפשר גם לציין את טבלת היעד ואת המיקום של תוצאות השאילתה. כדי לכתוב את התוצאות לטבלה קיימת, צריך לכלול את הדגל המתאים כדי לצרף (--append_table=true) או להחליף (--replace=true) את הטבלה.

   bq query \
       --batch \
       --location=LOCATION \
       --destination_table=TABLE \
       --use_legacy_sql=false \
       'QUERY'

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

   • ‫LOCATION: האזור או האזור המרובה של טבלת היעד, לדוגמה US

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

     אפשר להגדיר ערך ברירת מחדל למיקום באמצעות הקובץ ‎.bigqueryrc.

   • ‫TABLE: שם טבלת היעד, למשל myDataset.myTable

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

     אם הטבלה לא נמצאת בפרויקט הנוכחי, צריך להוסיף אתGoogle Cloud מזהה הפרויקט בפורמט PROJECT_ID:DATASET.TABLE – לדוגמה, myProject:myDataset.myTable. אם לא מציינים את --destination_table, נוצרת משימת שאילתה שכותבת את הפלט לטבלה זמנית.

API

כדי להריץ שאילתה באמצעות ה-API, מוסיפים משימה חדשה ומאכלסים את מאפיין ההגדרה של המשימה query. אפשר גם לציין את המיקום במאפיין location בקטע jobReference של משאב המשרה.

כשמאכלסים את מאפייני עבודת השאילתה, צריך לכלול את המאפיין configuration.query.priority ולהגדיר את הערך שלו ל-BATCH.

שולחים בקשת בדיקה לתוצאות באמצעות קריאה ל-getQueryResults. שולחים בקשת בדיקה עד ש-jobComplete שווה ל-true. בודקים אם יש שגיאות ואזהרות ברשימה errors.

המשך

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

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

import (
	"context"
	"fmt"
	"io"
	"time"

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

// queryBatch demonstrates issuing a query job using batch priority.
func queryBatch(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// dstDatasetID := "mydataset"
	// dstTableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	// Build an aggregate table.
	q := client.Query(`
		SELECT
  			corpus,
  			SUM(word_count) as total_words,
  			COUNT(1) as unique_words
		FROM ` + "`bigquery-public-data.samples.shakespeare`" + `
		GROUP BY corpus;`)
	q.Priority = bigquery.BatchPriority
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)

	// Start the job.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Job is started and will progress without interaction.
	// To simulate other work being done, sleep a few seconds.
	time.Sleep(5 * time.Second)
	status, err := job.Status(ctx)
	if err != nil {
		return err
	}

	state := "Unknown"
	switch status.State {
	case bigquery.Pending:
		state = "Pending"
	case bigquery.Running:
		state = "Running"
	case bigquery.Done:
		state = "Done"
	}
	// You can continue to monitor job progress until it reaches
	// the Done state by polling periodically.  In this example,
	// we print the latest status.
	fmt.Fprintf(w, "Job %s in Location %s currently in state: %s\n", job.ID(), job.Location(), state)

	return nil

}

Java

כדי להריץ שאילתת אצווה, מגדירים את העדיפות של השאילתה לערך QueryJobConfiguration.Priority.BATCH כשיוצרים QueryJobConfiguration.

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי 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.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;

// Sample to query batch in a table
public class QueryBatch {

  public static void runQueryBatch() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String query =
        "SELECT corpus"
            + " FROM `"
            + projectId
            + "."
            + datasetName
            + "."
            + tableName
            + " GROUP BY corpus;";
    queryBatch(query);
  }

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

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query)
              // Run at batch priority, which won't count toward concurrent rate limit.
              .setPriority(QueryJobConfiguration.Priority.BATCH)
              .build();

      TableResult results = bigquery.query(queryConfig);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));

      System.out.println("Query batch performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query batch not performed \n" + e.toString());
    }
  }
}

Node.js

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

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

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

async function queryBatch() {
  // Runs a query at batch priority.

  // Create query job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfigurationquery
  const queryJobConfig = {
    query: `SELECT corpus
            FROM \`bigquery-public-data.samples.shakespeare\` 
            LIMIT 10`,
    useLegacySql: false,
    priority: 'BATCH',
  };

  // Create job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfiguration
  const jobConfig = {
    // Specify a job configuration to set optional job resource properties.
    configuration: {
      query: queryJobConfig,
    },
  };

  // Make API request.
  const [job] = await bigquery.createJob(jobConfig);

  const jobId = job.metadata.id;
  const state = job.metadata.status.state;
  console.log(`Job ${jobId} is currently in state ${state}`);
}

Python

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

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

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(
    # Run at batch priority, which won't count toward concurrent rate limit.
    priority=bigquery.QueryPriority.BATCH
)

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

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.

# Check on the progress by getting the job's updated state. Once the state
# is `DONE`, the results are ready.
query_job = client.get_job(
    query_job.job_id, location=query_job.location
)  # Make an API request.

print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))

הרצת שאילתה מתמשכת

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

שימוש בחלונית הפניה

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

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

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

   כניסה ל-BigQuery

2. לוחצים על שאילתת SQL.

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

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

5. לוחצים על View actions (הצגת פעולות) ואז על Insert query snippet (הוספת קטע קוד של שאילתה).

   

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

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

הגדרות השאילתה

כשמריצים שאילתה, אפשר לציין את ההגדרות הבאות:

• טבלת יעד לתוצאות השאילתה.

• העדיפות של העבודה.

• האם להשתמש בתוצאות של שאילתות שנשמרו במטמון.

• הזמן הקצוב לתפוגה של העבודה באלפיות השנייה.

• האם להשתמש במצב סשן.

• סוג ההצפנה שבה יש להשתמש.

• מספר הבייטים המקסימלי שהחיוב על השאילתה יתבסס עליו.

• ניב ה-SQL שבו רוצים להשתמש.

• המיקום שבו תופעל השאילתה. השאילתה חייבת לפעול באותו מיקום כמו הטבלאות שאליהן מתייחסים בשאילתה.

• ההזמנה להרצת השאילתה.

מצב יצירה אופציונלית של משימות

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

כדי להפעיל את מצב יצירה אופציונלית של משימות, מגדירים את השדה jobCreationMode של המופע QueryRequest לערך JOB_CREATION_OPTIONAL בגוף הבקשה jobs.query.

כשהערך של השדה הזה מוגדר ל-JOB_CREATION_OPTIONAL, מערכת BigQuery קובעת אם השאילתה יכולה להשתמש במצב האופציונלי של יצירת משימה. אם כן, BigQuery מריץ את השאילתה ומחזיר את כל התוצאות בשדה rows של התגובה. מכיוון שלא נוצרה משימה עבור השאילתה הזו, BigQuery לא מחזיר jobReference בגוף התגובה. במקום זאת, היא מחזירה שדה queryId, שבו אפשר להשתמש כדי לקבל תובנות לגבי השאילתה באמצעות INFORMATION_SCHEMA.JOBS. מכיוון שלא נוצרת משימה, אין jobReference שאפשר להעביר אל ממשקי ה-API‏ jobs.get ו-jobs.getQueryResults כדי לחפש את השאילתות האלה.

אם BigQuery קובע שנדרשת משימה כדי להשלים את השאילתה, מוחזרת jobReference. כדי לגלות למה נוצרה עבודה עבור השאילתה, אפשר לבדוק את השדה job_creation_reason בתצוגה INFORMATION_SCHEMA.JOBS. במקרה כזה, צריך להשתמש ב-jobs.getQueryResults כדי לאחזר את התוצאות כשהשאילתה מסתיימת.

כשמשתמשים בערך JOB_CREATION_OPTIONAL, יכול להיות שהשדה jobReference לא יופיע בתשובה. כדאי לבדוק אם השדה קיים לפני שניגשים אליו.

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

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

המסוף

1. עוברים לדף BigQuery.

   כניסה ל-BigQuery

2. לוחצים על שאילתת SQL.

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

   לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery usa_names כדי לזהות את השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

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

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

BQ

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

   הפעלת Cloud Shell

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

2. משתמשים בפקודה bq query ומציינים את הדגל --job_creation_mode=JOB_CREATION_OPTIONAL. בדוגמה הבאה, הדגל --use_legacy_sql=false מאפשר להשתמש בתחביר של GoogleSQL.

   bq query \
       --rpc=true \
       --use_legacy_sql=false \
       --job_creation_mode=JOB_CREATION_OPTIONAL \
       --location=LOCATION \
       'QUERY'

   מחליפים את QUERY בשאילתת GoogleSQL תקינה, ואת LOCATION באזור תקין שבו נמצא מערך הנתונים. לדוגמה, אפשר להריץ שאילתה במערך הנתונים הציבורי של BigQuery‏ usa_names כדי לקבוע מהם השמות הנפוצים ביותר בארצות הברית בין השנים 1910 ל-2013:

   bq query \
       --rpc=true \
       --use_legacy_sql=false \
       --job_creation_mode=JOB_CREATION_OPTIONAL \
       --location=us \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   עבודת השאילתה מחזירה את הפלט בשורה בתגובה.

   הערה: אם צריך, אפשר להשתמש ב---apilog=stdout כדי לרשום ביומן את הבקשות והתגובות של ה-API ולחלץ את queryId.

API

כדי להריץ שאילתה במצב יצירה אופציונלית של משימות באמצעות ה-API, מריצים שאילתה באופן סינכרוני ומאכלסים את המאפיין QueryRequest. כוללים את המאפיין jobCreationMode ומגדירים את הערך שלו ל-JOB_CREATION_OPTIONAL.

בודקים את התשובה. אם jobComplete שווה ל-true ו-jobReference ריק, קוראים את התוצאות מהשדה rows. אפשר גם לקבל את queryId מהתשובה.

אם jobReference מופיע, אפשר לבדוק את jobCreationReason כדי להבין למה נוצרה משימה על ידי BigQuery. כדי לקבל את תוצאות הסקר, צריך להתקשר למספר getQueryResults. סקר עד ש-jobComplete שווה ל-true. בודקים אם יש שגיאות ואזהרות ברשימה errors.

Java

גרסה זמינה: 2.51.0 ואילך

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי 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.JobId;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.QueryJobConfiguration.JobCreationMode;
import com.google.cloud.bigquery.TableResult;

// Sample demonstrating short mode query execution.
//
// This feature is controlled by setting the defaultJobCreationMode
// field in the BigQueryOptions used for the client. JOB_CREATION_OPTIONAL
// allows for the execution of queries without creating a job.
public class QueryJobOptional {

  public static void main(String[] args) {
    String query =
        "SELECT name, gender, SUM(number) AS total FROM "
            + "bigquery-public-data.usa_names.usa_1910_2013 GROUP BY "
            + "name, gender ORDER BY total DESC LIMIT 10";
    queryJobOptional(query);
  }

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

      // Execute the query. The returned TableResult provides access information
      // about the query execution as well as query results.
      TableResult results = bigquery.query(QueryJobConfiguration.of(query));

      JobId jobId = results.getJobId();
      if (jobId != null) {
        System.out.println("Query was run with job state.  Job ID: " + jobId.toString());
      } else {
        System.out.println("Query was run in short mode.  Query ID: " + results.getQueryId());
      }

      // Print the results.
      results
          .iterateAll()
          .forEach(
              row -> {
                System.out.print("name:" + row.get("name").getStringValue());
                System.out.print(", gender: " + row.get("gender").getStringValue());
                System.out.print(", total: " + row.get("total").getLongValue());
                System.out.println();
              });

    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

כדי להריץ שאילתה עם שרת proxy, אפשר לעיין במאמר בנושא הגדרת שרת proxy.

Python

גרסה זמינה: 3.34.0 ומעלה

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

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

# This example demonstrates executing a query without requiring an associated
# job.
from google.cloud import bigquery
from google.cloud.bigquery.enums import JobCreationMode

# Construct a BigQuery client object, specifying that the library should
# avoid creating jobs when possible.
client = bigquery.Client(
    default_job_creation_mode=JobCreationMode.JOB_CREATION_OPTIONAL
)

query = """
    SELECT
        name,
        gender,
        SUM(number) AS total
    FROM
        bigquery-public-data.usa_names.usa_1910_2013
    GROUP BY
        name, gender
    ORDER BY
        total DESC
    LIMIT 10
"""
# Run the query.  The returned `rows` iterator can return information about
# how the query was executed as well as the result data.
rows = client.query_and_wait(query)

if rows.job_id is not None:
    print("Query was run with job state.  Job ID: {}".format(rows.job_id))
else:
    print(
        "Query was run without creating a job.  Query ID: {}".format(rows.query_id)
    )

print("The query data:")
for row in rows:
    # Row values can be accessed by field name or index.
    print("name={}, gender={}, total={}".format(row[0], row[1], row["total"]))

צומת

הגרסה הזמינה: 8.1.0 ואילך

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

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

// Demonstrates issuing a query that may be run in short query mode.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery({
  // default behavior is to create jobs when using the jobs.query API
  defaultJobCreationMode: 'JOB_CREATION_REQUIRED',
});

async function queryJobOptional() {
  // SQL query to run.

  const sqlQuery = `
    SELECT name, gender, SUM(number) AS total
    FROM bigquery-public-data.usa_names.usa_1910_2013
    GROUP BY name, gender
    ORDER BY total DESC
    LIMIT 10`;

  // Run the query
  const [rows, , res] = await bigquery.query({
    query: sqlQuery,
    // Skip job creation to enable short mode.
    jobCreationMode: 'JOB_CREATION_OPTIONAL',
  });

  if (!res.jobReference) {
    console.log(`Query was run in short mode. Query ID: ${res.queryId}`);
  } else {
    const jobRef = res.jobReference;
    const qualifiedId = `${jobRef.projectId}.${jobRef.location}.${jobRef.jobId}`;
    console.log(
      `Query was run with job state. Job ID: ${qualifiedId}, Query ID: ${res.queryId}`,
    );
  }
  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

המשך

גרסה זמינה: 1.69.0 ומעלה

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

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

import (
	"context"
	"fmt"
	"io"

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

// queryJobOptional demonstrates issuing a query that doesn't require a
// corresponding job.
func queryJobOptional(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID,
		bigquery.WithDefaultJobCreationMode(bigquery.JobCreationModeOptional),
	)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	q := client.Query(`
		SELECT
  			name, gender,
  			SUM(number) AS total
		FROM
			bigquery-public-data.usa_names.usa_1910_2013
		GROUP BY 
			name, gender
		ORDER BY
			total DESC
		LIMIT 10
		`)
	// Run the query and process the returned row iterator.
	it, err := q.Read(ctx)
	if err != nil {
		return fmt.Errorf("query.Read(): %w", err)
	}

	// The iterator provides information about the query execution.
	// Queries that were run in short query mode will not have the source job
	// populated.
	if it.SourceJob() == nil {
		fmt.Fprintf(w, "Query was run in optional job mode.  Query ID: %q\n", it.QueryID())
	} else {
		j := it.SourceJob()
		qualifiedJobID := fmt.Sprintf("%s:%s.%s", j.ProjectID(), j.Location(), j.ID())
		fmt.Fprintf(w, "Query was run with job state.  Job ID: %q, Query ID: %q\n",
			qualifiedJobID, it.QueryID())
	}

	// Print row data.
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

מנהל התקן של JDBC

גרסה זמינה: JDBC v1.6.1 ומעלה

צריך להגדיר את JobCreationMode=2 במחרוזת החיבור.

    jdbc:bigquery://https://www.googleapis.com/bigquery/v2:443;JobCreationMode=2;Location=US;
  

הערה: אם צריך, אפשר להוסיף את המחרוזת LogLevel=6;LogPath=log.txt למחרוזת החיבור כדי להפעיל רישום ברמה TRACE ולחלץ מידע לפתרון בעיות, כולל queryId.

מנהל התקן של ODBC

גרסה זמינה: ODBC v3.0.7.1016 ואילך

צריך להגדיר את הערך JobCreationMode=2 בקובץ .ini.

    [ODBC Data Sources]
    Sample DSN=Simba Google BigQuery ODBC Connector 64-bit
    [Sample DSN]
    JobCreationMode=2
  

הערה: אם צריך, אפשר להוסיף את LogLevel=6 ואת LogPath=log.txt לקובץ .ini כדי להפעיל רישום מפורט ביומן ולחלץ מידע לפתרון בעיות, כולל queryId.

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

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

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

מכסות

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

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

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

מעקב אחרי שאילתות

אפשר לקבל מידע על שאילתות בזמן שהן מופעלות באמצעות כלי הבדיקה של העבודות או באמצעות שאילתה של התצוגה INFORMATION_SCHEMA.JOBS_BY_PROJECT.

הרצה יבשה

הרצת סימולציה ב-BigQuery מספקת את המידע הבא:

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

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

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

הרצת בדיקה

כדי לבצע הרצה יבשה:

המסוף

1. נכנסים לדף BigQuery.

   כניסה ל-BigQuery

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

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

BQ

מזינים שאילתה כמו זו שבהמשך באמצעות הדגל --dry_run.

bq query \
--use_legacy_sql=false \
--dry_run \
'SELECT
   COUNTRY,
   AIRPORT,
   IATA
 FROM
   `project_id`.dataset.airports
 LIMIT
   1000'
 

אם השאילתה תקינה, הפקודה תחזיר את התגובה הבאה:

Query successfully validated. Assuming the tables are not modified,
running this query will process 10918 bytes of data.

הערה: אם השאילתה מעבדת כמות קטנה של נתונים, יכול להיות שתצטרכו להמיר את הבייטים שעוברים עיבוד מ-KB ל-MB. ‫MB הוא המידה הקטנה ביותר שמשמשת את מחשבון התמחור.

API

כדי לבצע הרצה יבשה באמצעות ה-API, שולחים עבודת שאילתה עם dryRun שמוגדר ל-true בסוג JobConfiguration.

המשך

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

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

import (
	"context"
	"fmt"
	"io"

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

// queryDryRun demonstrates issuing a dry run query to validate query structure and
// provide an estimate of the bytes scanned.
func queryDryRun(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(`
	SELECT
		name,
		COUNT(*) as name_count
	FROM ` + "`bigquery-public-data.usa_names.usa_1910_2013`" + `
	WHERE state = 'WA'
	GROUP BY name`)
	q.DryRun = true
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"

	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Dry run is not asynchronous, so get the latest status and statistics.
	status := job.LastStatus()
	if err := status.Err(); err != nil {
		return err
	}
	fmt.Fprintf(w, "This query will process %d bytes\n", status.Statistics.TotalBytesProcessed)
	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.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobStatistics;
import com.google.cloud.bigquery.QueryJobConfiguration;

// Sample to run dry query on the table
public class QueryDryRun {

  public static void runQueryDryRun() {
    String query =
        "SELECT name, COUNT(*) as name_count "
            + "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
            + "WHERE state = 'WA' "
            + "GROUP BY name";
    queryDryRun(query);
  }

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

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDryRun(true).setUseQueryCache(false).build();

      Job job = bigquery.create(JobInfo.of(queryConfig));
      JobStatistics.QueryStatistics statistics = job.getStatistics();

      System.out.println(
          "Query dry run performed successfully." + statistics.getTotalBytesProcessed());
    } catch (BigQueryException e) {
      System.out.println("Query not performed \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 queryDryRun() {
  // Runs a dry query of the U.S. given names dataset for the state of Texas.

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

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

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

  // Print the status and statistics
  console.log('Status:');
  console.log(job.metadata.status);
  console.log('\nJob Statistics:');
  console.log(job.metadata.statistics);
}

PHP

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

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

// Construct a BigQuery client object.
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);

// Set job configs
$jobConfig = $bigQuery->query($query);
$jobConfig->useQueryCache(false);
$jobConfig->dryRun(true);

// Extract query results
$queryJob = $bigQuery->startJob($jobConfig);
$info = $queryJob->info();

printf('This query will process %s bytes' . PHP_EOL, $info['statistics']['totalBytesProcessed']);

Python

מגדירים את המאפיין QueryJobConfig.dry_run לערך True. הפונקציה Client.query() תמיד מחזירה QueryJob שהושלם כשמספקים לה הגדרת שאילתה של הרצה יבשה.

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

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

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)

# Start the query, passing in the extra configuration.
query_job = client.query(
    (
        "SELECT name, COUNT(*) as name_count "
        "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
        "WHERE state = 'WA' "
        "GROUP BY name"
    ),
    job_config=job_config,
)  # Make an API request.

# A dry run query completes immediately.
print("This query will process {} bytes.".format(query_job.total_bytes_processed))

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

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