crea tabelle BigLake di Cloud Storage

Questo documento descrive come creare una tabella BigLake di Cloud Storage. Una tabella BigLake consente di utilizzare delega dell'accesso per eseguire query su dati strutturati in Cloud Storage. Accesso delega disaccoppia l'accesso alla tabella BigLake dall'accesso al datastore sottostante.

Prima di iniziare

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  3. Attiva BigQuery Connection API.

    Abilita l'API

    Se vuoi leggere le tabelle BigLake da motori open source come Apache Spark, devi abilitare API BigQuery Storage Read.

  4. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  5. Assicurati di avere un set di dati BigQuery.

  6. Assicurati che la versione di Google Cloud SDK sia 366.0.0 o successiva:

    gcloud version

    Se necessario, aggiornare Google Cloud SDK.

    1. (Facoltativo) Per Terraform, terraform-provider-google versione 4.25.0 o in un secondo momento. terraform-provider-google release sono elencate in GitHub. Puoi scaricare l'ultima versione di Terraform da Download di hashiCorp Terraform.

  7. Crea una connessione alle risorse Cloud in base all'origine dati esterna e concedi la connessione per accedere a Cloud Storage. Se non hai le autorizzazioni appropriate per creare una connessione, chiedi l'amministratore BigQuery per creare una connessione e la condividiamo con te.

Ruoli obbligatori

Per creare una tabella BigLake, è necessario quanto segue Autorizzazioni IAM (Identity and Access Management) di BigQuery:

  • bigquery.tables.create
  • bigquery.connections.delegate

L'amministratore BigQuery (roles/bigquery.admin) predefinito Il ruolo Identity and Access Management include queste autorizzazioni.

Se non sei un'entità con questo ruolo, chiedi all'amministratore per concederti l'accesso o per creare la tabella BigLake per te.

Per ulteriori informazioni su ruoli e autorizzazioni di Identity and Access Management in BigQuery, vedi Ruoli e ruoli predefiniti autorizzazioni.

Considerazione della località

Quando utilizzi Cloud Storage per archiviare i file di dati, puoi migliorare delle prestazioni usando Cloud Storage una sola regione o nei bucket a due regioni anziché bucket multiregionali.

Creazione di tabelle BigLake su dati non partizionati

Se hai dimestichezza con la creazione di tabelle in BigQuery, il processo di creare una tabella BigLake è simile. La tabella può utilizzare qualsiasi formato file supportato da BigLake. Per ulteriori informazioni, vedi Limitazioni.

Prima di creare una tabella BigLake, devi avere un oggetto set di dati e una risorsa Cloud connessione che possono accedere a Cloud Storage.

Per creare una tabella BigLake, seleziona una delle seguenti opzioni:

Console

  1. Vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.

  3. Espandi Azioni e fai clic su Crea tabella.

  4. Nella sezione Origine, specifica i seguenti dettagli:

    1. Per Crea tabella da, seleziona Google Cloud Storage

    2. In Seleziona un file dal bucket GCS o usa un pattern URI, vai a seleziona il bucket e il file da utilizzare oppure digita il percorso nel formato gs://bucket_name/[folder_name/]file_name.

      Non puoi specificare più URI nella console Google Cloud, ma puoi selezionare più file specificando un asterisco (*) carattere jolly. Ad esempio, gs://mybucket/file_name*. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

      Bucket Cloud Storage deve trovarsi nella stessa posizione del set di dati che contiene la tabella che stai creando.

    3. In Formato file, seleziona il formato corrispondente al tuo file.

  5. Nella sezione Destinazione, specifica i seguenti dettagli:

    1. In Progetto, scegli il progetto in cui creare la tabella.

    2. In Set di dati, scegli il set di dati in cui creare la tabella.

    3. In Tabella, inserisci il nome della tabella che stai creando.

    4. Per Tipo di tabella, seleziona Tabella esterna.

    5. Seleziona Crea una tabella BigLake utilizzando una connessione a una risorsa cloud.

    6. In ID connessione, seleziona la connessione creata in precedenza.

  6. Nella sezione Schema, puoi abilitare il rilevamento automatico dello schema o specificare manualmente se hai un file di origine. Se non hai un file di origine, devi specificare manualmente uno schema.

    • Per attivare il rilevamento automatico dello schema, seleziona l'opzione Rilevamento automatico.

    • Per specificare manualmente uno schema, lascia l'opzione Rilevamento automatico deselezionata. Attiva Modifica come testo e inserisci lo schema della tabella come Array JSON.

  7. Per ignorare le righe con valori di colonna aggiuntivi che non corrispondono allo schema, espandi la sezione Opzioni avanzate e seleziona Valori sconosciuti.

  8. Fai clic su Crea tabella.

Dopo aver creato la tabella permanente, puoi eseguire una query sulla tabella come se si trattasse di una tabella BigQuery nativa. Dopo la query puoi esportare i risultati file CSV o JSON, salva i risultati come tabella o salva i risultati in Fogli Google.

SQL

Utilizza la CREATE EXTERNAL TABLE Istruzione DDL. Puoi specificare lo schema in modo esplicito o utilizzare rilevamento automatico dello schema per dedurre lo schema dai dati esterni.

  1. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nell'editor query, inserisci la seguente istruzione:

    CREATE EXTERNAL TABLE `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME`
  WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID`
  OPTIONS (
    format ="TABLE_FORMAT",
    uris = ['BUCKET_PATH'[,...]],
    max_staleness = STALENESS_INTERVAL,
    metadata_cache_mode = 'CACHE_MODE'
    );

    Sostituisci quanto segue:

    • PROJECT_ID: il nome del tuo progetto in cui vuoi creare la tabella, ad esempio myproject
    • DATASET: il nome del Set di dati BigQuery in cui vuoi creare la tabella ad esempio, mydataset
    • EXTERNAL_TABLE_NAME: il nome della tabella che vuoi creare, ad esempio mytable
    • REGION: la regione che contiene connessione, ad esempio us
    • CONNECTION_ID: l'ID connessione per esempio, myconnection

      Quando visualizzi i dettagli della connessione nella console Google Cloud, l'ID connessione è il valore riportato nell'ultima sezione ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.

    • TABLE_FORMAT: il formato della tabella che che vuoi creare, ad esempio PARQUET

      Per ulteriori informazioni sui formati supportati, consulta Limitazioni.

    • BUCKET_PATH: il percorso bucket Cloud Storage che contiene i dati per una tabella esterna, nel formato ['gs://bucket_name/[folder_name/]file_name'].

      Puoi selezionare più file dal bucket specificando un asterisco (*) carattere jolly nel percorso. Ad esempio, ['gs://mybucket/file_name*']. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

      Puoi specificare più bucket per l'opzione uris fornendo più percorsi di addestramento.

      I seguenti esempi mostrano valori uris validi:

      • ['gs://bucket/path1/myfile.csv']
      • ['gs://bucket/path1/*.csv']
      • ['gs://bucket/path1/*', 'gs://bucket/path2/file00*']

      Se specifichi i valori uris che hanno come target più file, questi i file devono condividere uno schema compatibile.

      Per ulteriori informazioni sull'utilizzo degli URI Cloud Storage in per BigQuery, consulta Percorso della risorsa di Cloud Storage.

    • STALENESS_INTERVAL: specifica se I metadati memorizzati nella cache vengono utilizzati dalle operazioni su BigLake tabella e l'aggiornamento dei metadati memorizzati nella cache affinché l'operazione usarla. Per ulteriori informazioni sulle considerazioni sulla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

      Per abilitare la memorizzazione nella cache dei metadati, specifica valore letterale intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

    • CACHE_MODE: specifica se i metadati la cache viene aggiornata automaticamente o manualmente. Per ulteriori informazioni considerazioni sulla memorizzazione nella cache dei metadati, Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Imposta il valore AUTOMATIC affinché la cache dei metadati venga vengono aggiornati a un intervallo definito dal sistema, solitamente compreso tra 30 e 60 minuti.

      Imposta su MANUAL se vuoi aggiornare dei metadati in base a una pianificazione determinata da te. In questo caso, puoi chiamare la procedura di sistema di BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare la cache.

      Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore maggiore di 0.

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Opzione 1: file di definizione della tabella

Usa il comando bq mkdef per creare un file di definizione della tabella, quindi passare il percorso del file il comando bq mk come segue:

bq mkdef \
    --connection_id=CONNECTION_ID \
    --source_format=SOURCE_FORMAT \
  BUCKET_PATH > DEFINITION_FILE

bq mk --table \
    --external_table_definition=DEFINITION_FILE \
    --max_staleness=STALENESS_INTERVAL \
    PROJECT_ID:DATASET.EXTERNAL_TABLE_NAME \
    SCHEMA

Sostituisci quanto segue:

  • CONNECTION_ID: l'ID connessione per esempio, myconnection

    Quando visualizzi i dettagli della connessione nella console Google Cloud, l'ID connessione è il valore riportato nell'ultima sezione ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.

  • SOURCE_FORMAT: il formato dell'origine dati esterna. Ad esempio, PARQUET.

  • BUCKET_PATH: il percorso bucket Cloud Storage che contiene i dati per nel formato gs://bucket_name/[folder_name/]file_pattern.

    Puoi selezionare più file dal bucket specificando un asterisco (*) carattere jolly nel campo file_pattern. Ad esempio: gs://mybucket/file00*.parquet. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

    Puoi specificare più bucket per l'opzione uris fornendo più percorsi di addestramento.

    I seguenti esempi mostrano valori uris validi:

    • gs://bucket/path1/myfile.csv
    • gs://bucket/path1/*.parquet
    • gs://bucket/path1/file1*, gs://bucket1/path1/*

    Se specifichi i valori uris che hanno come target più file, questi i file devono condividere uno schema compatibile.

    Per ulteriori informazioni sull'utilizzo degli URI Cloud Storage in per BigQuery, consulta Percorso della risorsa di Cloud Storage.

  • DEFINITION_FILE: il percorso file di definizione della tabella sul tuo computer locale.

  • STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni nella tabella BigLake l'aggiornamento dei metadati memorizzati nella cache affinché l'operazione usarla. Per ulteriori informazioni sulle considerazioni sulla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

    Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

    Per abilitare la memorizzazione nella cache dei metadati, specifica un intervallo di valori compreso tra 30 minuti e 7 giorni, utilizzando Y-M D H:M:S descritto in Tipo di dati INTERVAL documentazione. Ad esempio, specifica 0-0 0 4:0:0 per un 4 di inattività di ora. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

  • DATASET: il nome del Set di dati BigQuery in cui vuoi creare una tabella ad esempio, mydataset

  • EXTERNAL_TABLE_NAME: il nome della tabella che vuoi creare, ad esempio mytable

  • SCHEMA: lo schema per Tabella BigLake

Esempio:

bq mkdef
    --connection_id=myconnection
    --metadata_cache_mode=CACHE_MODE
    --source_format=CSV 'gs://mybucket/*.csv' > mytable_def

bq mk
    --table
    --external_table_definition=mytable_def='gs://mybucket/*.csv'
    --max_staleness=0-0 0 4:0:0
    myproject:mydataset.mybiglaketable
    Region:STRING,Quarter:STRING,Total_sales:INTEGER

Per utilizzare il rilevamento automatico dello schema, imposta il flag --autodetect=true nella mkdef e ometti lo schema:

bq mkdef \
    --connection_id=myconnection \
    --metadata_cache_mode=CACHE_MODE \
    --source_format=CSV --autodetect=true \
    gs://mybucket/*.csv > mytable_def

bq mk \
    --table \
    --external_table_definition=mytable_def=gs://mybucket/*.csv \
    --max_staleness=0-0 0 4:0:0 \
    myproject:mydataset.myexternaltable

Opzione 2: definizione di una tabella incorporata

Anziché creare un file di definizione della tabella, puoi passare il file direttamente nel comando bq mk. Usa il decorator @connection per specificare la connessione da utilizzare alla fine. del --external_table_definition.

bq mk --table \
  --external_table_definition=@SOURCE_FORMAT=BUCKET_PATH@projects/PROJECT_ID/locations/REGION/connections/CONNECTION_ID \
  DATASET_NAME.TABLE_NAME \
  SCHEMA

Sostituisci quanto segue:

  • SOURCE_FORMAT: il formato dell'origine dati esterna

    Ad esempio, CSV.

  • BUCKET_PATH: il percorso bucket Cloud Storage che contiene i dati per nel formato gs://bucket_name/[folder_name/]file_pattern.

    Puoi selezionare più file dal bucket specificando un asterisco (*) carattere jolly nel campo file_pattern. Ad esempio: gs://mybucket/file00*.parquet. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

    Puoi specificare più bucket per l'opzione uris fornendo più percorsi di addestramento.

    I seguenti esempi mostrano valori uris validi:

    • gs://bucket/path1/myfile.csv
    • gs://bucket/path1/*.parquet
    • gs://bucket/path1/file1*, gs://bucket1/path1/*

    Se specifichi i valori uris che hanno come target più file, questi i file devono condividere uno schema compatibile.

    Per ulteriori informazioni sull'utilizzo degli URI Cloud Storage in per BigQuery, consulta Percorso della risorsa di Cloud Storage.

  • PROJECT_ID: il nome del tuo progetto in cui vuoi creare la tabella, ad esempio myproject

  • REGION: la regione che contiene connessione, us

  • CONNECTION_ID: l'ID connessione per esempio, myconnection

    Quando visualizzi i dettagli della connessione nella console Google Cloud, l'ID connessione è il valore riportato nell'ultima sezione ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.

  • DATASET_NAME: il nome del set di dati in cui vuoi creare la tabella BigLake

  • TABLE_NAME: il nome della tabella BigLake

  • SCHEMA: lo schema per Tabella BigLake

Esempio:

bq mk --table \
    --external_table_definition=@CSV=gs://mybucket/*.parquet@projects/myproject/locations/us/connections/myconnection \
    --max_staleness=0-0 0 4:0:0 \
    myproject:mydataset.myexternaltable \
    Region:STRING,Quarter:STRING,Total_sales:INTEGER

API

Chiama il metodo tables.insert API e crea un'istanza ExternalDataConfiguration nella risorsa Table che trasmetti.

Specifica la proprietà schema o imposta la proprietà Proprietà autodetect in true per attivare il rilevamento automatico dello schema per e origini dati supportate.

Specifica la proprietà connectionId per identificare la connessione da utilizzare per la connessione a Cloud Storage.

Terraform

Questo esempio crea una tabella BigLake su dati non partizionati.

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

# This creates a bucket in the US region named "my-bucket" with a pseudorandom suffix.
resource "random_id" "default" {
  byte_length = 8
}
resource "google_storage_bucket" "default" {
  name                        = "my-bucket-${random_id.default.hex}"
  location                    = "US"
  force_destroy               = true
  uniform_bucket_level_access = true
}

# This queries the provider for project information.
data "google_project" "project" {}

# This creates a connection in the US region named "my-connection".
# This connection is used to access the bucket.
resource "google_bigquery_connection" "default" {
  connection_id = "my-connection"
  location      = "US"
  cloud_resource {}
}

# This grants the previous connection IAM role access to the bucket.
resource "google_project_iam_member" "default" {
  role    = "roles/storage.objectViewer"
  project = data.google_project.project.id
  member  = "serviceAccount:${google_bigquery_connection.default.cloud_resource[0].service_account_id}"
}

# This makes the script wait for seven minutes before proceeding.
# This lets IAM permissions propagate.
resource "time_sleep" "default" {
  create_duration = "7m"

  depends_on = [google_project_iam_member.default]
}

# This defines a Google BigQuery dataset with
# default expiration times for partitions and tables, a
# description, a location, and a maximum time travel.
resource "google_bigquery_dataset" "default" {
  dataset_id                      = "my_dataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "My dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  # This defines a map of labels for the bucket resource,
  # including the labels "billing_group" and "pii".
  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}


# This creates a BigQuery Table with automatic metadata caching.
resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "my_table"
  schema = jsonencode([
    { "name" : "country", "type" : "STRING" },
    { "name" : "product", "type" : "STRING" },
    { "name" : "price", "type" : "INT64" }
  ])
  external_data_configuration {
    # This defines an external data configuration for the BigQuery table
    # that reads Parquet data from the publish directory of the default
    # Google Cloud Storage bucket.
    autodetect    = false
    source_format = "PARQUET"
    connection_id = google_bigquery_connection.default.name
    source_uris   = ["gs://${google_storage_bucket.default.name}/data/*"]
    # This enables automatic metadata refresh.
    metadata_cache_mode = "AUTOMATIC"
  }

  # This sets the maximum staleness of the metadata cache to 10 hours.
  max_staleness = "0-0 0 10:0:0"

  deletion_protection = false

  depends_on = [time_sleep.default]
}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

  1. Avvia Cloud Shell.

  2. Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.

    Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Le variabili di ambiente vengono sostituite se imposti valori espliciti in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory dedicata (inoltre chiamato modulo principale).

  1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome file deve contenere i caratteri .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf. 
    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

    Copia il codice campione nel nuovo oggetto main.tf.

    Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

  3. Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
  4. Salva le modifiche.
  5. Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory. 
    terraform init

    Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade : 

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative: 
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

  2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta: 
    terraform apply

    Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". per creare un nuovo messaggio email.

  3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

BigLake supporta il rilevamento automatico dello schema. Tuttavia, se non fornisci uno schema e all'account di servizio non è stato concesso l'accesso nella sessione passaggi non riusciti e viene visualizzato un messaggio di accesso negato se provi a rilevare automaticamente lo schema.

Creazione di tabelle BigLake su dati partizionati Hive

Puoi creare una tabella BigLake per i dati partizionati di Hive in di archiviazione ideale in Cloud Storage. Dopo aver creato una tabella partizionata esternamente, non possono cambiare la chiave di partizione. Devi ricreare la tabella per modificare di partizione.

Per creare una tabella BigLake basata su dati partizionati da Hive in Cloud Storage, seleziona una delle opzioni seguenti:

Console

  1. Vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.

  3. Fai clic su Visualizza azioni, e poi fai clic su Crea tabella. Viene visualizzato il riquadro Crea tabella.

  4. Nella sezione Origine, specifica i seguenti dettagli:

    1. Per Crea tabella da, seleziona Google Cloud Storage.

    2. Specifica il percorso della cartella utilizzando caratteri jolly. Ad esempio, my_bucket/my_files*. La cartella deve trovarsi nella stessa posizione del set di dati che contiene e la tabella che desideri creare, aggiungere o sovrascrivere.

    3. Seleziona il tipo di file dall'elenco Formato file.

    4. Seleziona la casella di controllo Partizionamento dei dati di origine e specifica i seguenti dettagli:

      1. In Seleziona prefisso URI di origine, inserisci il Prefisso URI. Ad esempio, gs://my_bucket/my_files.
      2. (Facoltativo) Per richiedere un filtro di partizionamento su tutte le query per questo seleziona la casella di controllo Richiedi filtro di partizione. La richiesta di un filtro di partizionamento può ridurre i costi e migliorare delle prestazioni. Per ulteriori informazioni, vedi Richiedere filtri dei predicati sulle chiavi di partizione nelle query.

      3. Nella sezione Modalità di inferenza della partizione, seleziona una delle le seguenti opzioni:

        • Induce automaticamente i tipi: imposta lo schema di partizione modalità di rilevamento su AUTO.
        • Tutte le colonne sono stringhe: imposta lo schema di partizione modalità di rilevamento su STRINGS.
        • Fornisci personale: imposta la modalità di rilevamento dello schema di partizione su CUSTOM e inserisci manualmente lo schema le informazioni per le chiavi di partizione. Per ulteriori informazioni, vedi Fornisci uno schema della chiave di partizione personalizzato.

  5. Nella sezione Destinazione, specifica i seguenti dettagli:

    1. In Progetto, seleziona il progetto in cui vuoi creare nella tabella.
    2. In Set di dati, seleziona il set di dati in cui creare nella tabella.
    3. In Tabella, inserisci il nome della tabella che ti interessa. per creare.
    4. Per Tipo di tabella, seleziona Tabella esterna.
    5. Seleziona Crea una tabella BigLake utilizzando una risorsa cloud connessione.
    6. In ID connessione, seleziona la connessione che hai creato. in precedenza.

  6. Nella sezione Schema, puoi abilitare il rilevamento automatico dello schema o specificare manualmente se hai un file di origine. Se non hai un file di origine, devi specificare manualmente uno schema.

    • Per attivare il rilevamento automatico dello schema, seleziona l'opzione Rilevamento automatico.

    • Per specificare manualmente uno schema, lascia l'opzione Rilevamento automatico deselezionata. Attiva Modifica come testo e inserisci lo schema della tabella come Array JSON.

  7. Per ignorare le righe con valori di colonna aggiuntivi che non corrispondono allo schema, espandi la sezione Opzioni avanzate e seleziona Valori sconosciuti.

  8. Fai clic su Crea tabella.

SQL

Utilizza la CREATE EXTERNAL TABLE Istruzione DDL:

  1. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nell'editor query, inserisci la seguente istruzione:

    CREATE EXTERNAL TABLE `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME`
WITH PARTITION COLUMNS
(
  PARTITION_COLUMN PARTITION_COLUMN_TYPE,
)
WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID`
OPTIONS (
  hive_partition_uri_prefix = "HIVE_PARTITION_URI_PREFIX",
  uris=['FILE_PATH'],
  max_staleness = STALENESS_INTERVAL,
  metadata_cache_mode = 'CACHE_MODE',
  format ="TABLE_FORMAT"
);

    Sostituisci quanto segue:

    • PROJECT_ID: il nome del tuo progetto in cui vuoi creare la tabella, ad esempio myproject
    • DATASET: il nome del Set di dati BigQuery in cui vuoi creare la tabella ad esempio, mydataset
    • EXTERNAL_TABLE_NAME: il nome della tabella che vuoi creare, ad esempio mytable
    • PARTITION_COLUMN: il nome del colonna di partizionamento
    • PARTITION_COLUMN_TYPE: il tipo di colonna di partizionamento
    • REGION: la regione che contiene connessione, ad esempio us
    • CONNECTION_ID: l'ID connessione per esempio, myconnection

      Quando visualizzi i dettagli della connessione nella console Google Cloud, l'ID connessione è il valore riportato nell'ultima sezione ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.

    • HIVE_PARTITION_URI_PREFIX: partizionamento hive uri prefisso, ad esempio gs://mybucket/
    • FILE_PATH: percorso dell'origine dati per il tabella esterna che vuoi creare, ad esempio gs://mybucket/*.parquet
    • STALENESS_INTERVAL: specifica se I metadati memorizzati nella cache vengono utilizzati dalle operazioni su BigLake tabella e l'aggiornamento dei metadati memorizzati nella cache affinché l'operazione usarla. Per ulteriori informazioni sulle considerazioni sulla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

      Per abilitare la memorizzazione nella cache dei metadati, specifica valore letterale intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

    • CACHE_MODE: specifica se i metadati la cache viene aggiornata automaticamente o manualmente. Per ulteriori informazioni sulle considerazioni sulla memorizzazione nella cache dei metadati, Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Imposta il valore AUTOMATIC affinché la cache dei metadati venga vengono aggiornati a un intervallo definito dal sistema, solitamente compreso tra 30 e 60 minuti.

      Imposta su MANUAL se vuoi aggiornare dei metadati in base a una pianificazione determinata da te. In questo caso, puoi chiamare la procedura di sistema di BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare la cache.

      Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore maggiore di 0.

    • TABLE_FORMAT: il formato della tabella che che vuoi creare, ad esempio PARQUET

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

Esempi

L'esempio seguente crea una tabella BigLake sopra partizionati dove:

  • Lo schema viene rilevato automaticamente.
  • L'intervallo di inattività della cache dei metadati per la tabella è di 1 giorno.
  • La cache dei metadati si aggiorna automaticamente.
CREATE EXTERNAL TABLE `my_dataset.my_table`
WITH PARTITION COLUMNS
(
  sku STRING,
)
WITH CONNECTION `us.my-connection`
OPTIONS(
  hive_partition_uri_prefix = "gs://mybucket/products",
  uris = ['gs://mybucket/products/*'],
  max_staleness = INTERVAL 1 DAY,
  metadata_cache_mode = 'AUTOMATIC'
);

L'esempio seguente crea una tabella BigLake sopra partizionati dove:

  • Lo schema è specificato.
  • L'intervallo di inattività della cache dei metadati per la tabella è di 8 ore.
  • La cache dei metadati deve essere aggiornata manualmente.
CREATE EXTERNAL TABLE `my_dataset.my_table`
(
  ProductId INTEGER,
  ProductName STRING,
  ProductType STRING
)
WITH PARTITION COLUMNS
(
  sku STRING,
)
WITH CONNECTION `us.my-connection`
OPTIONS(
  hive_partition_uri_prefix = "gs://mybucket/products",
  uris = ['gs://mybucket/products/*'],
  max_staleness = INTERVAL 8 HOUR,
  metadata_cache_mode = 'MANUAL'
);

bq

Per prima cosa, utilizza Comando bq mkdef per crea un file di definizione della tabella:

bq mkdef \
--source_format=SOURCE_FORMAT \
--connection_id=REGION.CONNECTION_ID \
--hive_partitioning_mode=PARTITIONING_MODE \
--hive_partitioning_source_uri_prefix=GCS_URI_SHARED_PREFIX \
--require_hive_partition_filter=BOOLEAN \
--metadata_cache_mode=CACHE_MODE \
 GCS_URIS > DEFINITION_FILE

Sostituisci quanto segue:

  • SOURCE_FORMAT: il formato dei dati esterni sorgente. Ad esempio, CSV.
  • REGION: la regione che contiene connessione attiva, ad esempio us.

  • CONNECTION_ID: l'ID connessione per ad esempio myconnection.

    Quando visualizzi i dettagli della connessione nella console Google Cloud, l'ID connessione è il valore riportato nell'ultima sezione ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.

  • PARTITIONING_MODE: la modalità di partizionamento di Hive. Utilizza uno dei seguenti i seguenti valori:

    • AUTO: rileva automaticamente i nomi e i tipi di chiavi.
    • STRINGS: converti automaticamente i nomi delle chiavi in stringhe.
    • CUSTOM: codifica lo schema della chiave nel prefisso dell'URI di origine.

  • GCS_URI_SHARED_PREFIX: il prefisso dell'URI di origine.

  • BOOLEAN: specifica se richiedere un filtro per i predicati nella query nel tempo. Questo flag è facoltativo. Il valore predefinito è false.

  • CACHE_MODE: specifica se i metadati la cache viene aggiornata automaticamente o manualmente. Devi solo includere questo se prevedi di usare anche il flag --max_staleness nella successivo comando bq mk per abilitare la memorizzazione nella cache dei metadati. Per maggiori informazioni informazioni sulla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

    Imposta il valore AUTOMATIC affinché la cache dei metadati venga vengono aggiornati a un intervallo definito dal sistema, solitamente compreso tra 30 e 60 minuti.

    Imposta su MANUAL se vuoi aggiornare dei metadati in base a una pianificazione determinata da te. In questo caso, puoi chiamare il Procedura di sistema di BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare la cache.

    Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore maggiore di 0.

  • GCS_URIS: il percorso della cartella Cloud Storage, utilizzando carattere jolly.

  • DEFINITION_FILE: il percorso file di definizione della tabella sul tuo in una macchina virtuale.

Se PARTITIONING_MODE è CUSTOM, includi lo schema della chiave di partizione nel prefisso dell'URI di origine, utilizzando il seguente formato:

--hive_partitioning_source_uri_prefix=GCS_URI_SHARED_PREFIX/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Dopo aver creato il file di definizione della tabella, utilizza il metodo Comando bq mk per crea la tabella BigLake:

bq mk --external_table_definition=DEFINITION_FILE \
--max_staleness=STALENESS_INTERVAL \
DATASET_NAME.TABLE_NAME \
SCHEMA

Sostituisci quanto segue:

  • DEFINITION_FILE: il percorso del file di definizione della tabella.

  • STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni nella tabella BigLake l'aggiornamento dei metadati memorizzati nella cache affinché l'operazione usarla. Se includi questo flag, devi aver specificato anche un valore per il flag --metadata_cache_mode nella Comando bq mkdef. Per ulteriori informazioni sui metadati considerazioni sulla memorizzazione nella cache, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

    Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

    Per abilitare la memorizzazione nella cache dei metadati, specifica un intervallo di valori compreso tra 30 minuti e 7 giorni, utilizzando Y-M D H:M:S descritto in Tipo di dati INTERVAL documentazione. Ad esempio, specifica 0-0 0 4:0:0 per un 4 di inattività di ora. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

  • DATASET_NAME: il nome del set di dati che contiene tabella.

  • TABLE_NAME: il nome della tabella che stai creando.

  • SCHEMA: specifica un percorso a un File di schema JSON, o specifica lo schema nella forma field:data_type,field:data_type,.... Per utilizzare lo schema rilevamento automatico, ometti questo argomento.

Esempi

L'esempio seguente utilizza la modalità di partizionamento Hive AUTO e anche imposta la cache dei metadati in modo che abbia un intervallo di inattività di 12 ore e aggiornate automaticamente:

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=AUTO \
  --hive_partitioning_source_uri_prefix=gs://myBucket/myTable \
  --metadata_cache_mode=AUTOMATIC \
  gs://myBucket/myTable/* > mytable_def

bq mk --external_table_definition=mytable_def \
  --max_staleness=0-0 0 12:0:0 \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

L'esempio seguente utilizza la modalità di partizionamento Hive STRING:

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=STRING \
  --hive_partitioning_source_uri_prefix=gs://myBucket/myTable \
  gs://myBucket/myTable/* > mytable_def

bq mk --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

L'esempio seguente utilizza la modalità di partizionamento Hive CUSTOM:

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=CUSTOM \
  --hive_partitioning_source_uri_prefix=gs://myBucket/myTable/{dt:DATE}/{val:STRING} \
  gs://myBucket/myTable/* > mytable_def

bq mk --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

API

Per impostare il partizionamento Hive utilizzando l'API BigQuery, includi il comando hivePartitioningOptions in ExternalDataConfiguration quando crei il file di definizione della tabella. Per creare una tabella BigLake, devi anche specificare un valore per il campo connectionId.

Se imposti il campo hivePartitioningOptions.mode su CUSTOM, devi codificare lo schema della chiave di partizione hivePartitioningOptions.sourceUriPrefix come segue: gs://BUCKET/PATH_TO_TABLE/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Per applicare l'utilizzo di un filtro per i predicati in fase di query, imposta il valore hivePartitioningOptions.requirePartitionFilter su true.

Terraform

Questo esempio crea una tabella BigLake su dati partizionati.

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.


# This creates a bucket in the US region named "my-bucket" with a pseudorandom
# suffix.
resource "random_id" "default" {
  byte_length = 8
}
resource "google_storage_bucket" "default" {
  name                        = "my-bucket-${random_id.default.hex}"
  location                    = "US"
  force_destroy               = true
  uniform_bucket_level_access = true
}

resource "google_storage_bucket_object" "default" {
  # This creates a fake message to create partition locations on the table.
  # Otherwise, the table deployment fails.
  name    = "publish/dt=2000-01-01/hr=00/min=00/fake_message.json"
  content = "{\"column1\": \"XXX\"}"
  bucket  = google_storage_bucket.default.name
}

# This queries the provider for project information.
data "google_project" "default" {}

# This creates a connection in the US region named "my-connection".
# This connection is used to access the bucket.
resource "google_bigquery_connection" "default" {
  connection_id = "my-connection"
  location      = "US"
  cloud_resource {}
}

# This grants the previous connection IAM role access to the bucket.
resource "google_project_iam_member" "default" {
  role    = "roles/storage.objectViewer"
  project = data.google_project.default.id
  member  = "serviceAccount:${google_bigquery_connection.default.cloud_resource[0].service_account_id}"
}

# This makes the script wait for seven minutes before proceeding. This lets IAM
# permissions propagate.
resource "time_sleep" "default" {
  create_duration = "7m"

  depends_on = [google_project_iam_member.default]
}

# This defines a Google BigQuery dataset with default expiration times for
# partitions and tables, a description, a location, and a maximum time travel.
resource "google_bigquery_dataset" "default" {
  dataset_id                      = "my_dataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "My dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  # This defines a map of labels for the bucket resource,
  # including the labels "billing_group" and "pii".
  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

# This creates a BigQuery table with partitioning and automatic metadata
# caching.
resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "my_table"
  schema     = jsonencode([{ "name" : "column1", "type" : "STRING", "mode" : "NULLABLE" }])
  external_data_configuration {
    # This defines an external data configuration for the BigQuery table
    # that reads Parquet data from the publish directory of the default
    # Google Cloud Storage bucket.
    autodetect    = false
    source_format = "PARQUET"
    connection_id = google_bigquery_connection.default.name
    source_uris   = ["gs://${google_storage_bucket.default.name}/publish/*"]
    # This configures Hive partitioning for the BigQuery table,
    # partitioning the data by date and time.
    hive_partitioning_options {
      mode                     = "CUSTOM"
      source_uri_prefix        = "gs://${google_storage_bucket.default.name}/publish/{dt:STRING}/{hr:STRING}/{min:STRING}"
      require_partition_filter = false
    }
    # This enables automatic metadata refresh.
    metadata_cache_mode = "AUTOMATIC"
  }


  # This sets the maximum staleness of the metadata cache to 10 hours.
  max_staleness = "0-0 0 10:0:0"

  deletion_protection = false

  depends_on = [
    time_sleep.default,
    google_storage_bucket_object.default
  ]
}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

  1. Avvia Cloud Shell.

  2. Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.

    Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Le variabili di ambiente vengono sostituite se imposti valori espliciti in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory dedicata (inoltre chiamato modulo principale).

  1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome file deve contenere i caratteri .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf. 
    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

    Copia il codice campione nel nuovo oggetto main.tf.

    Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

  3. Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
  4. Salva le modifiche.
  5. Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory. 
    terraform init

    Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade : 

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative: 
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

  2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta: 
    terraform apply

    Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". per creare un nuovo messaggio email.

  3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

Configura i criteri di controllo dell'accesso

Puoi utilizzare diversi metodi per controllare l'accesso alle tabelle BigLake:

Ad esempio, supponiamo che tu voglia limitare l'accesso alle righe per la tabella mytable nel set di dati mydataset:

+---------+---------+-------+
| country | product | price |
+---------+---------+-------+
| US      | phone   |   100 |
| JP      | tablet  |   300 |
| UK      | laptop  |   200 |
+---------+---------+-------+

Puoi creare un filtro a livello di riga per Kim (kim@example.com) che limita il suo accesso alle righe dove country è uguale a US.

CREATE ROW ACCESS POLICY only_us_filter
ON mydataset.mytable
GRANT TO ('user:kim@example.com')
FILTER USING (country = 'US');

Quindi, Kim esegue la query seguente:

SELECT * FROM projectid.mydataset.mytable;

L'output mostra solo le righe dove country è uguale a US:

+---------+---------+-------+
| country | product | price |
+---------+---------+-------+
| US      | phone   |   100 |
+---------+---------+-------+

Esegui query su tabelle BigLake

Per ulteriori informazioni, vedi Eseguire query sui dati di Cloud Storage nelle tabelle BigLake.

Aggiorna tabelle BigLake

Se necessario, puoi aggiornare le tabelle BigLake, ad esempio per cambia il loro memorizzazione nella cache dei metadati. Per ottenere dettagli della tabella come il formato e l'URI di origine, consulta Recuperare informazioni sulla tabella.

Puoi utilizzare questa stessa procedura anche per eseguire l'upgrade delle Cloud Storage tabelle esterne alle tabelle BigLake associando le tabelle esterne a una connessione. Per ulteriori informazioni, vedi Esegui l'upgrade delle tabelle esterne a tabelle BigLake.

Per aggiornare una tabella BigLake, seleziona una delle le seguenti opzioni:

SQL

Utilizza la CREATE OR REPLACE EXTERNAL TABLE Istruzione DDL per aggiornare una tabella:

  1. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nell'editor query, inserisci la seguente istruzione:

    CREATE OR REPLACE EXTERNAL TABLE
  `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME`
  WITH CONNECTION `REGION.CONNECTION_ID`
  OPTIONS(
    format ="TABLE_FORMAT",
    uris = ['BUCKET_PATH'],
    max_staleness = STALENESS_INTERVAL,
    metadata_cache_mode = 'CACHE_MODE'
    );

    Sostituisci quanto segue:

    • PROJECT_ID: il nome del progetto che contiene la tabella
    • DATASET: il nome del set di dati che contiene la tabella
    • EXTERNAL_TABLE_NAME: il nome del tavola
    • REGION: la regione che contiene connessione
    • CONNECTION_ID: il nome della connessione per utilizzare
    • TABLE_FORMAT: il formato utilizzato dalla tabella

      Non puoi modificare questa impostazione durante l'aggiornamento della tabella.

    • BUCKET_PATH: il percorso bucket Cloud Storage che contiene i dati per una tabella esterna, nel formato ['gs://bucket_name/[folder_name/]file_name'].

      Puoi selezionare più file dal bucket specificando un asterisco (*) carattere jolly nel percorso. Ad esempio, ['gs://mybucket/file_name*']. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

      Puoi specificare più bucket per l'opzione uris fornendo più percorsi di addestramento.

      I seguenti esempi mostrano valori uris validi:

      • ['gs://bucket/path1/myfile.csv']
      • ['gs://bucket/path1/*.csv']
      • ['gs://bucket/path1/*', 'gs://bucket/path2/file00*']

      Se specifichi i valori uris che hanno come target più file, questi i file devono condividere uno schema compatibile.

      Per ulteriori informazioni sull'utilizzo degli URI Cloud Storage in per BigQuery, consulta Percorso della risorsa di Cloud Storage.

    • STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella e l'aggiornamento dei metadati memorizzati nella cache affinché l'operazione usalo

      Per ulteriori informazioni sulle considerazioni sulla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

      Per abilitare la memorizzazione nella cache dei metadati, specifica valore letterale intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

    • CACHE_MODE: specifica se i metadati La cache viene aggiornata automaticamente o manualmente

      Per ulteriori informazioni considerazioni sulla memorizzazione nella cache dei metadati, Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Imposta il valore AUTOMATIC affinché la cache dei metadati venga vengono aggiornati a un intervallo definito dal sistema, solitamente compreso tra 30 e 60 minuti.

      Imposta su MANUAL se vuoi aggiornare dei metadati in base a una pianificazione determinata da te. In questo caso, puoi chiamare la procedura di sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare nella cache.

      Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore maggiore di 0.

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Utilizza i bq mkdef e Comandi bq update per aggiornare una tabella:

  1. Genera un definizione di una tabella esterna che descrive gli aspetti della tabella da modificare:

    bq mkdef --connection_id=PROJECT_ID.REGION.CONNECTION_ID \
--source_format=TABLE_FORMAT \
--metadata_cache_mode=CACHE_MODE \
"BUCKET_PATH" > /tmp/DEFINITION_FILE

    Sostituisci quanto segue:

    • PROJECT_ID: il nome del progetto che contiene la connessione
    • REGION: la regione che contiene connessione
    • CONNECTION_ID: il nome della connessione per utilizzare
    • TABLE_FORMAT: il formato utilizzato tabella. Non puoi modificare questa impostazione durante l'aggiornamento della tabella.

    • CACHE_MODE: specifica se i metadati la cache viene aggiornata automaticamente o manualmente. Per ulteriori informazioni considerazioni sulla memorizzazione nella cache dei metadati, Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Imposta AUTOMATIC per aggiornare la cache dei metadati in un definito dal sistema, di solito tra 30 e 60 minuti.

      Imposta su MANUAL se desideri aggiornare la cache dei metadati su una il piano di controllo da te determinato. In questo caso, puoi chiamare il metodo Procedura di sistema di BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare nella cache.

      Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore di 0.

    • BUCKET_PATH: il percorso bucket Cloud Storage che contiene i dati per una tabella esterna, nel formato gs://bucket_name/[folder_name/]file_name.

      Puoi limitare i file selezionati dal bucket specificando un asterisco (*) carattere jolly nel percorso. Ad esempio, gs://mybucket/file_name*. Per maggiori informazioni le informazioni, vedi Supporto dei caratteri jolly per gli URI Cloud Storage.

      Puoi specificare più bucket per l'opzione uris fornendo più percorsi di addestramento.

      I seguenti esempi mostrano valori uris validi:

      • gs://bucket/path1/myfile.csv
      • gs://bucket/path1/*.csv
      • gs://bucket/path1/*,gs://bucket/path2/file00*

      Se specifichi i valori uris che hanno come target più file, questi i file devono condividere uno schema compatibile.

      Per ulteriori informazioni sull'utilizzo degli URI Cloud Storage in per BigQuery, consulta Percorso della risorsa di Cloud Storage.

    • DEFINITION_FILE: il nome della tabella di definizione del file che stai creando.

  2. Aggiorna la tabella utilizzando la nuova definizione della tabella esterna:

    bq update --max_staleness=STALENESS_INTERVAL \
--external_table_definition=/tmp/DEFINITION_FILE \
PROJECT_ID:DATASET.EXTERNAL_TABLE_NAME

    Sostituisci quanto segue:

    • STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni e il grado di attualità dei metadati memorizzati nella cache per l'operazione per utilizzarlo. Per ulteriori informazioni sui metadati considerazioni sulla memorizzazione nella cache, consulta Memorizzazione nella cache dei metadati per migliorare le prestazioni.

      Per disabilitare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

      Per abilitare la memorizzazione nella cache dei metadati, specifica un intervallo di valori compreso tra 30 minuti e 7 giorni, utilizzando Y-M D H:M:S descritto in Tipo di dati INTERVAL documentazione. Ad esempio, specifica 0-0 0 4:0:0 per un 4 di inattività di ora. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se è stato aggiornato nelle ultime 4 ore. Se i metadati memorizzati nella cache sia precedente, l'operazione recupera i metadati Cloud Storage.

    • DEFINITION_FILE: il nome della tabella di definizione che hai creato o aggiornato.

    • PROJECT_ID: il nome del progetto che contiene la tabella

    • DATASET: il nome del set di dati che contiene la tabella

    • EXTERNAL_TABLE_NAME: il nome della tabella

Esempio

L'esempio seguente aggiorna mytable in modo che utilizzi i metadati memorizzati nella cache, a condizione che sia stato aggiornato nelle ultime 4, 5 ore e anche di aggiornare automaticamente i metadati:

bq update --project_id=myproject --max_staleness='0-0 0 4:30:0' \
--external_table_definition=enable_metadata.json mydataset.mytable

Dove enable_metadata.json presenta i seguenti contenuti: { "metadataCacheMode": "AUTOMATIC" }

Audit logging

Per informazioni sul logging in BigQuery, consulta Introduzione alle Monitoraggio di BigQuery. Per scoprire di più sul logging in Google Cloud, consulta Cloud Logging.

Passaggi successivi