Aggiorna le proprietà del set di dati

Console

1. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

2. Espandi more_vert Azioni e fai clic su Apri.

3. Nel riquadro Dettagli, fai clic su mode_edit 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:

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

   Vai a BigQuery

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

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

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi 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 in fase di aggiornamento

Esempi:

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

bq update --description "Description of mydataset" mydataset

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

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

API

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

Vai

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

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

// 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

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

Console

1. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

2. Espandi more_vert Azioni e fai clic su Apri.

3. Nel riquadro dei dettagli, fai clic sull'icona a forma di matita accanto a Informazioni sul set di dati per modificare la scadenza.

4. Nella finestra di dialogo Informazioni sul set di dati, nella sezione Scadenza tabella predefinita inserisci un valore in Numero di giorni dopo la creazione della tabella.

5. Fai clic su Salva.

SQL

Per aggiornare la scadenza predefinita della tabella, utilizza il metodo Dichiarazione 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.

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

   Vai a BigQuery

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

    ALTER SCHEMA mydataset
    SET OPTIONS(
        default_table_expiration_days = 3.75);
    

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi 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 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 in Il set di dati viene eliminato integer secondi dopo la data e l'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 progetto predefinito.

bq update --default_table_expiration 7200 mydataset

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 in myotherproject, non nel progetto predefinito.

bq update --default_table_expiration 7200 myotherproject:mydataset

API

Chiama datasets.patch e aggiorna la proprietà defaultTableExpirationMs in 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

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

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

// 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

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

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:

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

   Vai a BigQuery

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

    ALTER SCHEMA mydataset
    SET OPTIONS(
        default_partition_expiration_days = 3.75);
    

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi 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 nelle tabelle partizionate appena create. Questo flag non ha valori minimi valore. Specifica 0 per rimuovere la data di scadenza esistente. Qualsiasi partizione in le tabelle partizionate create di recente vengono eliminate integer secondi dopo la data UTC della partizione. Questo viene applicato se non imposti una scadenza della partizione nella tabella quando durante la 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 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 in myotherproject, non nel progetto predefinito.

bq update --default_partition_expiration 93600 myotherproject:mydataset

API

Chiama datasets.patch e aggiorna la proprietà defaultPartitionExpirationMs in 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.

Console

1. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

2. Espandi more_vert Azioni e fai clic su Apri.

3. Fai clic su Condividi set di dati.

4. Nella finestra di dialogo Condividi set di dati, per eliminare voci esistenti, espandi il e fai clic sull'icona Elimina (cestino).

5. Nella finestra di dialogo Condividi set di dati, per aggiungere nuove voci:

   1. Inserisci l'entità nella casella Aggiungi entità.

   2. Per 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.

6. 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.

7. Quando hai finito di aggiungere o eliminare i controlli di accesso, fai clic su Fine.

bq

1. Scrivi le informazioni esistenti del set di dati (inclusi i controlli di accesso) in un con il comando show. Se il set di dati si trova in un progetto diverso rispetto al progetto predefinito, aggiungi l'ID progetto al nome del set di dati nella 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 comando seguente per scrivere i controlli di accesso per mydataset in un file JSON. mydataset è 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
   

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

   Ad esempio, la sezione di accesso del file JSON di un set di dati potrebbe essere le seguenti:

   {
    "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]"
     }
    ],
   }
   

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

   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 è 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
   

4. 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

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:     "[email protected]"},
		),
	}

	// 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

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 "[email protected]"
      // 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("[email protected]"), 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

// 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: '[email protected]',
  };

  // 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

# 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 = "[email protected]"

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 "[email protected]"
# * "groupByEmail" -- A group of users. For example "[email protected]"
# * "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)
)

Console

1. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
2. Espandi more_vert Azioni e fai clic su Apri.
3. Nel riquadro Details (Dettagli), fai clic su mode_edit Modifica dettagli.
4. Espandi Opzioni avanzate, quindi seleziona la Finestra di spostamento cronologico. per l'utilizzo.
5. Fai clic su Salva.

SQL

Utilizza la ALTER SCHEMA SET OPTIONS con l'opzione max_time_travel_hours per specificare lo spostamento cronologico 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).

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

   Vai a BigQuery

2. Nell'editor 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.

3. Fai clic su play_circle Esegui.

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

bq

Utilizza la bq update con il flag --max_time_travel_hours per specificare lo spostamento cronologico 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 tra ore

API

Chiama il datasets.patch oppure datasets.update con un parametro risorsa set di dati in cui hanno 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).

Console

1. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.
2. Espandi more_vert Azioni e fai clic su Apri.
3. Nel riquadro Details (Dettagli), fai clic su mode_edit Modifica dettagli.
4. 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.
5. 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:

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

   Vai a BigQuery

2. 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 da utilizzare, LOGICAL o PHYSICAL

3. Fai clic su play_circle Esegui.

Per ulteriori informazioni su come eseguire le query, vedi 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 da utilizzare, LOGICAL o PHYSICAL

bq

Per aggiornare il modello di fatturazione per un set di dati, utilizza 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 da 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