Erstellen eines DataSet

Datensatz erstellen

# [demo]Erstellen Sie ein DataSet mit dem Namen
dataset_name = "demo"
dataset_id = "{}.{}".format(client.project, dataset_name)

dataset = bigquery.Dataset(dataset_id)
#USA ist der billigste Ort, deshalb benutze ich diesen immer.Wenn Sie sich für die Region interessieren, ändern Sie diese bitte
dataset.location = "US"

client.create_dataset(dataset) 

Referenz: Verwalten von Datensätzen

Tabellenbetrieb

Informationen zum Erstellen einer Tabelle und zum Laden von Daten in die Tabelle

--Tabelle erstellen --Überprüfen Sie die Tabelle --Datenimport in Tabelle --Datenexport aus Tabelle

• Tabelle löschen

Wenn Sie die offizielle Referenz lesen, ist im Grunde alles geschrieben, aber gut. .. .. Jep. .. .. Sie können es in Qiita schreiben. .. ..

-Referenz- Managing Tables Verwenden Sie Anweisungen zur Datendefinitionssprache (https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language?hl=ja).

Eine Tabelle erstellen

Hier beschreiben wir ein Codebeispiel unter der Annahme, dass wir eine Kaufverlaufstabelle für die folgenden Produkte erstellen.

• Ignorieren Sie Feld 10, wenn Sie keine verschachtelten Informationen verarbeiten möchten

Erstellen Sie eine Tabellendefinition (erstellen Sie ein Schema)

BigQuery liest die Definition einer Tabelle als Schema

Daher werden verschiedene Definitionen in die Methode von "bigquery.SchemaField" eingefügt.

Feldname und -typ können nicht weggelassen werden

Tag-Informationen werden in einem verschachtelten Format definiert

from google.cloud import bigquery

#Schema definieren
schema = [
    bigquery.SchemaField('TRANSACTION_ID', 'STRING', mode='REQUIRED', description='Kaufhistorie ID'),
    bigquery.SchemaField('ORDER_TS', 'TIMESTAMP', mode='REQUIRED', description='Kaufzeit'),
    bigquery.SchemaField('ORDER_DT', 'DATE', mode='REQUIRED', description='Kaufdatum'),
    bigquery.SchemaField('ITEM_CODE', 'STRING', mode='REQUIRED', description='Produkt ID'),
    bigquery.SchemaField('ITEM_NAME', 'STRING', mode='NULLABLE', description='Produktname'),
    bigquery.SchemaField('QUANTITY', 'INTEGER', mode='NULLABLE', description='Kaufmenge'),
    bigquery.SchemaField('AMOUNT', 'FLOAT', mode='NULLABLE', description='Kaufpreis'),
    bigquery.SchemaField('DISCOUNT', 'FLOAT', mode='NULLABLE', description='Rabattbetrag'),
    bigquery.SchemaField('CUSTOMER_ID', 'STRING', mode='NULLABLE', description='Kundennummer'),
    
    bigquery.SchemaField('ITEM_TAG', 'RECORD', mode='REPEATED', description='Tag-Informationen', 
                         fields= [
                         bigquery.SchemaField('TAG_ID', 'STRING', mode='NULLABLE', description='Tag ID'),
                         bigquery.SchemaField('TAG_NAME', 'STRING', mode='NULLABLE', description='Verlinke den Namen'),
                         ]
                         )
]

Erstellen Sie tatsächlich eine Tabelle

Nach dem Erstellen des Schemas besteht der nächste Schritt darin, die Tabelle tatsächlich zu erstellen

Neben dem Schema sind weitere Faktoren zu berücksichtigen

• Tabelle teilen (Wenn Sie Daten über 2000 Tage speichern möchten, ist es besser, die Tabelle nicht zu teilen.)
• Machen Sie es zu einer Cluster-Tabelle (beachten Sie, dass es nur auf geteilte Tabellen angewendet werden kann)

Wovon ich beim Erstellen einer geteilten Tabelle mit BigQuery süchtig war

Dieses Mal erstellen wir eine Tabelle als Split & Cluster-Tabelle

Tabelle erstellen

from google.cloud import bigquery

# project_id = 'YourProjectID'
# client = bigquery.Client(project=project_id)
# dataset_name = "demo"
# dataset_id = "{}.{}".format(client.project, dataset_name)

#Entscheiden Sie sich für einen Tabellennamen
table_name = "demo_transaction"
table_id = "{}.{}.{}".format(client.project, dataset_id, table_name)

#Verwenden Sie das oben definierte Schema
table = bigquery.Table(table_id, schema=schema)

#Tabelleneinstellungen teilen(Hier BESTELLEN_DT)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="ORDER_DT"
)
#Cluster-Tabelleneinstellungen
table.clustering_fields = ["ITEM_CODE", "CUSTOMER_ID"]
table.description = "Demo Data"

#Tabellenerstellung ausführen
table = client.create_table(table)

Wenn Sie es auf der Konsole im Web überprüfen, können Sie sehen, dass es so definiert ist

Überprüfen Sie die Tabellenliste

Gibt an, ob der DataSet-Name bestätigt oder das DataSet-Objekt angegeben werden soll, um die Liste der Tabellen zu überprüfen Kann bei bestätigt werden

# [demo]Überprüfen Sie die Tabelle im DataSet

#Muster zum Überprüfen des Tabellennamens durch Angabe des DataSet-Namens
dataset_id = "demo"
for table in client.list_tables(dataset=dataset_id):
  print(table.table_id)

#Zu überprüfendes Muster durch Angabe eines DataSet-Objekts
dataset_object = client.get_dataset("demo")
for table in client.list_tables(dataset=dataset_object):
  print(table.table_id)

Laden von Daten in eine Tabelle

Datenwissenschaftler importieren / exportieren häufig Daten, daher möchte ich dies auch verstehen.

• Lokale Datei importieren
• Lesen Sie CSV
• Lesen Sie JSON
• GCS-Datei importieren

Lokale Datei importieren

Beschreiben Sie das Muster, in dem die Datei in CSV gespeichert ist, und die beiden Muster, in denen sie in JSON gespeichert ist.

CSV-Datei lesen

Ich denke, es ist üblich, Daten in CSV-Dateien zu speichern, daher folge ich diesem Muster. CSV kann jedoch nicht verwendet werden, da verschachtelte Informationen in einer Tabelle mit verschachtelten Feldern nicht in CSV ausgedrückt werden können.

Versuchen Sie, einen Tabellennamen, der keine verschachtelten Informationen enthält, als "demo_transaciton" zu laden

CSV importieren

#Geben Sie die lokale Datei an
filename = 'demo_transaction.csv'

#Datensatzname
detaset_id = "demo"
#Zu importierender Tabellenname
table_id = "demo_transaction_csv"
dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)

#Einstellungen für den Import
job_config = bigquery.LoadJobConfig()
#Geben Sie an, dass CSV die Quelle ist
job_config.source_format = bigquery.SourceFormat.CSV
#Überspringen Sie die erste Zeile, wenn die Datei Überschriften enthält
job_config.skip_leading_rows = 1

with open(filename, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_ref, job_config=job_config)

#Lauf
job.result()

Übrigens, wenn aus irgendeinem Grund ein Fehler auftritt, überprüfen Sie den Inhalt des Fehlers mit job.errors und laden Sie ihn neu.

JSON-Datei lesen

Importieren Sie mit json eine Tabelle mit verschachtelten Daten

Das Format, das von json importiert werden kann, ist festgelegt, und es ist erforderlich, Daten in Form der Beurteilung eines Datensatzes nach Zeilenumbruch zu enthalten, wie unten gezeigt

JSON-Format

{"TRANSACTION_ID":"t0001","ORDER_TS":"2019-11-02 12:00:00 UTC","ORDER_DT":"2019-11-02","ITEM_CODE":"ITEM001","ITEM_NAME":"YYYYY1","QUANTITY":"29","AMOUNT":2200,"DISCOUNT":0,"CUSTOMER_ID":"F0002","ITEM_TAG":[{"TAG_ID":"XXX1", "TAG_NAME":"XYZ1"},{"TAG_ID":"XXX2", "TAG_NAME":"XYZ2"}]}
{"TRANSACTION_ID":"t0002","ORDER_TS":"2019-11-03 12:00:00 UTC","ORDER_DT":"2019-11-03","ITEM_CODE":"ITEM002","ITEM_NAME":"YYYYY2","QUANTITY":"35","AMOUNT":5700,"DISCOUNT":0,"CUSTOMER_ID":"F0002","ITEM_TAG":[]}
{"TRANSACTION_ID":"t0003","ORDER_TS":"2019-11-04 12:00:00 UTC","ORDER_DT":"2019-11-04","ITEM_CODE":"ITEM003","ITEM_NAME":"YYYYY3","QUANTITY":"48","AMOUNT":4200,"DISCOUNT":0,"CUSTOMER_ID":"F0002","ITEM_TAG":[{"TAG_ID":"XXX3", "TAG_NAME":"XYZ3"}]}

Wenn sich in einem solchen Zustand jsonisierte Daten befinden, kann die lokale Datei wie folgt importiert werden

Json importieren

#Geben Sie den lokalen Dateinamen an
filename = 'demo_transaction.json'

#Datensatzname
detaset_id = "demo"
#Tabellenname mit verschachtelten Informationen
table_id = "demo_transaction"
dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)

job_config = bigquery.LoadJobConfig()
#Ich werde Ihnen sagen, dass json die Originaldatei ist
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON

with open(filename, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_ref, job_config=job_config)

#Lauf
job.result()

Da es sich um verschachtelte Daten handelt, sieht es übrigens so aus, wenn es auf der Konsole angezeigt wird

-Referenz- Kern: Probieren Sie Google BigQuery JSON Input Lightly aus

GCS-Datei importieren

Es gibt Zeiten, in denen Daten als lokale Datei in BigQuery importiert werden. Da jedoch GCP verwendet wird, ist es besser, GCS vollständig zu nutzen.

Überprüfen Sie daher, wie die Daten in GCS importiert werden

Es ist schön, dass Sie keine GCS-bezogenen Bibliotheken aufrufen müssen, solange Sie den Pfad der in GCS gespeicherten Datei kennen

Beispiel unter der Annahme, dass die CSV-Datei in die Tabelle demo_transaction_csv importiert wird ↓

Laden von GCS

#Geben Sie den Datensatz- und Tabellennamen an
detaset_id = "demo"
table_id = "demo_transaction_csv"
dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)

#Da CSV geladen ist, verschiedene Einstellungen
job_config = bigquery.LoadJobConfig()
job_config.skip_leading_rows = 1
job_config.source_format = bigquery.SourceFormat.CSV

#Geben Sie den Pfad an, in dem sich die GCS-Datei befindet
uri = "gs://{yourbacketname}/demo_transaction.csv"

#Job generieren
load_job = client.load_table_from_uri(
    uri, table_ref, job_config=job_config
) 

#Last ausführen
load_job.result()

(Vielleicht böse) Schieben Sie DataFrame mit Pandas-Funktion in BQ

Obwohl es sich nicht um eine offizielle API-Funktion handelt, können Sie die Daten von pd.DataFrame auch mit der Funktion auf der Pandas-Seite in die BigQuery-Tabelle einfügen.

Es ist möglich, es zusätzlich in die vorhandene Tabelle einzufügen, aber ich glaube, dass es häufig verwendet wird, um den DataFrame nach verschiedenen Verarbeitungen als neue Tabelle zu exportieren.

Ziehen Sie beispielsweise einen Teil der zuvor erstellten Daten von demo.demo_transaction_csv heraus und schreiben Sie sie als weitere Tabelle aus.

to_Exportieren Sie DataFrame mit gbq

#Bereiten Sie eine Abfrage vor, um einen Teil der Daten abzurufen
query = """
    SELECT 
        TRANSACTION_ID
        , ORDER_TS
        , ITEM_CODE
        , QUANTITY
        , AMOUNT
        
    FROM 
        `{YourProjectID}.demo.demo_transaction_csv` 
    LIMIT 200
    ;
    """
#Abfragejob generieren
query_job = client.query(
    query, location='US'
)

#Ergebnisse in einem Datenrahmen empfangen
df = query_job.to_dataframe()

#Datenrahmen[demo_transaciton_csv_extracted]Exportieren Sie mit dem Namen
# if_exists:append ->Wenn bereits eine Tabelle vorhanden ist, fügen Sie sie hinzu. Wenn nicht, erstellen Sie eine neue
# if_exists:fail ->Fehler, wenn bereits eine Tabelle vorhanden ist, erstellen Sie eine neue, wenn nicht
# if_exists:replace ->Wenn bereits eine Tabelle vorhanden ist, ersetzen Sie diese. Wenn nicht, erstellen Sie eine neue

detaset_id = "demo"
table_id = "demo_transaciton_csv_extracted"

df.to_gbq(destination_table='{dataset}.{table}'.format(dataset=dataset_id, table=table_id),project_id=project_id, if_exists='append')

Stellen Sie sicher, dass der Import funktioniert

Überprüfen Sie, ob die Tabelle Daten enthält

detaset_id = "demo"
dataset_ref = client.dataset(dataset_id)

table_id = "demo_transaciton_csv_extracted"
table_ref = dataset_ref.table(table_id)
table = client.get_table(table_ref)
print("Table has {} rows".format(table.num_rows))

> Table has 200 rows

Importieren Sie pd.DataFrame-Daten mit nativer API-Funktionalität

Ich habe zuerst die böse Methode geschrieben, aber es ist auch möglich, einen DataFrame mit API einzufügen

Kann ausgeführt werden, ohne das Schema im Beispielcode zu definieren

pd.DataFrame importieren

import pandas as pd

detaset_id = "demo"
dataset_ref = client.dataset(dataset_id)

table_id = "demo_pandas_data"
table_ref = dataset_ref.table(table_id)

#Passenderweise pd.Erstellen Sie DataFrame-Daten
rows = [
    {"item_id": "xx1", "quantity": 1},
    {"item_id": "xx2", "quantity": 2},
    {"item_id": "xx3", "quantity": 3},
]

dataframe = pd.DataFrame(
    rows,
    columns=["item_id", "quantity"]
)

#Schema definieren(Sie können ohne es importieren, aber es ist sicherer, es zu schreiben)
job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("item_id", "STRING"),
        bigquery.SchemaField("quantity", "INTEGER"),
    ],
)

# pd.Speichern Sie DataFrame-Daten in einer Tabelle
job = client.load_table_from_dataframe(
    dataframe,
    table_ref,
    job_config=job_config,
    location="US",
)
#Lauf
job.result()

Importieren Sie vorhandene Tabellendaten

Evilly zieht Daten aus einer vorhandenen Tabelle über DataFrame und schreibt sie als neue Tabelle, aber im Grunde möchte ich sie mit offiziellen Funktionen implementieren

• Extrahieren Sie die Informationen der vorhandenen Tabelle mithilfe der API-Funktion und schreiben Sie sie neu --Schreiben Sie eine neue direkt in die Abfrage

Schreiben Sie Abfrageergebnisse mit nativer API-Funktionalität

Geben Sie beim Schreiben mit der API-Funktion einfach einen neuen Tabellennamen in "QueryJobConfig.destination" an.

**einfach! !! !! ** ** **

Schreiben Sie Abfrageergebnisse, indem Sie eine Schreibtabelle angeben

#Jobkonfiguration generieren
job_config = bigquery.QueryJobConfig()

detaset_id = "demo"
dataset_ref = client.dataset(dataset_id)

#Definieren Sie den Tabellennamen, in den geschrieben werden soll
table_id = "demo_transaciton_csv_direct_extracted"
table_ref = dataset_ref.table(table_id)

# (wichtig)Geben Sie die Schreibzieltabelle an
job_config.destination = table_ref

#Definieren Sie die Abfrage, in die geschrieben werden soll
query = """
    SELECT 
        TRANSACTION_ID
        , ORDER_TS
        , ITEM_CODE
        , QUANTITY
        , AMOUNT
    FROM 
        `{YourProjectID}.demo.demo_transaction_csv` 
    LIMIT 300
    ;
    """

#Abfragejob generieren
query_job = client.query(
    query,
    location="US",
    job_config=job_config,
)

#Lauf
query_job.result()

Durch Abfrage erstelltes Muster (CREATE TABLE [TABLE_NAME] AS SELECT)

Ich bin der Meinung, dass das Muster zum Definieren einer neuen Tabelle mit "QueryJobConfig.destination" ausreichend ist, aber ich folge auch der bekannten Methode (CREATE TABLE ~ AS SELECT).

Immerhin benutze ich es unerwartet. .. ..

Erstellen Sie eine neue Tabelle mit einer Abfrage

detaset_id = "demo"
#Definieren Sie den Tabellennamen, in den geschrieben werden soll
table_id = "demo_transaciton_csv_as_select"

#Definieren Sie die Abfrage, in die geschrieben werden soll
query = """
    DROP TABLE IF EXISTS {dataset}.{table} ;
    CREATE TABLE {dataset}.{table} AS 
    SELECT 
        TRANSACTION_ID
        , ORDER_TS
        , ITEM_CODE
        , QUANTITY
        , AMOUNT
        
    FROM 
        `{YourProjectID}.demo.demo_transaction_csv` 
    LIMIT 400
    ;
    """.format(dataset=dataset_id, table=table_id)

#Abfragejob generieren
job_config = bigquery.QueryJobConfig()
query_job = client.query(
    query,
    location="US",
    job_config=job_config,
)

#Lauf(Natürlich wird nichts zurückgegeben, aber es ist richtig geschrieben)
query_job.result()

Dies sollte alle Möglichkeiten zum Importieren von Daten abdecken. .. ..

Erstellen einer geteilten Tabelle

BigQuery ist ein spaltenbasiertes Pay-as-you-go-Format

1. Auch wenn Sie "Limit" einstellen, ändert sich der Rechnungsbetrag nicht
2. Der Rechnungsbetrag ändert sich auch dann nicht, wenn Sie die Bedingungen mit "Wo" eingrenzen
3. Für jede weitere Spalte wird eine Gebühr erhoben

Es gibt eine Funktion im Dienst

Es spielt keine Rolle, solange das Datenvolumen klein ist (1 TB pro Monat ist für Abfragen kostenlos), aber wenn Sie mit Daten von mehreren zehn TB oder mehr arbeiten, müssen Sie vorsichtig sein.

Was soll ich dann tun?

1. ** Richten Sie eine geteilte Tabelle ein **
2. ** Clustertabelle einrichten **

Ist die grundlegende Bewältigungsmethode

Eine Tabelle mit mehreren TB Daten sollte immer einige Zeitreiheninformationen enthalten. Legen Sie diese Informationen daher als zu teilendes Feld fest und erstellen Sie eine geteilte Tabelle.

Beachten Sie, dass Sie es später nur ändern können, wenn Sie es beim Erstellen der Tabelle als geteilte Tabelle definieren.

-Referenz- Übersicht über partitionierte Tabellen

Muster zum Einfügen der Split-Option in die Tabellendefinition

Beschreiben Sie zunächst das Muster zum Festlegen der Aufteilungsoption in der Phase der Tabellenerstellung.

Legen Sie die Aufteilungsoptionen fest

#Beschreiben Sie die Tabellendefinition (Zeitreihenspalte ist erforderlich).
schema = [
    bigquery.SchemaField('TRANSACTION_ID', 'STRING', mode='REQUIRED', description='Kaufhistorie ID'),
    bigquery.SchemaField('ORDER_TS', 'TIMESTAMP', mode='REQUIRED', description='Kaufzeit'),
    bigquery.SchemaField('ORDER_DT', 'DATE', mode='REQUIRED', description='Kaufdatum'),
]

detaset_id = "demo"
table_id = "demo_transaction_time_partition1"
dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)

#Erstellung von Tabellenobjekten
table = bigquery.Table(table_ref, schema=schema)

#Legen Sie die Aufteilungsoptionen fest
table.time_partitioning = bigquery.TimePartitioning(
    #Geteilt nach Tag
    type_=bigquery.TimePartitioningType.DAY,
    #Legen Sie das Zielfeld fest
    field="ORDER_DT"
)
table.description = "Time Partition Data"

#Erstellen Sie eine geteilte Tabelle
table = client.create_table(table)

Durch Abfrage erstelltes Muster (CREATE TABLE [TABLE_NAME] AS SELECT)

Eine geteilte Tabelle kann auch aus einer vorhandenen Tabelle mit "CREATE TABLE [TABLE_NAME] AS SELECT" erstellt werden

Die beste Verwendung ist, wenn ** eine aufgeblähte Tabelle neu erstellt wird, die nicht als geteilte Tabelle festgelegt wurde **

OK, wenn Sie "PARTITION BY [Time Partition Field]" vor "AS SELECT" setzen

Tabellenerstellungsabfrage mit Split-Option

detaset_id = "demo"
#Definieren Sie den Tabellennamen, in den geschrieben werden soll
table_id = "demo_transaciton_csv_as_select_time_partition"

query = """
    DROP TABLE IF EXISTS {dataset}.{table} ;
    CREATE TABLE {dataset}.{table} 
    PARTITION BY
    ORDER_DT
    AS 
    SELECT 
        TRANSACTION_ID
        , ORDER_TS
        , ORDER_DT
        , ITEM_CODE
        , QUANTITY
        , AMOUNT
        
    FROM 
        `{YourProjectID}.demo.demo_transaction_csv` 
    LIMIT 500
    ;
    """.format(dataset=dataset_id, table=table_id)

#Abfragejob generieren
query_job = client.query(
    query,
    location="US"
)
#Lauf
query_job.result()

Einfach! !!

Erstellen einer Clustertabelle

Sie können weitere Clusterfelder in der geteilten Tabelle festlegen

In der Option der geteilten Tabelle wird nur das Clusterfeld angegeben, daher wird es extrahiert und beschrieben.

-Referenz- Erstellen und Verwenden von Clustertabellen (https://cloud.google.com/bigquery/docs/creating-clustered-tables?hl=ja)

Informationen zum Festlegen der Clusteroption finden Sie im Folgenden.

[BigQuery] Clustered Table Survey

Muster zum Einfügen von Clusteroptionen in die Tabellendefinition

Geben Sie zusätzliche Clusterfelder an

"""Die Clustertabelle muss eine geteilte Tabelle sein
table = bigquery.Table(table_ref, schema=schema)
table.time_partitioning = bigquery.TimePartitioning(
    type_=bigquery.TimePartitioningType.DAY,
    field="ORDER_DT"
)
"""
table.clustering_fields = ["ITEM_CODE", "CUSTOMER_ID"]

Durch Abfrage erstelltes Muster (CREATE TABLE [TABLE_NAME] AS SELECT)

Fügen Sie einfach die Cluster-Option "CLUSTER BY" hinzu, auch wenn Sie dies in SQL angeben

Auszug aus dem Clusteroption-Additionsteil

query = 
    """
    DROP TABLE IF EXISTS {dataset}.{table} ;
    CREATE TABLE {dataset}.{table} 
    PARTITION BY
    ORDER_DT
    CLUSTER BY
    ITEM_CODE, CUSTOMER_ID
    AS 
    SELECT 
        *
    FROM 
        `{YourProjectID}.demo.demo_transaction_csv` 
    LIMIT 500
    ;
    """.format(dataset=dataset_id, table=table_id)

Tabellendaten exportieren

Huh. .. .. Schließlich ist der Teil zum Ablegen der Daten beendet. .. ..

Als nächstes folgt der Exportteil, aber die Methode zum Exportieren der Tabelle selbst besteht im Wesentlichen darin, nach GCS zu exportieren

Export nach GCS

Exportieren Sie den Inhalt der Tabelle, indem Sie den GCS-Bucket angeben Wenn Sie nicht "job_config" angeben, wird es als CSV-Datei geschrieben.

Normalerweise ist es csv, daher können Tabellen mit verschachtelten Spalten nicht mit csv exportiert werden

Export im CSV-Format

#Geben Sie die zu exportierende Tabelle an
detaset_id = "demo"
dataset_ref = client.dataset(dataset_id)

table_id = "demo_transaciton_csv"
table_ref = dataset_ref.table(table_id)

#Datei im angegebenen Bucket speichern
bucket_name = "{Your Bucket Name}"
output_name = "{}.csv".format(table_id)
destination_uri = "gs://{}/{}".format(bucket_name, output_name)

#Exportauftrag generieren
extract_job = client.extract_table(
    table_ref,
    destination_uri,
    location="US",
)
#Lauf
extract_job.result()

Datei komprimieren und exportieren

Wenn Sie die Tabelle so exportieren, wie sie ist, ist die Datenmenge so groß wie sie ist. Daher möchte ich die Komprimierungsoption festlegen

Stellen Sie die Ausgabeoptionen mit "ExtractJobConfig" ein und komprimieren Sie sie

Sie können steuern, ob der Header exportiert werden soll, indem Sie die Option print_header festlegen (Standard ist True).

Komprimierungsoption hinzugefügt(Mit gzip komprimieren)

destination_uri = "gs://{YourBucket}/{filename}.gz"
job_config = bigquery.ExtractJobConfig(
  compression="GZIP",
  print_header=True
)

#Exportauftrag generieren
extract_job = client.extract_table(
    table_ref,
    destination_uri,
    job_config=job_config,
    location="US",
)

#Lauf
extract_job.result()

Exportieren Sie eine Tabelle mit verschachtelten Daten mit json (avro).

Wenn eine verschachtelte Spalte vorhanden ist, kann sie nicht mit csv exportiert werden. Exportieren Sie sie daher mit json oder avro.

json kann komprimiert werden, aber avro unterstützt keine Komprimierungsoptionen

Verschachtelte Tabellen in json oder Avro

output_name = "{}.json".format(table_id)
destination_uri = "gs://{}/{}".format(bucket_name, output_name)

#Exportieren mit json(Keine Header-Ausgabe)
job_config = bigquery.ExtractJobConfig(
  destination_format = "NEWLINE_DELIMITED_JSON",
  print_header = False
)

#Lauf
extract_job = client.extract_table(
    table_ref,
    destination_uri,
    job_config=job_config,
)

extract_job.result()

Export mit tsv

Der Standard ist übrigens csv, aber Sie können auch mit tsv exportieren

Stellen Sie die Option tsv ein

# job_Fügen Sie der Konfiguration die Option delimita hinzu
job_config = bigquery.ExtractJobConfig(
    field_delimiter="\t"
)

Tabelle löschen

Wenn Sie die Tabelle löschen möchten, geben Sie einfach den Tabellennamen an

Tabelle löschen

# from google.cloud import bigquery
# project_id = 'YourProjectID'
# client = bigquery.Client(project=project_id)

detaset_id = "{YourDataSetId}"
dataset_ref = client.dataset(dataset_id)

table_id = "{YourTableId}"
table_ref = dataset_ref.table(table_id)

#Tabelle löschen
client.delete_table(table_ref)

Dies ist das Ende der Geschichte rund um die Tabellenerstellung