Menulis hasil kueri

Dokumen ini menjelaskan cara menulis hasil kueri ke tabel sementara atau permanen.

Tabel sementara dan permanen

BigQuery menyimpan semua hasil kueri ke tabel, yang dapat bersifat permanen atau sementara.

• BigQuery menggunakan tabel sementara untuk menyimpan hasil kueri yang tidak ditulis ke tabel permanen. Tabel dibuat dalam set data khusus dan diberi nama secara acak. Anda juga dapat membuat tabel sementara untuk penggunaan Anda sendiri dalam kueri multi-pernyataan dan sesi.

• Setelah kueri selesai, tabel sementara akan ada hingga 24 jam. Untuk melihat struktur dan data tabel, buka konsol BigQuery, klik Histori pribadi, lalu pilih kueri yang membuat tabel sementara. Kemudian, di baris Tabel tujuan, klik Tabel sementara.

• Akses ke data tabel sementara dibatasi untuk pengguna atau akun layanan yang membuat tugas kueri.

• Anda tidak dapat membagikan tabel sementara, dan tabel tersebut tidak terlihat menggunakan daftar standar atau metode manipulasi tabel lainnya. Tabel sementara dibuat di region yang sama dengan tabel yang dikueri.

• Tabel permanen dapat berupa tabel baru atau yang sudah ada di set data apa pun yang aksesnya Anda miliki. Jika menulis hasil kueri ke tabel baru, Anda akan dikenai biaya untuk storing data. Saat Anda menulis hasil kueri ke tabel permanen, tabel yang Anda kuerikan harus berada di lokasi yang sama dengan set data yang berisi tabel tujuan.

Catatan: Jika Anda membuat kueri data dari project ke data yang disimpan di project lain, project pembuatan kueri akan dikenai biaya untuk tugas kueri saat project yang menyimpan data ditagih untuk jumlah data yang disimpan di BigQuery.

Izin yang diperlukan

Setidaknya, untuk menulis hasil kueri ke tabel, Anda harus diberi izin berikut:

• bigquery.tables.create izin untuk membuat tabel baru
• bigquery.tables.updateData untuk menulis data ke tabel baru, menimpa tabel, atau menambahkan data ke tabel
• bigquery.jobs.create untuk menjalankan tugas kueri

Izin tambahan seperti bigquery.tables.getData mungkin diperlukan untuk mengakses data yang Anda minta.

Peran IAM yang telah ditetapkan berikut mencakup izin bigquery.tables.create dan bigquery.tables.updateData:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

Peran IAM yang telah ditetapkan berikut mencakup izin bigquery.jobs.create:

• bigquery.user
• bigquery.jobUser
• bigquery.admin

Selain itu, jika pengguna memiliki izin bigquery.datasets.create, saat pengguna tersebut membuat set data, dia diberi akses bigquery.dataOwner. Akses bigquery.dataOwner memberi pengguna kemampuan untuk membuat dan memperbarui tabel dalam set data.

Untuk mengetahui informasi lebih lanjut tentang peran dan izin IAM di BigQuery, lihat Peran dan izin yang telah ditetapkan.

Menulis hasil kueri ke tabel permanen

Saat menulis hasil kueri ke tabel permanen, Anda dapat membuat tabel baru, menambahkan hasil ke tabel yang sudah ada, atau menimpa tabel yang sudah ada.

Menulis hasil kueri

Gunakan prosedur berikut untuk menulis hasil kueri Anda ke tabel permanen. Untuk membantu mengontrol biaya, Anda dapat melihat pratinjau data sebelum menjalankan kueri.

Konsol

1. Buka halaman BigQuery di konsol Google Cloud.

   Buka halaman BigQuery

2. Di panel Explorer, luaskan project Anda dan pilih set data.

3. Masukkan kueri SQL yang valid.

4. Klik Lainnya lalu pilih Setelan kueri.

   

5. Pilih opsi Tetapkan tabel tujuan untuk hasil kueri.

   

6. Di bagian Tujuan, pilih Set data tempat Anda ingin membuat tabel, lalu pilih ID Tabel.

7. Di bagian Preferensi tulis tabel tujuan, pilih salah satu dari berikut ini:

   • Tulis jika kosong — Menulis hasil kueri ke tabel hanya jika tabel kosong.
   • Append to table — Menambahkan hasil kueri ke tabel yang ada.
   • Overwrite table — Menimpa tabel yang ada dengan nama yang sama menggunakan hasil kueri.

8. Opsional: Untuk Lokasi data, pilih lokasi Anda.

9. Untuk memperbarui setelan kueri, klik Simpan.

10. Klik Jalankan. Ini akan membuat tugas kueri yang menulis hasil kueri ke tabel yang Anda tentukan.

Atau, jika lupa menentukan tabel tujuan sebelum menjalankan kueri, Anda dapat menyalin tabel hasil yang di-cache ke tabel permanen dengan mengklik tombol Simpan Hasil di atas editor.

SQL

Contoh berikut menggunakan pernyataan CREATE TABLE untuk membuat tabel trips dari data di tabel bikeshare_trips publik:

1. Di konsol Google Cloud, buka halaman BigQuery.

   Buka BigQuery

2. Di editor kueri, masukkan pernyataan berikut:

   CREATE TABLE mydataset.trips AS (
     SELECT
       bike_id,
       start_time,
       duration_minutes
     FROM
       bigquery-public-data.austin_bikeshare.bikeshare_trips
   );
   

3. Klik Run.

Untuk informasi selengkapnya tentang cara menjalankan kueri, lihat Menjalankan kueri interaktif.

Untuk mengetahui informasi selengkapnya, lihat Membuat tabel baru dari tabel yang ada.

bq

1. Di konsol Google Cloud, aktifkan Cloud Shell.

   Aktifkan Cloud Shell

   Di bagian bawah Google Cloud Console, Cloud Shell sesi akan terbuka dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi sesi.

2. Masukkan perintah bq query dan tentukan flag --destination_table untuk membuat tabel permanen berdasarkan hasil kueri. Tentukan flag use_legacy_sql=false untuk menggunakan sintaksis GoogleSQL. Untuk menulis hasil kueri ke tabel yang tidak ada dalam project default Anda, tambahkan ID project ke nama set data dalam format berikut: project_id:dataset.

   Opsional: Berikan flag --location dan tetapkan nilainya ke lokasi Anda.

   Untuk mengontrol disposisi tulis untuk tabel tujuan yang ada, tentukan salah satu flag opsional berikut:

   • --append_table: Jika tabel tujuan ada, hasil kueri akan ditambahkan ke tabel tujuan tersebut.

   • --replace: Jika ada, tabel tujuan akan ditimpa dengan hasil kueri.

     bq --location=location query \
     --destination_table project_id:dataset.table \
     --use_legacy_sql=false 'query'
     

     Ganti kode berikut:

   • location adalah nama lokasi yang digunakan untuk memproses kueri. Flag --location bersifat opsional. Misalnya, jika menggunakan BigQuery di region Tokyo, Anda dapat menetapkan nilai flag ke asia-northeast1. Anda dapat menetapkan nilai default untuk lokasi menggunakan file .bigqueryrc.

   • project_id adalah project ID Anda.

   • dataset adalah nama set data yang berisi tabel tempat Anda menulis hasil kueri.

   • table adalah nama tabel tempat Anda menulis hasil kueri.

   • query adalah kueri dalam sintaksis GoogleSQL.

     Jika flag disposisi tulis tidak ditentukan, perilaku default-nya adalah menulis hasil ke tabel hanya jika kosong. Jika tabel itu ada dan tidak kosong, error berikut akan ditampilkan: `BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

     Contoh:

     Catatan: Contoh ini membuat kueri set data publik yang berbasis di AS. Karena set data publik disimpan di lokasi multi-region AS, set data yang berisi tabel tujuan juga harus berada di AS. Anda tidak dapat membuat kueri set data di satu lokasi dan menulis hasilnya ke tabel tujuan di lokasi lain.

     Masukkan perintah berikut untuk menulis hasil kueri ke tabel tujuan bernama mytable di mydataset. Set data ada dalam project default Anda. Karena tidak ada flag disposisi tulis yang ditentukan dalam perintah, tabel harus baru atau kosong. Jika tidak, error Already exists akan ditampilkan. Kueri ini mengambil data dari set data publik Data Nama AS.

     bq query \
     --destination_table mydataset.mytable \
     --use_legacy_sql=false \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'
     

     Masukkan perintah berikut untuk menggunakan hasil kueri guna menimpa tabel tujuan bernama mytable di mydataset. Set data berada dalam project default Anda. Perintah ini menggunakan flag --replace untuk menimpa tabel tujuan.

     bq query \
     --destination_table mydataset.mytable \
     --replace \
     --use_legacy_sql=false \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'
     

     Masukkan perintah berikut untuk menambahkan hasil kueri ke tabel tujuan bernama mytable di mydataset. Set data berada di my-other-project, bukan di project default Anda. Perintah ini menggunakan flag --append_table untuk menambahkan hasil kueri ke tabel tujuan.

     bq query \
     --append_table \
     --use_legacy_sql=false \
     --destination_table my-other-project:mydataset.mytable \
     'SELECT
     name,
     number
     FROM
     `bigquery-public-data`.usa_names.usa_1910_current
     WHERE
     gender = "M"
     ORDER BY
     number DESC'
     

     Output untuk setiap contoh ini terlihat seperti berikut. Agar mudah dibaca, beberapa output akan terpotong.

     Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
     +---------+--------+
     |  name   | number |
     +---------+--------+
     | Robert  |  10021 |
     | John    |   9636 |
     | Robert  |   9297 |
     | ...              |
     +---------+--------+
     

API

Untuk menyimpan hasil kueri ke tabel permanen, panggil metode jobs.insert, konfigurasi tugas query, dan sertakan nilai untuk propertidestinationTable. Untuk mengontrol disposisi tulis untuk tabel tujuan yang ada, konfigurasi properti writeDisposition.

Guna mengontrol lokasi pemrosesan untuk tugas kueri, tentukan properti location di bagian jobReference pada resource tugas.

Go

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Go di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Go API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

import (
	"context"
	"fmt"
	"io"

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

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// 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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Java API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

Untuk menyimpan hasil kueri ke tabel permanen, tetapkan tabel tujuan ke TableId yang diinginkan di QueryJobConfiguration.

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

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, 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();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

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

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Node.js API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

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

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  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/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

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

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Python di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Python API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

Untuk menyimpan hasil kueri ke tabel permanen, buat QueryJobConfig dan tetapkan tujuan ke TableReference yang diinginkan. Teruskan konfigurasi tugas ke metode kueri.

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

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.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Menulis hasil kueri yang besar

Biasanya, kueri memiliki ukuran respons maksimum. Jika berencana menjalankan kueri yang mungkin menampilkan hasil lebih besar, Anda dapat melakukan salah satu hal berikut:

• Di GoogleSQL, tentukan tabel tujuan untuk hasil kueri.
• Di SQL lama, tentukan tabel tujuan dan tetapkan opsi allowLargeResults.

Saat menentukan tabel tujuan untuk hasil kueri yang besar, Anda dikenai biaya untuk storing data.

Batasan

Dalam legacy SQL, penulisan hasil yang besar tunduk pada batasan berikut:

• Anda harus menentukan tabel tujuan.
• Anda tidak dapat menentukan klausa ORDER BY, TOP, atau LIMIT tingkat teratas. Tindakan tersebut akan meniadakan manfaat penggunaan allowLargeResults, karena output kueri tidak lagi dapat dihitung secara paralel.
• Fungsi jendela dapat menampilkan hasil kueri yang besar hanya jika digunakan bersama dengan klausa PARTITION BY.

Menulis hasil besar menggunakan legacy SQL

Untuk menulis set hasil yang besar menggunakan legacy SQL:

Konsol

1. Di konsol Google Cloud, buka halaman BigQuery.

   Buka BigQuery

2. Klik Compose New Query.

3. Masukkan kueri SQL yang valid di area teks Editor kueri. Gunakan awalan #legacySQL atau pastikan Anda telah mencentang Gunakan SQL Lama di setelan kueri.

4. Klik Lainnya, lalu pilih Setelan kueri.

   

5. Untuk Tujuan, centang Tetapkan tabel tujuan untuk hasil kueri.

   

6. Untuk Set data, pilih set data yang akan menyimpan tabel.

7. Di kolom ID Tabel, masukkan nama tabel.

8. Jika menulis hasil besar yang ditetapkan ke tabel yang sudah ada, Anda dapat menggunakan opsi Preferensi penulisan tabel tujuan untuk mengontrol disposisi tulis tabel tujuan:

   • Tulis jika kosong: Menulis hasil kueri ke tabel hanya jika tabel kosong.
   • Tambahkan ke tabel: Menambahkan hasil kueri ke tabel yang ada.
   • Timpa tabel: Menimpa tabel yang ada dengan nama yang sama menggunakan hasil kueri.

9. Untuk Hasil Ukuran, centang Izinkan hasil besar (tanpa batas ukuran).

10. Opsional: Untuk Lokasi data, pilih lokasi data Anda.

11. Klik Simpan untuk mengubah setelan kueri.

12. Klik Jalankan. Tindakan ini akan membuat tugas kueri yang menulis hasil besar yang ditetapkan ke tabel yang Anda tentukan.

bq

Gunakan tanda --allow_large_results dengan tanda --destination_table untuk membuat tabel tujuan untuk menyimpan kumpulan hasil besar. Karena opsi --allow_large_results hanya berlaku untuk SQL lama, Anda juga harus menentukan flag --use_legacy_sql=true. Untuk menulis hasil kueri ke tabel yang tidak ada dalam project default Anda, tambahkan project ID ke nama set data dalam format berikut: PROJECT_ID:DATASET. Berikan flag --location dan tetapkan nilai ke lokasi Anda.

Untuk mengontrol disposisi tulis untuk tabel tujuan yang ada, tentukan salah satu flag opsional berikut:

• --append_table: Jika tabel tujuan ada, hasil kueri akan ditambahkan ke tabel tujuan tersebut.
• --replace: Jika ada, tabel tujuan akan ditimpa dengan hasil kueri.

bq --location=location query \
--destination_table PROJECT_ID:DATASET.TABLE \
--use_legacy_sql=true \
--allow_large_results "QUERY"

Ganti kode berikut:

• LOCATION adalah nama lokasi yang digunakan untuk memproses kueri. Flag --location bersifat opsional. Misalnya, jika menggunakan BigQuery di region Tokyo, Anda dapat menetapkan nilai flag ke asia-northeast1. Anda dapat menetapkan nilai default untuk lokasi menggunakan file .bigqueryrc.
• PROJECT_ID adalah project ID Anda.
• DATASET adalah nama set data yang berisi tabel tempat Anda menulis hasil kueri.
• TABLE adalah nama tabel tempat Anda menulis hasil kueri.
• QUERY adalah kueri dalam sintaksis legacy SQL.

Contoh:

Catatan: Contoh ini membuat kueri set data publik. Karena set data disimpan di lokasi multi-region US, set data tujuan Anda juga harus berada di AS. Anda tidak dapat menulis hasil kueri data publik ke tabel di region lain.

Masukkan perintah berikut untuk menulis hasil kueri yang besar ke tabel tujuan bernama mytable di mydataset. Set data berada dalam project default Anda. Karena tidak ada flag disposisi tulis yang ditentukan dalam perintah, tabel harus baru atau kosong. Jika tidak, error Already exists akan ditampilkan. Kueri tersebut mengambil data dari set data publik Data Nama USA. Kueri ini hanya digunakan sebagai contoh. Kumpulan hasil yang ditampilkan tidak melebihi ukuran respons maksimum.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Masukkan perintah berikut untuk menggunakan hasil kueri berukuran besar guna menimpa tabel tujuan bernama mytable di mydataset. Set data berada di myotherproject, bukan di project default Anda. Perintah ini menggunakan flag --replace untuk menimpa tabel tujuan.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Masukkan perintah berikut untuk menambahkan hasil kueri berukuran besar ke tabel tujuan bernama mytable di mydataset. Set data berada di myotherproject, bukan project default Anda. Perintah ini menggunakan flag --append_table untuk menambahkan hasil kueri ke tabel tujuan.

bq query \
--destination_table myotherproject:mydataset.mytable \
--append_table \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

API

Untuk menulis hasil yang besar ke tabel tujuan, panggil jobs.insert tradisional, mengonfigurasiquery tugas, dan tetapkanallowLargeResults properti kepadatrue singkat ini. Tentukan tabel tujuan menggunakan properti destinationTable. Untuk mengontrol disposisi tulis untuk tabel tujuan yang ada, konfigurasi properti writeDisposition.

Tentukan lokasi Anda di properti location di bagian jobReference di resource tugas.

Go

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Go di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Go API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

import (
	"context"
	"fmt"
	"io"

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

// queryLegacyLargeResults demonstrates issuing a legacy SQL query and writing a large result set
// into a destination table.
func queryLegacyLargeResults(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "destinationdataset"
	// tableID := "destinationtable"
	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 corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;")
	q.UseLegacySQL = true
	q.AllowLargeResults = true
	q.QueryConfig.Dst = client.Dataset(datasetID).Table(tableID)
	// 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

Untuk mengaktifkan hasil besar, setel memungkinkan hasil yang besar ke true dan tetapkan tabel tujuan ke situs ID Tabel dalam QueryJobConfiguration.

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.TableId;
import com.google.cloud.bigquery.TableResult;

// Sample to run query with large results and save the results to a table.
public class QueryLargeResults {

  public static void runQueryLargeResults() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDataset = "MY_DESTINATION_DATASET_NAME";
    String destinationTable = "MY_DESTINATION_TABLE_NAME";
    String query = "SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;";
    queryLargeResults(destinationDataset, destinationTable, query);
  }

  public static void queryLargeResults(
      String destinationDataset, String destinationTable, 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 =
          // To use legacy SQL syntax, set useLegacySql to true.
          QueryJobConfiguration.newBuilder(query)
              .setUseLegacySql(true)
              // Save the results of the query to a permanent table.
              .setDestinationTable(TableId.of(destinationDataset, destinationTable))
              // Allow results larger than the maximum response size.
              // If true, a destination table must be set.
              .setAllowLargeResults(true)
              .build();

      TableResult results = bigquery.query(queryConfig);

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

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

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Node.js API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

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

async function queryLegacyLargeResults() {
  // Query enables large result sets.

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

  const query = `SELECT word FROM [bigquery-public-data:samples.shakespeare] LIMIT 10;`;

  // 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 and of the destination table.
    useLegacySql: true,
    allowLargeResult: true,
    destinationTable: {
      projectId: projectId,
      datasetId: datasetId,
      tableId: tableId,
    },
  };

  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));
}

Python

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Python di Panduan memulai BigQuery menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi BigQuery Python API.

Untuk melakukan autentikasi ke BigQuery, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien.

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

# Set the destination table and use_legacy_sql to True to use
# legacy SQL syntax.
job_config = bigquery.QueryJobConfig(
    allow_large_results=True, destination=table_id, use_legacy_sql=True
)

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.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Mendownload dan menyimpan hasil kueri dari konsol Google Cloud

Setelah menjalankan kueri SQL menggunakan konsol Google Cloud, Anda dapat menyimpan hasilnya ke lokasi lain. Anda dapat menggunakan konsol Google Cloud untuk mendownload hasil kueri ke file lokal, Google Spreadsheet, atau Google Drive. Jika Anda mengurutkan hasil kueri berdasarkan kolom terlebih dahulu, urutan tersebut akan dipertahankan dalam data yang didownload. Menyimpan hasil ke file lokal, Google Spreadsheet, atau Google Drive tidak didukung oleh alat command line bq atau API.

Batasan

Mendownload dan menyimpan hasil kueri memiliki batasan berikut:

• Anda dapat mendownload hasil kueri secara lokal dalam format CSV atau format JSON yang dibatasi baris baru.
• Anda tidak dapat menyimpan hasil kueri yang berisi data bertingkat dan berulang ke Google Spreadsheet.
• Untuk menyimpan hasil kueri ke Google Drive menggunakan Google Cloud Console, hasil yang ditetapkan harus berukuran 1 GB atau kurang. Jika hasil Anda lebih besar, Anda dapat menyimpannya ke tabel.
• Saat menyimpan hasil kueri ke file CSV lokal, ukuran download maksimum adalah 10 MB. Ukuran download maksimum didasarkan pada ukuran setiap baris yang ditampilkan dalam respons metode tabledata.list, dan dapat bervariasi berdasarkan skema hasil kueri. Akibatnya, ukuran file CSV yang didownload dapat bervariasi, dan mungkin kurang dari batas ukuran download maksimum.
• Anda hanya dapat menyimpan hasil kueri ke Google Drive dalam format CSV atau format JSON yang dibatasi baris baru.

Langkah selanjutnya

• Pelajari cara mengekspor tabel ke file JSON secara terprogram.
• Pelajari kuota untuk tugas kueri.
• Pelajari harga penyimpanan BigQuery.