Tabellendaten verwalten

In diesem Dokument wird beschrieben, wie Tabellendaten in BigQuery verwaltet werden. Sie können auf die folgenden Arten mit BigQuery-Tabellendaten arbeiten:

  • Daten in eine Tabelle laden
  • Tabellendaten durchsuchen (oder Vorschau ansehen)
  • Tabellendaten abfragen
  • Tabellendaten anfügen oder überschreiben
  • Tabellendaten mithilfe der Datenbearbeitungssprache (Data Manipulation Language, DML) ändern
  • Tabellendaten kopieren
  • Tabellendaten exportieren

Weitere Informationen zum Verwalten von Tabellenschemas finden Sie unter Tabellenschemas ändern.

Daten in eine Tabelle laden

Sie können Daten laden, wenn Sie eine Tabelle erstellen, oder Sie können eine leere Tabelle erstellen und die Daten später laden. Wenn Sie Daten laden, haben Sie die Möglichkeit, für unterstützte Datenformate die automatische Schemaerkennung zu verwenden oder das Schema anzugeben.

Weitere Informationen zum Laden von Daten finden Sie in der Dokumentation zum Format und Speicherort Ihrer Quelldaten:

Tabellendaten durchsuchen

So können Sie Tabellendaten durchsuchen:

  • Mit der Cloud Console
  • Mit dem Befehl bq head des bq-Befehlszeilentools
  • Durch Aufrufen der API-Methode tabledata.list
  • Mit den Clientbibliotheken

Erforderliche Berechtigungen

Zum Abrufen einer Tabelle müssen Ihnen mindestens Berechtigungen des Typs bigquery.tables.getData erteilt worden sein. Die folgenden vordefinierten IAM-Rollen enthalten bigquery.tables.getData-Berechtigungen:

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

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit bigquery.dataOwner-Zugriff hat der Nutzer die Möglichkeit, Daten in Tabellen und Partitionen im Dataset zu durchsuchen.

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Vordefinierte Rollen und Berechtigungen.

Tabellendaten durchsuchen

So durchsuchen Sie Tabellendaten:

Console

  1. Öffnen Sie in der Cloud Console die Seite "BigQuery".

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie auf eine Tabelle in der Liste.

  4. Klicken Sie auf Details und notieren Sie den Wert in Zeilenanzahl. Möglicherweise benötigen Sie diesen Wert, um den Ausgangspunkt für Ihre Ergebnisse mit dem bq-Befehlszeilentool oder der API zu steuern.

  5. Klicken Sie auf Vorschau. Ein Beispielsatz mit Daten wird angezeigt:

    Tabellenvorschau

Befehlszeile

Führen Sie den Befehl bq head mit dem Flag --max_rows aus, um alle Spalten in einer bestimmten Anzahl von Tabellenzeilen aufzulisten. Wenn --max_rows nicht angegeben ist, lautet die Standardeinstellung 100.

Verwenden Sie das Flag --selected_fields und geben Sie die Spalten als durch Kommas getrennte Liste ein, um in einer Teilmenge von Spalten in der Tabelle zu suchen, einschließlich verschachtelter und sich wiederholender Spalten.

Mit dem Flag --start_row=integer (oder dem Kürzel -s) können Sie festlegen, wie viele Zeilen übersprungen werden, bevor die Tabellendaten angezeigt werden. Der Standardwert ist 0. Die Anzahl der Zeilen in einer Tabelle können Sie mit dem Befehl bq show zum Abrufen von Tabelleninformationen abfragen.

Wenn sich die Tabelle, die Sie ansehen möchten, in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Befehl die Projekt-ID im folgenden Format hinzu: project_id:dataset.table.

bq head \
--max_rows integer1 \
--start_row integer2 \
--selected_fields "columns" \
project_id:dataset.table

Dabei gilt:

  • integer1 ist die Anzahl der anzuzeigenden Zeilen.
  • integer2 ist die Anzahl der zu überspringenden Zeilen, bevor Daten angezeigt werden.
  • columns ist eine durch Kommas getrennte Liste von Spalten.
  • project_id ist die Projekt-ID.
  • dataset ist der Name des Datasets, das die Tabelle enthält.
  • table ist der Name der zu durchsuchenden Tabelle.

Beispiele:

Geben Sie den folgenden Befehl ein, um alle Spalten in den ersten 10 Zeilen in mydataset.mytable aufzulisten. mydataset befindet sich in Ihrem Standardprojekt.

bq head --max_rows=10 mydataset.mytable

Geben Sie den folgenden Befehl ein, um alle Spalten in den ersten 100 Zeilen in mydataset.mytable aufzulisten. mydataset befindet sich im Projekt myotherproject, nicht in Ihrem Standardprojekt.

bq head myotherproject:mydataset.mytable

Geben Sie den folgenden Befehl ein, um nur field1 und field2 aus mydataset.mytable anzeigen zu lassen. Der Befehl verwendet das Flag --start_row, um zu Zeile 100 zu springen. mydataset.mytable befindet sich in Ihrem Standardprojekt.

bq head --start_row 100 --selected_fields "field1,field2" mydataset.mytable

Da mit dem Befehl bq head kein Abfragejob erstellt wird, werden bq head-Befehle nicht im Abfrageverlauf angezeigt und nicht berechnet.

API

Wenn Sie die Daten in einer Tabelle ansehen möchten, rufen Sie tabledata.list auf. Geben Sie den Namen der Tabelle im Parameter tableId an.

Mit den folgenden optionalen Parametern können Sie die Ausgabe steuern:

  • maxResults: Maximale Anzahl der Ergebnisse, die zurückgegeben werden sollen
  • selectedFields: durch Kommas getrennte Liste der Spalten, die zurückgegeben werden sollen; wenn nicht angegeben, werden alle Spalten zurückgegeben
  • startIndex: nullbasierter Index der Startzeile, die gelesen werden soll

Die Werte werden zusammengefasst in einem JSON-Objekt zurückgegeben. Dieses Objekt muss dann wie in der Referenzdokumentation zu tabledata.list beschrieben geparst werden.

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von C# in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery C# API.


using Google.Api.Gax;
using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryBrowseTable
{
    public void BrowseTable(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference tableReference = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        // Load all rows from a table
        PagedEnumerable<TableDataList, BigQueryRow> result = client.ListRows(
            tableReference: tableReference,
            schema: null
        );
        // Print the first 10 rows
        foreach (BigQueryRow row in result.Take(10))
        {
            Console.WriteLine($"{row["corpus"]}: {row["word_count"]}");
        }
    }
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Die Cloud-Clientbibliothek für Go erstellt Seitenumbrüche standardmäßig automatisch. Deshalb müssen Sie die Seitenumbrüche nicht selbst einfügen. Beispiel:

import (
	"context"
	"fmt"
	"io"

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

// browseTable demonstrates reading data from a BigQuery table directly without the use of a query.
// For large tables, we also recommend the BigQuery Storage API.
func browseTable(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	table := client.Dataset(datasetID).Table(tableID)
	it := table.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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableDataListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableResult;

// Sample to directly browse a table with optional paging
public class BrowseTable {

  public static void runBrowseTable() {
    // TODO(developer): Replace these variables before running the sample.
    String table = "MY_TABLE_NAME";
    String dataset = "MY_DATASET_NAME";
    browseTable(dataset, table);
  }

  public static void browseTable(String dataset, String table) {
    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 table itself
      TableId tableId = TableId.of(dataset, table);

      // Page over 100 records. If you don't need pagination, remove the pageSize parameter.
      TableResult result = bigquery.listTableData(tableId, TableDataListOption.pageSize(100));

      // Print the records
      result
          .iterateAll()
          .forEach(
              row -> {
                row.forEach(fieldValue -> System.out.print(fieldValue.toString() + ", "));
                System.out.println();
              });

      System.out.println("Query ran successfully");
    } catch (BigQueryException e) {
      System.out.println("Query failed to run \n" + e.toString());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Die Cloud-Clientbibliothek für Node.js erstellt Seitenumbrüche standardmäßig automatisch. Deshalb müssen Sie die Seitenumbrüche nicht selbst einfügen. Beispiel:


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

async function browseRows() {
  // Displays rows from "my_table" in "my_dataset".

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

  // List rows in the table
  const [rows] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .getRows();

  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

PHP

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery PHP API.

Das Erstellen von Seitenumbrüchen erfolgt in den Cloud-Clientbibliotheken für PHP automatisch mit der Generatorfunktion rows. Diese ruft im Verlauf der Iteration die nächste Seite mit Ergebnissen ab.

use Google\Cloud\BigQuery\BigQueryClient;

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

$maxResults = 10;
$startIndex = 0;

$options = [
    'maxResults' => $maxResults,
    'startIndex' => $startIndex
];
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$numRows = 0;
foreach ($table->rows($options) as $row) {
    print('---');
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, $value);
    }
    $numRows++;
}

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur  Python API.


from google.cloud import bigquery

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

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

# Download all rows from a table.
rows_iter = client.list_rows(table_id)  # Make an API request.

# Iterate over rows to make the API requests to fetch row data.
rows = list(rows_iter)
print("Downloaded {} rows from table {}".format(len(rows), table_id))

# Download at most 10 rows.
rows_iter = client.list_rows(table_id, max_results=10)
rows = list(rows_iter)
print("Downloaded {} rows from table {}".format(len(rows), table_id))

# Specify selected fields to limit the results to certain columns.
table = client.get_table(table_id)  # Make an API request.
fields = table.schema[:2]  # First two columns.
rows_iter = client.list_rows(table_id, selected_fields=fields, max_results=10)
rows = list(rows_iter)
print("Selected {} columns from table {}.".format(len(rows_iter.schema), table_id))
print("Downloaded {} rows from table {}".format(len(rows), table_id))

# Print row data in tabular format.
rows = client.list_rows(table, max_results=10)
format_string = "{!s:<16} " * len(rows.schema)
field_names = [field.name for field in rows.schema]
print(format_string.format(*field_names))  # Prints column headers.
for row in rows:
    print(format_string.format(*row))  # Prints row data.

Ruby

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Ruby in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

Das Erstellen von Seitenumbrüchen erfolgt in den Cloud-Clientbibliotheken für Ruby automatisch mit Table#data und Data#next.

require "google/cloud/bigquery"

def browse_table
  bigquery = Google::Cloud::Bigquery.new project_id: "bigquery-public-data"
  dataset  = bigquery.dataset "samples"
  table    = dataset.table "shakespeare"

  # Load all rows from a table
  rows = table.data

  # Load the first 10 rows
  rows = table.data max: 10

  # Print row data
  rows.each { |row| puts row }
end

Tabellendaten abfragen

Nachdem Sie Ihre Daten in BigQuery geladen haben, können Sie die Daten in Ihren Tabellen abfragen. BigQuery unterstützt zwei Arten von Abfragen:

BigQuery verwendet standardmäßig interaktive Abfragen. Dies bedeutet, dass die Abfrage so bald wie möglich ausgeführt wird.

Außerdem sind in BigQuery Batch-Abfragen möglich. BigQuery stellt jede Batch-Abfrage in Ihrem Namen in die Warteschlange und startet sie, sobald Ressourcen verfügbar sind – meist innerhalb von ein paar Minuten.

Sie können interaktive Abfragen und Batchabfragen mit den folgenden Tools ausführen:

Weitere Informationen zum Abfragen von BigQuery-Tabellen finden Sie unter Einführung in das Abfragen von BigQuery-Daten.

Sie können nicht nur Daten, die in BigQuery-Tabellen gespeichert sind, sondern auch extern gespeicherte Daten abfragen. Weitere Informationen finden Sie unter Einführung in externe Datenquellen.

Tabellendaten anfügen und überschreiben

Sie haben die Möglichkeit, Tabellendaten mit einem Lade- oder Abfragevorgang zu überschreiben. Sie können zusätzliche Daten an eine vorhandene Tabelle anfügen. Dazu führen Sie einen Lade-/Anfügevorgang aus oder fügen Abfrageergebnisse an die Tabelle an.

Weitere Informationen zum Anfügen oder Überschreiben einer Tabelle beim Laden von Daten finden Sie in der Dokumentation zu Ihrem Quelldatenformat:

Wenn Sie Abfrageergebnissen an eine Tabelle anfügen oder sie damit überschreiben möchten, geben Sie eine Zieltabelle an und legen Sie die Schreibanforderung auf eine dieser Optionen fest:

  • Append to table (An Tabelle anfügen): Die Abfrageergebnisse werden an eine vorhandene Tabelle angefügt.
  • Overwrite table (Tabelle überschreiben): Eine vorhandene Tabelle mit demselben Namen wird mit den Abfrageergebnissen überschrieben.

Weitere Informationen zum Verwenden von Abfrageergebnissen zum Anfügen oder Überschreiben von Daten finden Sie unter Abfrageergebnisse schreiben.

Tabellendaten ändern

Verwenden Sie den SQL-Standarddialekt, um Daten in einer Tabelle mit DML-Anweisungen zu ändern. Mit DML-Anweisungen können Sie Zeilen im Bulk aktualisieren, einfügen und löschen. Beispiele zum Verwenden von DML finden Sie unter Tabellendaten mit der Datenbearbeitungssprache aktualisieren.

Legacy-SQL unterstützt keine DML-Anweisungen. Sie müssen die Tabelle löschen und anschließend mit den neuen Daten neu erstellen, um Daten mit Legacy-SQL-Dialekt zu aktualisieren oder zu löschen. Alternativ können Sie eine Abfrage schreiben, die die Daten ändert und die Abfrageergebnisse in eine neue Zieltabelle schreibt.

Tabellendaten kopieren

So können Sie eine Tabelle kopieren:

  • Mit der Cloud Console
  • Mit dem Befehl bq cp des bq-Befehlszeilentools
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines Kopierjobs
  • Mit den Clientbibliotheken

Weitere Informationen zum Kopieren von Tabellen finden Sie unter Tabelle kopieren.

Tabellendaten exportieren

Sie können Tabellendaten in einen Cloud Storage-Bucket im CSV-, JSON-, Avro- oder Parquet-Format (Vorschau) exportieren. Der Export auf Ihre lokale Maschine wird nicht unterstützt. Sie können jedoch mit der Cloud Console Abfrageergebnisse herunterladen und speichern.

Weitere Informationen finden Sie unter Tabellendaten exportieren.

Weitere Informationen