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

הרצת שאילתה

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

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

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

‫BigQuery Job User (roles/bigquery.jobUser) בפרויקט.
‫BigQuery Data Viewer (צפייה בנתוני BigQuery) (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.

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

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

המסוף

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

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

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

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

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

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

BQ

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

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

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

BQ

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

הפעלת 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, פועלים לפי השלבים הבאים:

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

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

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

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

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

BQ

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

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

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

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

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

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

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

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

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

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

כדי להעריך את ההשפעה של סביבת זמן ריצה מתקדמת, אפשר להשתמש בשאילתת 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

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

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

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

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

המסוף

BQ

API

Java

Python

צומת

המשך

דרייבר JDBC

דרייבר ODBC

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

מכסות

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

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

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

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

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

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