‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

הרצת שאילתה

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

סוגי השאילתות

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

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

אפשר להריץ משימות של שאילתות בשיטות הבאות:

כותבים ומריצים שאילתה במסוףGoogle Cloud .
מריצים את הפקודה bq query בכלי שורת הפקודה של BigQuery.
קוראים באופן פרוגרמטי ל-method‏ jobs.query או jobs.insert ב-API בארכיטקטורת REST של 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 בפרויקט שאתם שולחים אליו שאילתה. ההרשאה הזו נדרשת בנוסף לכל הרשאה שנדרשת כדי לגשת לנתונים ששלחתם לגביהם שאילתה.

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

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

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

המסוף

נכנסים לדף BigQuery.

כניסה ל-BigQuery
לוחצים על שאילתת SQL.
בעורך השאילתות, מזינים שאילתת 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;
```
אפשר גם להשתמש בחלונית Reference כדי ליצור שאילתות חדשות.
אופציונלי: כדי להציג באופן אוטומטי הצעות לקוד כשמקלידים שאילתה, לוחצים על Tools > Parser-based auto-completion. אם אתם לא צריכים הצעות של השלמה אוטומטית, בטלו את הבחירה באפשרות השלמה אוטומטית מבוססת-מנתח. הפעולה הזו גם משביתה את ההצעות למילוי אוטומטי של שם הפרויקט.
אופציונלי: כדי לבחור הגדרות שאילתה נוספות, לוחצים על Edit > Query settings.
לוחצים על הפעלה.

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

עכשיו אפשר לבדוק את תוצאות השאילתה בכרטיסייה Results שבחלונית Query results.
אופציונלי: כדי למיין את תוצאות השאילתה לפי עמודה, לוחצים על Open sort menu ליד שם העמודה ובוחרים סדר מיון. אם מספר הבייטים המשוער לעיבוד לצורך המיון גדול מאפס, מספר הבייטים מוצג בחלק העליון של התפריט.
אופציונלי: כדי לראות תצוגה חזותית של תוצאות השאילתה, עוברים לכרטיסייה Visualization. אפשר להגדיל או להקטין את התצוגה של התרשים, להוריד אותו כקובץ PNG או להציג או להסתיר את המקרא.

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

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

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

BQ

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

הפעלת Cloud Shell

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

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

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

הכנת הספרייה

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

יוצרים ספרייה חדשה ב-Cloud Shell ובה יוצרים קובץ חדש. שם הקובץ חייב לכלול את הסיומת .tf, למשל main.tf. במדריך הזה, הקובץ נקרא main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
אם אתם עוקבים אחרי המדריך, תוכלו להעתיק את הקוד לדוגמה בכל קטע או שלב.

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

לחלופין, אפשר גם להעתיק את הקוד מ-GitHub. כדאי לעשות את זה כשקטע הקוד של Terraform הוא חלק מפתרון מקצה לקצה.
בודקים את הפרמטרים לדוגמה ומשנים אותם בהתאם לסביבה שלכם.
שומרים את השינויים.
מפעילים את Terraform. צריך לעשות זאת רק פעם אחת לכל ספרייה.
```
terraform init
```
אופציונלי: תוכלו לכלול את האפשרות -upgrade, כדי להשתמש בגרסה העדכנית ביותר של הספק של Google:
```
terraform init -upgrade
```

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

בודקים את ההגדרות ומוודאים שהמשאבים שמערכת Terraform תיצור או תעדכן תואמים לציפיות שלכם:
```
terraform plan
```
מתקנים את ההגדרות לפי הצורך.
מריצים את הפקודה הבאה ומזינים yes בהודעה שמופיעה, כדי להחיל את הגדרות Terraform:
```
terraform apply
```
ממתינים עד שב-Terraform תוצג ההודעה "Apply complete!‎".
פותחים את הפרויקט ב- Google Cloud כדי להציג את התוצאות. במסוף Google Cloud , נכנסים למשאבים בממשק המשתמש כדי לוודא שהם נוצרו או עודכנו ב-Terraform.

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

הרצה יבשה

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

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

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

הרצת בדיקה

כדי לבצע הרצת בדיקה, בצע את הפעולות הבאות:

המסוף

נכנסים לדף BigQuery.

כניסה ל-BigQuery
מזינים את השאילתה בעורך השאילתות.

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

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.

API

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

המשך

כדי לבצע אימות ב-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

כדי לבצע אימות ב-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

כדי לבצע אימות ב-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

כדי לבצע אימות ב-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 שהושלם כשמספקים הגדרת שאילתה להרצה יבשה.

כדי לבצע אימות ב-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))

פתרון בעיות בשאילתות

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

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

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

המסוף

נכנסים לדף BigQuery.

כניסה ל-BigQuery
לוחצים על שאילתת SQL.
בעורך השאילתות, מזינים שאילתת 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;
```
לוחצים על עריכה > הגדרות השאילתה.
בקטע Resource management, לוחצים על Batch.
אופציונלי: משנים את הגדרות השאילתה.
לוחצים על Save.
לוחצים על הפעלה.

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

BQ

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

הפעלת Cloud Shell

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

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

המשך

כדי לבצע אימות ב-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.

כדי לבצע אימות ב-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

כדי לבצע אימות ב-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

כדי לבצע אימות ב-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

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

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

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

כניסה ל-BigQuery
לוחצים על שאילתת SQL.
לוחצים על quick_reference_all Reference.
לוחצים על טבלה או תצוגה שנוספו לאחרונה או סומנו בכוכב. אפשר גם להשתמש בשורת החיפוש כדי למצוא טבלאות ותצוגות.
לוחצים על View actions ואז על Insert query snippet.
אופציונלי: אפשר לראות תצוגה מקדימה של פרטי הסכימה של הטבלה או התצוגה, או לפתוח אותם בכרטיסייה חדשה.
עכשיו אפשר לערוך את השאילתה באופן ידני או להוסיף שמות של שדות ישירות לשאילתה. כדי להוסיף שם של שדה, לוחצים על המקום בעורך השאילתות שבו רוצים להוסיף את שם השדה, ואז לוחצים על שם השדה בחלונית Reference.

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

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

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

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

המסוף

נכנסים לדף BigQuery.

כניסה ל-BigQuery
לוחצים על שאילתת SQL.
בעורך השאילתות, מזינים שאילתת 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;
```
לוחצים על Edit > Query mode > Optional job creation. כדי לאשר את הבחירה, לוחצים על אישור.
לוחצים על הפעלה.

BQ

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

הפעלת Cloud Shell

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

כדי לבצע אימות ב-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 ואילך

כדי לבצע אימות ב-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 ואילך

כדי לבצע אימות ב-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 ואילך

כדי לבצע אימות ב-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 גרסה 1.6.1 ואילך

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

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

מנהל התקן 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

שאילתות עם אחזור נתונים גלובלי

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

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

מכסות

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

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

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

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

סביבת זמן ריצה מתקדמת

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

וקטוריזציה משופרת

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

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

אופטימיזציה של שאילתות קצרות

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

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

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

הערכת ההשפעה של סביבת זמן הריצה המתקדמת

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

WITH
  jobs AS (
    SELECT
      *,
      query_info.query_hashes.normalized_literals AS query_hash,
      TIMESTAMP_DIFF(end_time, start_time, MILLISECOND) AS elapsed_ms,
      EXISTS(
        SELECT 1
        FROM UNNEST(JSON_QUERY_ARRAY(query_info.optimization_details.optimizations)) AS o
        WHERE JSON_VALUE(o, '$.enhanced_vectorization') = 'applied'
      ) AS has_advanced_runtime
    FROM region-LOCATION.INFORMATION_SCHEMA.JOBS_BY_PROJECT
    WHERE EXTRACT(DATE FROM creation_time) > DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
  ),
  most_recent_jobs_without_advanced_runtime AS (
    SELECT *
    FROM jobs
    WHERE NOT has_advanced_runtime
    QUALIFY ROW_NUMBER() OVER (PARTITION BY query_hash ORDER BY end_time DESC) = 1
  )
SELECT
  job.job_id,
  100 * SAFE_DIVIDE(
    original_job.elapsed_ms - job.elapsed_ms,
    original_job.elapsed_ms) AS percent_execution_time_saved,
  job.elapsed_ms AS new_elapsed_ms,
  original_job.elapsed_ms AS original_elapsed_ms,
FROM jobs AS job
INNER JOIN most_recent_jobs_without_advanced_runtime AS original_job
  USING (query_hash)
WHERE
  job.has_advanced_runtime
  AND original_job.end_time < job.start_time
ORDER BY percent_execution_time_saved DESC
LIMIT 10;

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

‫LOCATION: המיקום שבו צריך למדוד את ביצועי המשימה

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

/*--------------+----------------------------+----------------+---------------------*
 |    job_id    | percent_elapsed_time_saved | new_elapsed_ms | original_elapsed_ms |
 +--------------+----------------------------+----------------+---------------------+
 | sample_job1  |         45.38834951456311  |            225 |                 412 |
 | sample_job2  |         45.19480519480519  |            211 |                 385 |
 | sample_job3  |         33.246753246753244 |            257 |                 385 |
 | sample_job4  |         29.28802588996764  |           1311 |                1854 |
 | sample_job5  |         28.18181818181818  |           1027 |                1430 |
 | sample_job6  |         25.804195804195807 |           1061 |                1430 |
 | sample_job7  |         25.734265734265733 |           1062 |                1430 |
 | sample_job8  |         25.454545454545453 |           1066 |                1430 |
 | sample_job9  |         25.384615384615383 |           1067 |                1430 |
 | sample_job10 |         25.034965034965033 |           1072 |                1430 |
 *--------------+----------------------------+----------------+---------------------*/

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

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

אפשר להחיל את השאילתה הזו על מדדים אחרים של ביצועי שאילתות, כמו total_slot_ms ו-total_bytes_billed. מידע נוסף זמין בסכימה של INFORMATION_SCHEMA.JOBS_BY_PROJECT.

הרצת שאילתה

סוגי השאילתות

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

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

פתרון בעיות

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

המסוף

BQ

Terraform

הכנת Cloud Shell

הכנת הספרייה

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

API

C#‎

המשך

Java

Node.js

PHP

Python

Ruby

הרצה יבשה

הרצת בדיקה

המסוף

BQ

API

המשך

Java

Node.js

PHP

Python

פתרון בעיות בשאילתות

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

המסוף

BQ

API

המשך

Java

Node.js

Python

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

שימוש בחלונית Reference

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

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

המסוף

BQ

API

Java

Python

צומת

המשך

מנהל התקן JDBC

מנהל התקן ODBC

שאילתות עם אחזור נתונים גלובלי

מכסות

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

סביבת זמן ריצה מתקדמת

וקטוריזציה משופרת

אופטימיזציה של שאילתות קצרות

הערכת ההשפעה של סביבת זמן הריצה המתקדמת

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