Questa pagina è stata tradotta dall'API Cloud Translation.

Aggiornare le proprietà dei set di dati

Questo documento descrive come aggiornare le proprietà del set di dati in in BigQuery. Dopo aver creato un set di dati, puoi aggiornare le seguenti proprietà:

Controlli di accesso
Modello di fatturazione
Tempo di scadenza predefinito per le nuove tabelle
Scadenza della partizione predefinita per le nuove partizioni tabelle
Modalità di arrotondamento predefinita per le nuove tabelle
Descrizione
Etichette
Finestre di viaggio cronologico

Prima di iniziare

Concedi i ruoli IAM (Identity and Access Management) che concedono agli utenti le autorizzazioni necessarie per eseguire ogni attività in questo documento.

Autorizzazioni obbligatorie

Per aggiornare le proprietà dei set di dati, devi disporre delle seguenti autorizzazioni IAM:

bigquery.datasets.update
bigquery.datasets.setIamPolicy (obbligatorio solo per aggiornare i controlli di accesso ai set di dati nella console Google Cloud)

Il ruolo IAM predefinito di roles/bigquery.dataOwner include le autorizzazioni necessarie per aggiornare le proprietà del set di dati.

Inoltre, se disponi dell'autorizzazione bigquery.datasets.create, puoi aggiornare le proprietà dei set di dati che crei.

Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Aggiornare le descrizioni dei set di dati

Puoi aggiornare la descrizione di un set di dati nei seguenti modi:

Utilizzo della console Google Cloud.
Viene utilizzato il comando bq update dello strumento a riga di comando bq.
Chiamata al metodo dell'API datasets.patch.
Utilizzo delle librerie client.

Per aggiornare la descrizione di un set di dati:

Console

Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Espandi Azioni e fai clic su Apri.
Nel riquadro Dettagli, fai clic su Modifica dettagli per modificare il testo della descrizione.

Nella finestra di dialogo Modifica dettagli visualizzata:
1. Nel campo Descrizione, inserisci una descrizione oppure modificare la descrizione esistente.
2. Per salvare il nuovo testo della descrizione, fai clic su Salva.

SQL

Per aggiornare la descrizione di un set di dati, utilizza il metodo Dichiarazione ALTER SCHEMA SET OPTIONS per impostare l'opzione description.

L'esempio seguente imposta la descrizione su un set di dati denominato mydataset:

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, inserisci la seguente istruzione:

 ALTER SCHEMA mydataset
 SET OPTIONS (
     description = 'Description of mydataset');

Fai clic su Esegui.

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

bq

Esegui il comando bq update con il flag --description. Se aggiornare un set di dati in un progetto diverso da quello predefinito, aggiungi al nome del set di dati nel seguente formato: project_id:dataset.

bq update \
--description "string" \
project_id:dataset

Sostituisci quanto segue:

string: il testo che descrive il set di dati, tra virgolette
project_id: il tuo ID progetto
dataset: il nome del set di dati che stai aggiornando

Esempi:

Inserisci il comando seguente per modificare la descrizione di mydataset in "Descrizione del mioset didati." mydataset si trova nel tuo progetto predefinito.

bq update --description "Description of mydataset" mydataset

Inserisci il seguente comando per modificare la descrizione di mydataset in "Descrizione di mydataset". Il set di dati si trova in myotherproject, non nel tuo progetto predefinito.

bq update \
--description "Description of mydataset" \
myotherproject:mydataset

API

Chiama datasets.patch e aggiorna la proprietà description nel risorsa del set di dati. Poiché il metodo datasets.update sostituisce l'intera risorsa del set di dati, è preferibile il metodo datasets.patch.

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateDatasetDescription demonstrates how the Description metadata of a dataset can
// be read and modified.
func updateDatasetDescription(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.DatasetMetadataToUpdate{
		Description: "Updated Description.",
	}
	if _, err = ds.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Crea un'istanza Dataset.Builder da un'istanza Dataset esistente con il metodo Dataset.toBuilder(). Configura l'oggetto del generatore di set di dati. Crea il set di dati aggiornato con Dataset.Builder.build() e richiama il metodo Dataset.update() per inviare l'aggiornamento all'API.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;

public class UpdateDatasetDescription {

  public static void runUpdateDatasetDescription() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String newDescription = "this is the new dataset description";
    updateDatasetDescription(datasetName, newDescription);
  }

  public static void updateDatasetDescription(String datasetName, String newDescription) {
    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();

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDescription(newDescription).build());
      System.out.println("Dataset description updated successfully to " + newDescription);
    } catch (BigQueryException e) {
      System.out.println("Dataset description was not updated \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

async function updateDatasetDescription() {
  // Updates a dataset's description.

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Set new dataset description
  const description = 'New dataset description.';
  metadata.description = description;

  const [apiResponse] = await dataset.setMetadata(metadata);
  const newDescription = apiResponse.description;

  console.log(`${datasetId} description: ${newDescription}`);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Configura Dataset.description e richiama Client.update_dataset() per inviare l'aggiornamento all'API.


from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.
dataset.description = "Updated description."
dataset = client.update_dataset(dataset, ["description"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with description '{}'.".format(
        full_dataset_id, dataset.description
    )
)

Aggiorna le scadenze predefinite delle tabelle

Puoi aggiornare la scadenza predefinita della tabella di un set di dati nei seguenti modi:

Utilizzo della console Google Cloud.
Viene utilizzato il comando bq update dello strumento a riga di comando bq.
Chiamata al metodo dell'API datasets.patch.
Utilizzare le librerie client.

Puoi impostare una scadenza predefinita per le tabelle a livello di set di dati oppure puoi impostare la scadenza di una tabella al momento della sua creazione. Se imposti la scadenza quando viene creata la tabella, la scadenza predefinita della tabella del set di dati viene ignorata. Se non imposti una scadenza predefinita per le tabelle a livello del set di dati e non impostare una scadenza quando la tabella viene creata, non scadrà mai devi eliminare la tabella manualmente. Quando una tabella scade, viene eliminata insieme a tutti i dati che contiene.

Quando aggiorni l'impostazione della scadenza predefinita della tabella di un set di dati:

Se modifichi il valore da Never a una data e ora di scadenza definita, le tabelle che esistono già nel set di dati non scadranno, a meno che la data e ora di scadenza non sia stata impostata sulla tabella al momento della sua creazione.
Se modifichi il valore della scadenza predefinita della tabella, tutte le tabelle esistenti scadono in base all'impostazione originale della scadenza della tabella. Tutte le nuove tabelle create nel set di dati hanno la nuova impostazione di scadenza della tabella applicata a meno che non specifichi una scadenza diversa nella tabella quando è stato creato.

Il valore della scadenza predefinita della tabella viene espresso in modo diverso a seconda su dove viene impostato il valore. Utilizza il metodo che ti offre livello di granularità:

Nella console Google Cloud, la scadenza è espressa in giorni.
Nello strumento a riga di comando bq, la scadenza è espressa in secondi.
Nell'API, la scadenza è espressa in millisecondi.

Per aggiornare la data e l'ora di scadenza predefinite per un set di dati:

Console

Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Espandi l'opzione Azioni e fai clic su Apri.
Nel riquadro dei dettagli, fai clic sull'icona a forma di matita accanto a Informazioni sul set di dati per modificare la scadenza.
Nella finestra di dialogo Informazioni set di dati, nella sezione Scadenza tabella predefinita, inserisci un valore per Numero di giorni dopo la creazione della tabella.
Fai clic su Salva.

SQL

Per aggiornare la scadenza predefinita della tabella, utilizza l'istruzione ALTER SCHEMA SET OPTIONS per impostare l'opzione default_table_expiration_days.

L'esempio seguente aggiorna la scadenza predefinita della tabella per un set di dati denominato mydataset.

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor query, inserisci la seguente istruzione:

 ALTER SCHEMA mydataset
 SET OPTIONS(
     default_table_expiration_days = 3.75);

Fai clic su Esegui.

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

bq

Per aggiornare la scadenza predefinita per le tabelle appena create in un set di dati, inserisci il comando bq update con il flag --default_table_expiration. Se aggiorni un set di dati in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

bq update \
--default_table_expiration integer \
project_id:dataset

Sostituisci quanto segue:

integer: la durata predefinita, in secondi, per le tabelle appena create. Il valore minimo è 3600 secondi (un'ora). La La scadenza restituisce l'ora UTC attuale più il valore intero. Specifica 0 per rimuovere la data di scadenza esistente. Qualsiasi tabella creata nel set di dati viene eliminata integer secondi dopo la relativa ora di creazione. Questo valore viene applicato se non imposti una tabella scadrà quando la tabella viene creata.
project_id: il tuo ID progetto.
dataset: il nome del set di dati che stai aggiornamento in corso.

Esempi:

Inserisci il comando seguente per impostare la scadenza predefinita della tabella per nuove tabelle create in mydataset a due ore (7200 secondi) dal ora attuale. Il set di dati si trova nel tuo progetto predefinito.

bq update --default_table_expiration 7200 mydataset

Inserisci il seguente comando per impostare la scadenza predefinita delle nuove tabelle create in mydataset su due ore (7200 secondi) dall'ora corrente. Il set di dati si trova in myotherproject, non nel tuo progetto predefinito.

bq update --default_table_expiration 7200 myotherproject:mydataset

API

Chiama datasets.patch e aggiorna la proprietà defaultTableExpirationMs nel risorsa del set di dati. La scadenza è espressa in millisecondi nell'API. Poiché Il metodo datasets.update sostituisce l'intera risorsa del set di dati, È preferibile il metodo datasets.patch.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// updateDatasetDefaultExpiration demonstrats setting the default expiration of a dataset
// to a specific retention period.
func updateDatasetDefaultExpiration(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.DatasetMetadataToUpdate{
		DefaultTableExpiration: 24 * time.Hour,
	}
	if _, err := client.Dataset(datasetID).Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Crea un Dataset.Builder da un modello esistente Set di dati con l'editor di codice Dataset.toBuilder() . Configura l'oggetto del generatore di set di dati. Crea il set di dati aggiornato con il metodo Dataset.Builder.build() e chiama il metodo Dataset.update() per inviare l'aggiornamento all'API.

Configura la data e l'ora di scadenza predefinite con il metodo Dataset.Builder.setDefaultTableLifetime().

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.concurrent.TimeUnit;

public class UpdateDatasetExpiration {

  public static void runUpdateDatasetExpiration() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    updateDatasetExpiration(datasetName);
  }

  public static void updateDatasetExpiration(String datasetName) {
    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();

      // Update dataset expiration to one day
      Long newExpiration = TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDefaultTableLifetime(newExpiration).build());
      System.out.println("Dataset description updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Dataset expiration was not updated \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

async function updateDatasetExpiration() {
  // Updates the lifetime of all tables in the dataset, in milliseconds.

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

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Set new dataset metadata
  const expirationTime = 24 * 60 * 60 * 1000;
  metadata.defaultTableExpirationMs = expirationTime.toString();

  const [apiResponse] = await dataset.setMetadata(metadata);
  const newExpirationTime = apiResponse.defaultTableExpirationMs;

  console.log(`${datasetId} expiration: ${newExpirationTime}`);
}

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Configura la proprietà Dataset.default_table_expiration_ms e chiama Client.update_dataset() per inviare l'aggiornamento all'API.


from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.
dataset.default_table_expiration_ms = 24 * 60 * 60 * 1000  # In milliseconds.

dataset = client.update_dataset(
    dataset, ["default_table_expiration_ms"]
)  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset {} with new expiration {}".format(
        full_dataset_id, dataset.default_table_expiration_ms
    )
)

Aggiornare le scadenze predefinite delle partizioni

Puoi aggiornare la scadenza predefinita della partizione di un set di dati nei seguenti modi:

Viene utilizzato il comando bq update dello strumento a riga di comando bq.
Chiamata al metodo dell'API datasets.patch.
Utilizzare le librerie client.

L'impostazione o l'aggiornamento della scadenza predefinita della partizione di un set di dati non è attualmente supportata dalla console Google Cloud.

Puoi impostare una scadenza predefinita della partizione a livello di set di dati che influisce su tutte le tabelle partizionate appena create oppure puoi impostare una scadenza della partizione per le singole tabelle quando vengono create. Se imposti la scadenza predefinita della partizione a livello del set di dati e tu imposti la scadenza a livello del set di dati, le nuove tabelle partizionate avranno solo la scadenza della partizione. Se entrambe le opzioni sono impostate, la scadenza predefinita della partizione sostituisce la scadenza predefinita della tabella.

Se imposti la data e l'ora di scadenza della partizione quando viene creata la tabella partizionata, questo valore sostituisce la scadenza predefinita della partizione a livello di set di dati, se esistente.

Se non imposti una scadenza predefinita per la partizione a livello di set di dati non impostare una scadenza della partizione quando viene creata la tabella, partizioni non scadono mai e devi eliminarle manualmente.

Quando imposti una scadenza predefinita per la partizione in un set di dati, la scadenza si applica a tutte le partizioni di tutte le tabelle partizionate create nel set di dati. Quando imposti la scadenza della partizione in una tabella, la scadenza si applica a tutte le partizioni create nella tabella specificata. Al momento, non puoi applicare criteri a partizioni diverse nella stessa tabella.

Quando aggiorni l'impostazione della scadenza predefinita della partizione di un set di dati:

Se modifichi il valore da never a una data e ora di scadenza definita, le eventuali partizioni già esistenti nelle tabelle partizionate del set di dati non scadranno, a meno che la data e l'ora di scadenza della partizione non siano state impostate sulla tabella al momento della sua creazione.
Se modifichi il valore della scadenza predefinita della partizione, nelle tabelle partizionate esistenti scadono in base alla la scadenza predefinita della partizione. A tutte le nuove tabelle partizionate create nel set di dati viene applicata la nuova impostazione di scadenza della partizione predefinita, a meno che non specifichi una scadenza della partizione diversa per la tabella al momento della creazione.

Il valore per la scadenza della partizione predefinita viene espresso in modo diverso a seconda su dove viene impostato il valore. Utilizza il metodo che offre il livello di granularità appropriato:

Nello strumento a riga di comando bq, la scadenza è espressa in secondi.
Nell'API, la scadenza è espressa in millisecondi.

Per aggiornare la scadenza predefinita della partizione per un set di dati:

Console

L'aggiornamento della scadenza predefinita della partizione di un set di dati non è attualmente supportato dalla console Google Cloud.

SQL

Per aggiornare la scadenza predefinita delle partizioni, utilizza Dichiarazione ALTER SCHEMA SET OPTIONS per impostare l'opzione default_partition_expiration_days.

L'esempio seguente aggiorna la scadenza predefinita della partizione per set di dati denominato mydataset:

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor query, inserisci la seguente istruzione:

 ALTER SCHEMA mydataset
 SET OPTIONS(
     default_partition_expiration_days = 3.75);

Fai clic su Esegui.

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

bq

Per aggiornare la scadenza predefinita per un set di dati, inserisci bq update con il flag --default_partition_expiration. Se stai aggiornando un set di dati in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

bq update \
--default_partition_expiration integer \
project_id:dataset

Sostituisci quanto segue:

integer: la durata predefinita, in secondi, per le partizioni nelle tabelle partizionate appena create. Questo flag non ha un valore minimo. Specifica 0 per rimuovere la data e l'ora di scadenza esistenti. Qualsiasi partizione in le tabelle partizionate create di recente vengono eliminate integer secondi dopo la data UTC della partizione. Questo valore viene applicato se non imposti una scadenza per la partizione nella tabella al momento della sua creazione.
project_id: il tuo ID progetto.
dataset: il nome del set di dati che stai aggiornamento in corso.

Esempi:

Inserisci il comando seguente per impostare la scadenza predefinita della partizione per nuove tabelle partizionate create in mydataset a 26 ore (93.600 secondi). Il set di dati si trova nel progetto predefinito.

bq update --default_partition_expiration 93600 mydataset

Inserisci il seguente comando per impostare la scadenza predefinita della partizione per le nuove tabelle partizionate create in mydataset su 26 ore (93.600 secondi). Il set di dati si trova in myotherproject, non nel tuo progetto predefinito.

bq update --default_partition_expiration 93600 myotherproject:mydataset

API

Chiama datasets.patch e aggiorna la proprietà defaultPartitionExpirationMs nel risorsa del set di dati. La scadenza è espressa in millisecondi. Poiché datasets.update sostituisce l'intera risorsa del set di dati, il metodo datasets.patch è preferito.

Aggiorna la modalità di arrotondamento

Puoi aggiornare la modalità di arrotondamento predefinita di un set di dati utilizzando l'istruzione DDL ALTER SCHEMA SET OPTIONS. L'esempio seguente aggiorna la modalità di arrotondamento predefinita per mydataset in ROUND_HALF_EVEN.

ALTER SCHEMA mydataset
SET OPTIONS (
  default_rounding_mode = "ROUND_HALF_EVEN");

Consente di impostare la modalità di arrotondamento predefinita per le nuove tabelle create nel set di dati. Questa operazione non influisce sulle nuove colonne aggiunte alle tabelle esistenti. L'impostazione della modalità di arrotondamento predefinita in una tabella nel set di dati sostituisce questa impostazione .

Aggiornare i controlli di accesso ai set di dati

La procedura per aggiornare i controlli di accesso di un set di dati è molto simile processo per l'assegnazione dei controlli dell'accesso a un set di dati. I controlli dell'accesso non possono essere applicati durante la creazione del set di dati utilizzando la console Google Cloud a riga di comando bq. Devi prima creare il set di dati, quindi aggiornare il relativo codice controlli dell'accesso. L'API ti consente di aggiornare i controlli di accesso ai set di dati chiamando il metodo datasets.patch.

Quando aggiorni i controlli di accesso su un set di dati, puoi modificare l'accesso per le seguenti entità:

Entità IAM:
- Email Account Google: concede a un account Google individuale l'accesso a il set di dati.
- Gruppo Google: concede a tutti i membri di un gruppo Google l'accesso al del set di dati.
- Dominio Google Workspace: concede a tutti gli utenti e i gruppi di un dominio Google accesso al set di dati.
- Account di servizio: concede a un account di servizio l'accesso al set di dati.
- Chiunque: inserisci allUsers per concedere l'accesso al pubblico.
- Tutti gli Account Google: inserisci allAuthenticatedUsers per concedere l'accesso a qualsiasi utente che ha eseguito l'accesso a un Account Google.
Tipi di risorse:
- Set di dati autorizzati: concede a un set di dati autorizzato accesso al set di dati.
- Viste autorizzate: concede a una vista autorizzata accesso al set di dati.
- Funzioni autorizzate: concede l'accesso al set di dati a una funzione tabella o UDF autorizzata.

Per aggiornare i controlli dell'accesso in un set di dati:

Console

Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Espandi l'opzione Azioni e fai clic su Apri.
Fai clic su Condividi set di dati.
Nella finestra di dialogo Condividi set di dati, per eliminare voci esistenti, espandi il e fai clic sull'icona Elimina (cestino).
Nella finestra di dialogo Condividi set di dati, per aggiungere nuove voci:
1. Inserisci l'entità nella casella Aggiungi entità.
2. In Seleziona un ruolo, scegli un ruolo IAM appropriato dall'elenco. Per ulteriori informazioni sulle autorizzazioni assegnate a ogni ruolo BigQuery predefinito, consulta Ruoli e autorizzazioni predefiniti .
3. Fai clic su Aggiungi.
Per aggiungere una vista autorizzata, fai clic sulla scheda Vista autorizzata e inserisci il progetto, il set di dati e la vista, quindi fai clic su Aggiungi.
Al termine dell'aggiunta o dell'eliminazione dei controlli di accesso, fai clic su Fine.

bq

Scrivi le informazioni esistenti del set di dati (inclusi i controlli di accesso) in un file JSON utilizzando il comando show. Se il set di dati si trova in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.
```
bq show \
--format=prettyjson \
project_id:dataset > path_to_file
```
Sostituisci quanto segue:
- project_id: il tuo ID progetto.
- dataset: il nome del set di dati.
- path_to_file: il percorso del file JSON su della macchina locale.
Esempi:

Inserisci il seguente comando per scrivere i controlli di accesso per mydataset in un file JSON. mydataset si trova nel tuo progetto predefinito.
```
bq show --format=prettyjson mydataset > /tmp/mydataset.json
```
Inserisci il comando seguente per scrivere i controlli di accesso per mydataset in un file JSON. mydataset è a myotherproject.
```
bq show --format=prettyjson \
myotherproject:mydataset > /tmp/mydataset.json
```

Apporta le modifiche alla sezione "access" del file JSON. Puoi aggiungere o rimuovi una qualsiasi delle specialGroup voci: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. Puoi anche aggiungere, rimuovere o modificare uno dei seguenti elementi: userByEmail, groupByEmail e domain.

Ad esempio, la sezione di accesso del file JSON di un set di dati sarà simile al seguente:

{
 "access": [
  {
   "role": "READER",
   "specialGroup": "projectReaders"
  },
  {
   "role": "WRITER",
   "specialGroup": "projectWriters"
  },
  {
   "role": "OWNER",
   "specialGroup": "projectOwners"
  }
  {
   "role": "READER",
   "specialGroup": "allAuthenticatedUsers"
  }
  {
   "role": "READER",
   "domain": "[DOMAIN_NAME]"
  }
  {
   "role": "WRITER",
   "userByEmail": "[USER_EMAIL]"
  }
  {
   "role": "READER",
   "groupByEmail": "[GROUP_EMAIL]"
  }
 ],
}

Quando le modifiche sono complete, usa il comando update e includi i file JSON utilizzando il flag --source. Se il set di dati si trova in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

Attenzione:quando applichi il file JSON che contiene i controlli dell'accesso, quelli esistenti sono sovrascritto.
```
bq update --source path_to_file project_id:dataset
```
Sostituisci quanto segue:
- path_to_file: il percorso del file JSON su della macchina locale.
- project_id: il tuo ID progetto.
- dataset: il nome del set di dati.
Esempi:

Inserisci il comando seguente per aggiornare i controlli dell'accesso per mydataset. mydataset si trova nel tuo progetto predefinito.
```
bq update --source /tmp/mydataset.json mydataset
```
Inserisci il comando seguente per aggiornare i controlli dell'accesso per mydataset. mydataset è a myotherproject.
```
bq update --source /tmp/mydataset.json myotherproject:mydataset
```
Per verificare le modifiche apportate al controllo dell'accesso, inserisci di nuovo il comando show senza scrivere le informazioni in un file.
```
bq show --format=prettyjson dataset
```
o
```
bq show --format=prettyjson project_id:dataset
```

API

Chiama il datasets.patch e aggiorna la proprietà access nel risorsa del set di dati.

Poiché il metodo datasets.update sostituisce l'intera risorsa del set di dati, datasets.patch è il metodo preferito per l'aggiornamento dei controlli dell'accesso.

Vai

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateDatasetAccessControl demonstrates how the access control policy of a dataset
// can be amended by adding an additional entry corresponding to a specific user identity.
func updateDatasetAccessControl(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       bigquery.ReaderRole,
			EntityType: bigquery.UserEmailEntity,
			Entity:     "sample.bigquery.dev@gmail.com"},
		),
	}

	// Leverage the ETag for the update to assert there's been no modifications to the
	// dataset since the metadata was originally read.
	if _, err := ds.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Configura i controlli di accesso con il metodo Dataset.Builder.setAcl().

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Role;
import com.google.cloud.bigquery.Acl.User;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.ArrayList;

public class UpdateDatasetAccess {

  public static void runUpdateDatasetAccess() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    updateDatasetAccess(datasetName);
  }

  public static void updateDatasetAccess(String datasetName) {
    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();

      Dataset dataset = bigquery.getDataset(datasetName);

      // Create a new ACL granting the READER role to "sample.bigquery.dev@gmail.com"
      // For more information on the types of ACLs available see:
      // https://cloud.google.com/storage/docs/access-control/lists
      Acl newEntry = Acl.of(new User("sample.bigquery.dev@gmail.com"), Role.READER);

      // Get a copy of the ACLs list from the dataset and append the new entry
      ArrayList<Acl> acls = new ArrayList<>(dataset.getAcl());
      acls.add(newEntry);

      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("Dataset Access Control updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Dataset Access control was not updated \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

async function updateDatasetAccess() {
  // Updates a datasets's access controls.

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

  // Create new role metadata
  const newRole = {
    role: 'READER',
    entity_type: 'userByEmail',
    userByEmail: 'sample.bigquery.dev@gmail.com',
  };

  // Retreive current dataset metadata
  const dataset = bigquery.dataset(datasetId);
  const [metadata] = await dataset.getMetadata();

  // Add new role to role acess array
  metadata.access.push(newRole);
  const [apiResponse] = await dataset.setMetadata(metadata);
  const newAccessRoles = apiResponse.access;
  newAccessRoles.forEach(role => console.log(role));
}

Python

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Imposta la proprietà dataset.access_entries con i controlli di accesso per un set di dati. Quindi chiama il client.update_dataset() per aggiornare la proprietà.


# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
dataset_id = "your-project.your_dataset"

# TODO(developer): Set entity_id to the ID of the email or group from whom
# you are adding access. Alternatively, to the JSON REST API representation
# of the entity, such as a view's table reference.
entity_id = "user-or-group-to-add@example.com"

from google.cloud.bigquery.enums import EntityTypes

# TODO(developer): Set entity_type to the type of entity you are granting access to.
# Common types include:
#
# * "userByEmail" -- A single user or service account. For example "fred@example.com"
# * "groupByEmail" -- A group of users. For example "example@googlegroups.com"
# * "view" -- An authorized view. For example
#       {"projectId": "p", "datasetId": "d", "tableId": "v"}
#
# For a complete reference, see the REST API reference documentation:
# https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#Dataset.FIELDS.access
entity_type = EntityTypes.GROUP_BY_EMAIL

# TODO(developer): Set role to a one of the "Basic roles for datasets"
# described here:
# https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
role = "READER"

from google.cloud import bigquery

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

dataset = client.get_dataset(dataset_id)  # Make an API request.

entries = list(dataset.access_entries)
entries.append(
    bigquery.AccessEntry(
        role=role,
        entity_type=entity_type,
        entity_id=entity_id,
    )
)
dataset.access_entries = entries

dataset = client.update_dataset(dataset, ["access_entries"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with modified user permissions.".format(full_dataset_id)
)

Aggiornare le finestre di spostamento nel tempo

Puoi aggiornare la finestra di spostamento temporale di un set di dati nei seguenti modi:

Utilizzo della console Google Cloud.
L'utilizzo del ALTER SCHEMA SET OPTIONS l'Informativa.
Lo strumento a riga di comando bq Comando bq update.
Chiamata a datasets.patch oppure API datasets.update . Il metodo update sostituisce l'intera risorsa del set di dati, mentre il metodo Il metodo patch sostituisce solo i campi forniti nel set di dati inviato risorsa.

Per ulteriori informazioni sulla finestra di viaggio nel tempo, consulta Configurare la finestra di viaggio nel tempo.

Per aggiornare la finestra di spostamento cronologico per un set di dati:

Console

Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Espandi Azioni e fai clic su Apri.
Nel riquadro Dettagli, fai clic su Modifica dettagli.
Espandi Opzioni avanzate, quindi seleziona la Finestra di viaggio nel tempo da utilizzare.
Fai clic su Salva.

SQL

Utilizza l'istruzione ALTER SCHEMA SET OPTIONS con l'opzione max_time_travel_hours per specificare la finestra di scorrimento temporale quando modifichi un set di dati. Il valore max_time_travel_hours deve essere un numero intero espresso in multipli di 24 (48, 72, 96, 120, 144, 168) tra 48 (2 giorni) e 168 (7 giorni).

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor di query, inserisci la seguente istruzione:
```
ALTER SCHEMA DATASET_NAME
SET OPTIONS(
  max_time_travel_hours = HOURS);
```
Sostituisci quanto segue:
- DATASET_NAME: il nome del set di dati che stai aggiornando
- HOURS con la durata della finestra di spostamento cronologico in ore.
Fai clic su Esegui.

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

bq

Utilizza il comando bq update con il flag --max_time_travel_hours per specificare la finestra di viaggio nel tempo quando modifichi un set di dati. Il valore --max_time_travel_hours deve essere un numero intero espresso in multipli di 24 (48, 72, 96, 120, 144, 168) tra 48 (2 giorni) e 168 (7 giorni).

bq update \
--dataset=true --max_time_travel_hours=HOURS \
PROJECT_ID:DATASET_NAME

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
DATASET_NAME: il nome del set di dati che stai aggiornando
HOURS con la durata della finestra di spostamento cronologico in ore

API

Chiama il metodo datasets.patch o datasets.update con una risorsa set di dati definita in cui hai specificato un valore per il campo maxTimeTravelHours. La Il valore di maxTimeTravelHours deve essere un numero intero espresso in multipli di 24 (48, 72, 96, 120, 144, 168) tra 48 (2 giorni) e 168 (7 giorni).

Aggiornare i modelli di fatturazione dello spazio di archiviazione

Puoi modificare modello di fatturazione dello spazio di archiviazione per un set di dati. Imposta il valore storage_billing_model su PHYSICAL da utilizzare byte fisici durante il calcolo delle modifiche dello spazio di archiviazione o a LOGICAL da utilizzare byte logici. LOGICAL è l'impostazione predefinita.

Quando modifichi il modello di fatturazione di un set di dati, sono necessarie 24 ore prima che la modifica venga applicata.

Una volta modificato il modello di fatturazione dello spazio di archiviazione di un set di dati, devi attendere 14 giorni prima di poterlo modificare di nuovo.

Console

Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
Espandi Azioni e fai clic su Apri.
Nel riquadro Dettagli, fai clic su Modifica dettagli.
Espandi Opzioni avanzate, quindi seleziona Abilita archiviazione fisica modello di fatturazione per utilizzare la fatturazione dello spazio di archiviazione fisico o deselezionarla per per l'archiviazione logica.
Fai clic su Salva.

SQL

Per aggiornare il modello di fatturazione per un set di dati, utilizza Dichiarazione ALTER SCHEMA SET OPTIONS e imposta l'opzione storage_billing_model:

Nella console Google Cloud, vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor query, inserisci la seguente istruzione:
```
ALTER SCHEMA DATASET_NAME
SET OPTIONS(
 storage_billing_model = 'BILLING_MODEL');
```
Sostituisci quanto segue:
- DATASET_NAME con il nome del set di dati che stai modificando
- BILLING_MODEL con il tipo di spazio di archiviazione che vuoi utilizzare, LOGICAL o PHYSICAL
Fai clic su Esegui.

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

Per aggiornare il modello di fatturazione dello spazio di archiviazione per tutti i set di dati in un progetto, utilizza la seguente query SQL per ogni regione in cui si trovano i set di dati:

FOR record IN
 (SELECT CONCAT(catalog_name, '.', schema_name) AS dataset_path
 FROM PROJECT_ID.region-REGION.INFORMATION_SCHEMA.SCHEMATA)
DO
 EXECUTE IMMEDIATE
   "ALTER SCHEMA `" || record.dataset_path || "` SET OPTIONS(storage_billing_model = 'BILLING_MODEL')";
END FOR;

Sostituisci quanto segue:

PROJECT_ID con il tuo ID progetto
REGION con un qualificatore regione
BILLING_MODEL con il tipo di spazio di archiviazione che vuoi utilizzare, LOGICAL o PHYSICAL

bq

Per aggiornare il modello di fatturazione per un set di dati, utilizza il comando bq update e imposta il flag --storage_billing_model:

bq update -d --storage_billing_model=BILLING_MODEL PROJECT_ID:DATASET_NAME

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
DATASET_NAME: il nome del set di dati che stai aggiornando
BILLING_MODEL: il tipo di spazio di archiviazione che vuoi utilizzare, LOGICAL o PHYSICAL

API

Chiama il metodo datasets.update con una risorsa set di dati definita in cui è impostato il campo storageBillingModel.

L'esempio seguente mostra come chiamare datasets.update utilizzando curl:

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" -L -X PUT https://bigquery.googleapis.com/bigquery/v2/projects/PROJECT_ID/datasets/DATASET_ID -d '{"datasetReference": {"projectId": "PROJECT_ID", "datasetId": "DATASET_NAME"}, "storageBillingModel": "BILLING_MODEL"}'

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
DATASET_NAME: il nome del set di dati che stai aggiornando
BILLING_MODEL: il tipo di spazio di archiviazione che vuoi da utilizzare, LOGICAL o PHYSICAL

Sicurezza dei set di dati

Per controllare l'accesso ai set di dati in BigQuery, consulta Controllo dell'accesso ai set di dati. Per informazioni sulla crittografia dei dati, vedi Crittografia at-rest.

Passaggi successivi

Per ulteriori informazioni sulla creazione di set di dati, consulta Creare set di dati.
Per saperne di più sulla gestione dei set di dati, consulta Gestire i set di dati.