Crea e utilizza tabelle

Questo documento descrive come creare e utilizzare tabelle standard (integrate) in BigQuery. Per informazioni sulla creazione di altri tipi di tabelle, consulta quanto segue:

• Crea tabelle partizionate
• Creazione e utilizzo di tabelle in cluster

Dopo aver creato una tabella, puoi:

• Controlla l'accesso ai dati delle tabelle.
• Ottenere informazioni sulle tabelle.
• Elenca le tabelle in un set di dati.
• Recupera i metadati della tabella.

Per saperne di più sulla gestione delle tabelle, tra cui l'aggiornamento delle proprietà, la copia e l'eliminazione di una tabella, consulta Gestione delle tabelle.

Prima di iniziare

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

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare una tabella, chiedi all'amministratore di concederti i seguenti ruoli IAM:

• Utente job BigQuery (roles/bigquery.jobUser) sul progetto se crei una tabella caricando dati o salvando i risultati delle query salvate in una tabella.
• BigQuery Data Editor (roles/bigquery.dataEditor) nel set di dati in cui stai creando la tabella.

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare una tabella. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Denominazione delle tabelle

Quando crei una tabella in BigQuery, il nome della tabella deve essere univoco per set di dati. Il nome della tabella può:

• Contenere caratteri per un totale di massimo 1024 byte UTF-8.
• Contenere caratteri Unicode nella categoria L (lettera), M (segno), N (numero), Pc (connettore, incluso il trattino basso), Pd (trattino), Zs (spazio). Per saperne di più, consulta Categoria generale.

Di seguito sono riportati alcuni esempi di nomi di tabelle validi: table 01, ग्राहक, 00_お客様, étudiant-01.

Precisazioni:

• I nomi delle tabelle sono sensibili alle maiuscole per impostazione predefinita. mytable e MyTable possono coesistere nello stesso set di dati, a meno che non facciano parte di un set di dati con la sensibilità alle maiuscole disattivata.
• Alcuni nomi di tabelle e prefissi dei nomi di tabelle sono riservati. Se ricevi un messaggio di errore che indica che il nome o il prefisso della tabella è riservato, seleziona un nome diverso e riprova.

• Se includi più operatori punto (.) in una sequenza, gli operatori duplicati vengono rimossi implicitamente.

  Ad esempio: project_name....dataset_name..table_name

  Diventa: project_name.dataset_name.table_name

Crea tabelle

Puoi creare una tabella in BigQuery nei seguenti modi:

• Manualmente utilizzando la console Cloud de Confiance o il comando bq mk dello strumento a riga di comando bq.
• In modo programmatico chiamando il metodo API tables.insert.
• Utilizzando le librerie client.
• Dai risultati della query.
• Definendo una tabella che fa riferimento a un'origine dati esterna.
• Quando carichi i dati.
• Utilizzando un'istruzione DDL (Data Definition Language) CREATE TABLE.

Crea una tabella vuota con una definizione di schema

Puoi creare una tabella vuota con una definizione dello schema nei seguenti modi:

• Inserisci lo schema utilizzando la console Cloud de Confiance .
• Fornisci lo schema in linea utilizzando lo strumento a riga di comando bq.
• Invia un file di schema JSON utilizzando lo strumento a riga di comando bq.
• Fornisci lo schema in una risorsa di tabella quando chiami il metodo tables.insert delle API.

Per saperne di più sulla specifica di uno schema di tabella, consulta Specifica di uno schema.

Dopo aver creato la tabella, puoi caricare i dati o compilarla scrivendo i risultati delle query.

Per creare una tabella vuota con una definizione di schema:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  table_id   = "mytable"

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

using Google.Cloud.BigQuery.V2;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

import (
	"context"
	"fmt"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    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();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

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

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

from google.cloud import bigquery

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

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

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

Crea una tabella vuota senza una definizione dello schema

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a table without schema
public class CreateTableWithoutSchema {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createTableWithoutSchema(datasetName, tableName);
  }

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

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Crea una tabella dal risultato di una query

Per creare una tabella dal risultato di una query, scrivi i risultati in una tabella di destinazione.

import (
	"context"
	"fmt"
	"io"

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

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \n" + e.toString());
    }
  }
}

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

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Crea una tabella che fa riferimento a un'origine dati esterna

Un'origine dati esterna è un'origine dati in cui puoi eseguire query direttamente da BigQuery, anche se i dati non vengono archiviati in BigQuery. Ad esempio, potresti avere dati in un database Cloud de Confiance by S3NS diverso, in file in Cloud Storage o in un prodotto cloud diverso che vorresti analizzare in BigQuery, ma non avere ancora la possibilità di eseguire una migrazione.

Per saperne di più, consulta Introduzione alle origini dati esterne.

Crea una tabella quando carichi i dati

Quando carichi i dati in BigQuery, puoi caricarli in una nuova tabella o partizione, puoi aggiungerli a una tabella o partizione esistente oppure puoi sovrascrivere una tabella o partizione. Non è necessario creare una tabella vuota prima di caricarvi i dati. Puoi creare la nuova tabella e caricare i dati contemporaneamente.

Quando carichi i dati in BigQuery, puoi fornire lo schema della tabella o della partizione oppure, per i formati dei dati supportati, puoi utilizzare il rilevamento automatico dello schema.

Per saperne di più sul caricamento dei dati, consulta Introduzione al caricamento dei dati in BigQuery.

Crea una tabella multimodale

Puoi creare una tabella con una o più colonne ObjectRef per archiviare i metadati relativi ai dati non strutturati correlati agli altri dati strutturati nella tabella. Ad esempio, in una tabella dei prodotti, puoi creare una colonna ObjectRef per archiviare le informazioni sulle immagini dei prodotti insieme agli altri dati di prodotto. I dati non strutturati vengono archiviati in Cloud Storage e resi disponibili in BigQuery utilizzando una tabella di oggetti.

Per scoprire come creare una tabella multimodale, consulta Analizza i dati multimodali con SQL e BigQuery DataFrames.

Controlla l'accesso alle tabelle

Per configurare l'accesso a tabelle e viste, puoi concedere un ruolo IAM a un'entità ai seguenti livelli, elencati in ordine di intervallo di risorse consentite (dalla più grande alla più piccola):

• Un livello elevato nella gerarchia delle risorseCloud de Confiance by S3NS , ad esempio a livello di progetto, cartella o organizzazione
• Il livello del set di dati
• Livello di tabella o vista

Puoi anche limitare l'accesso ai dati all'interno delle tabelle utilizzando i seguenti metodi:

• Sicurezza a livello di colonna
• Mascheramento dei dati delle colonne
• Sicurezza a livello di riga

L'accesso a qualsiasi risorsa protetta da IAM è cumulativo. Ad esempio, se un'entità non ha accesso a un livello elevato, come un progetto, puoi concederle l'accesso a livello di set di dati, in modo che possa accedere alle tabelle e alle viste del set di dati. Analogamente, se l'entità non dispone dell'accesso a livello elevato o di set di dati, puoi concederle l'accesso a livello di tabella o vista.

La concessione di ruoli IAM a un livello superiore nella gerarchia delle risorseCloud de Confiance by S3NS, ad esempio a livello di progetto, cartella o organizzazione, consente all'entità di accedere a un ampio insieme di risorse. Ad esempio, la concessione di un ruolo a un'entità a livello di progetto assegna a quell'entità le autorizzazioni che si applicano a tutti i set di dati nel progetto.

La concessione di un ruolo a livello di set di dati specifica le operazioni che un'entità può eseguire su tabelle e viste in quel set di dati specifico, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli di accesso a livello di set di dati, consulta Controllo dell'accesso ai set di dati.

La concessione di un ruolo a livello di tabella o vista specifica le operazioni che un'entità può eseguire su tabelle e viste specifiche, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli degli accessi a livello di tabella, consulta Controllo dell'accesso a tabelle e viste.

Puoi anche creare ruoli personalizzati IAM. Se crei un ruolo personalizzato, le autorizzazioni che concedi dipendono dalle operazioni specifiche che vuoi che l'entità sia in grado di eseguire.

Non puoi impostare un'autorizzazione "Nega" su nessuna risorsa protetta da IAM.

Per saperne di più su ruoli e autorizzazioni, consulta Informazioni sui ruoli nella documentazione di IAM e Ruoli e autorizzazioni IAM di BigQuery.

Ottieni informazioni sulle tabelle

Puoi ottenere informazioni o metadati sulle tabelle nei seguenti modi:

• Utilizzando la console Cloud de Confiance .
• Utilizzo del comando bq show dello strumento a riga di comando bq.
• Chiamata del metodo API tables.get.
• Utilizzo delle librerie client.
• Esecuzione di query sulla vista INFORMATION_SCHEMA.VIEWS.

Autorizzazioni obbligatorie

Come minimo, per ottenere informazioni sulle tabelle, devi disporre delle autorizzazioni bigquery.tables.get. I seguenti ruoli IAM predefiniti includono le autorizzazioni bigquery.tables.get:

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

Inoltre, se un utente dispone delle autorizzazioni bigquery.datasets.create, quando crea un set di dati, gli viene concesso l'accesso bigquery.dataOwner. L'accesso bigquery.dataOwner consente all'utente di recuperare i metadati della tabella.

Per saperne di più su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.

Ottieni informazioni sulla tabella

Per ottenere informazioni sulle tabelle:

import (
	"context"
	"fmt"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	return nil
}

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

  public static void getTable(String projectId, String datasetName, String tableName) {
    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();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \n" + e.toString());
    }
  }
}

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

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

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

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

use Google\Cloud\BigQuery\BigQueryClient;

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

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Ottieni informazioni sulla tabella utilizzando INFORMATION_SCHEMA

INFORMATION_SCHEMA è una serie di visualizzazioni che forniscono l'accesso ai metadati relativi a set di dati, routine, tabelle, visualizzazioni, job, prenotazioni e dati in streaming.

Puoi eseguire query sulle seguenti viste per ottenere informazioni sulla tabella:

• Utilizza le viste INFORMATION_SCHEMA.TABLES e INFORMATION_SCHEMA.TABLE_OPTIONS per recuperare i metadati relativi a tabelle e viste in un progetto.
• Utilizza le viste INFORMATION_SCHEMA.COLUMNS e INFORMATION_SCHEMA.COLUMN_FIELD_PATHS per recuperare i metadati relativi alle colonne (campi) di una tabella.
• Utilizza le viste INFORMATION_SCHEMA.TABLE_STORAGE per recuperare i metadati sull'utilizzo dello spazio di archiviazione attuale e storico da parte di una tabella.

Anche le viste TABLES e TABLE_OPTIONS contengono informazioni di alto livello sulle viste. Per informazioni dettagliate, esegui una query sulla vista INFORMATION_SCHEMA.VIEWS.

TABLES visualizzazione

Quando esegui una query sulla vista INFORMATION_SCHEMA.TABLES, i risultati della query contengono una riga per ogni tabella o vista di un set di dati. Per informazioni dettagliate sulle visualizzazioni, esegui una query sulla visualizzazione INFORMATION_SCHEMA.VIEWS.

La vista INFORMATION_SCHEMA.TABLES ha il seguente schema:

Esempi

Esempio 1:

L'esempio seguente recupera i metadati della tabella per tutte le tabelle nel set di dati denominato mydataset. I metadati restituiti riguardano tutti i tipi di tabelle in mydataset nel progetto predefinito.

mydataset contiene le seguenti tabelle:

• mytable1: una tabella BigQuery standard
• myview1: una vista BigQuery

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

SELECT
  table_catalog, table_schema, table_name, table_type,
  is_insertable_into, creation_time, ddl
FROM
  mydataset.INFORMATION_SCHEMA.TABLES;

Il risultato è simile al seguente. Per motivi di leggibilità, alcune colonne sono escluse dal risultato.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` |
|                |               |                |            |                    |                     | (                                           |
|                |               |                |            |                    |                     |   id INT64                                  |
|                |               |                |            |                    |                     | );                                          |
| myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1`   |
|                |               |                |            |                    |                     | AS SELECT 100 as id;                        |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+

Esempio 2:

L'esempio seguente recupera i metadati della tabella per tutte le tabelle di tipo CLONE o SNAPSHOT dalla vista INFORMATION_SCHEMA.TABLES. I metadati restituiti riguardano le tabelle in mydataset nel progetto predefinito.

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

  SELECT
    table_name, table_type, base_table_catalog,
    base_table_schema, base_table_name, snapshot_time_ms
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'CLONE'
  OR
    table_type = 'SNAPSHOT';

Il risultato è simile al seguente. Per motivi di leggibilità, alcune colonne sono escluse dal risultato.

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | table_name   | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms    |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | items_clone  | CLONE      | myproject          | mydataset         | items           | 2018-10-31 22:40:05 |
  | orders_bk    | SNAPSHOT   | myproject          | mydataset         | orders          | 2018-11-01 08:22:39 |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+

Esempio 3:

L'esempio seguente recupera le colonne table_name e ddl dalla vista INFORMATION_SCHEMA.TABLES per la tabella population_by_zip_2010 nel set di dati census_bureau_usa. Questo set di dati fa parte del programma per i set di dati pubblici di BigQuery.

Poiché la tabella su cui stai eseguendo la query si trova in un altro progetto, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view. In questo esempio, il valore è `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

SELECT
  table_name, ddl
FROM
  `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
WHERE
  table_name = 'population_by_zip_2010';

Il risultato è simile al seguente:

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       table_name       |                                                                                                            ddl                                                                                                             |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010`                                                                                                                                               |
|                        | (                                                                                                                                                                                                                          |
|                        |   geo_id STRING OPTIONS(description="Geo code"),                                                                                                                                                                           |
|                        |   zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"),                                                                                                                          |
|                        |   population INT64 OPTIONS(description="The total count of the population for this segment."),                                                                                                                             |
|                        |   minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."),                                                          |
|                        |   maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), |
|                        |   gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.")                                                                                                                    |
|                        | )                                                                                                                                                                                                                          |
|                        | OPTIONS(                                                                                                                                                                                                                   |
|                        |   labels=[("freebqcovid", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  

TABLE_OPTIONS visualizzazione

Quando esegui una query sulla vista INFORMATION_SCHEMA.TABLE_OPTIONS, i risultati della query contengono una riga per ogni opzione, per ogni tabella o vista di un set di dati. Per informazioni dettagliate sulle viste, esegui invece una query sulla vista INFORMATION_SCHEMA.VIEWS.

La vista INFORMATION_SCHEMA.TABLE_OPTIONS ha il seguente schema:

Tabella delle opzioni

Per le tabelle esterne sono possibili le seguenti opzioni:

Esempi

Esempio 1:

L'esempio seguente recupera le date di scadenza predefinite per tutte le tabelle in mydataset nel progetto predefinito (myproject) eseguendo una query sulla vista INFORMATION_SCHEMA.TABLE_OPTIONS.

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'expiration_timestamp';

Il risultato è simile al seguente:

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

Esempio 2:

L'esempio seguente recupera i metadati relativi a tutte le tabelle in mydataset che contengono dati di test. La query utilizza i valori nell'opzione description per trovare le tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset si trova nel tuo progetto predefinito: myproject.

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'description'
    AND option_value LIKE '%test%';

Il risultato è simile al seguente:

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

COLUMNS visualizzazione

Quando esegui una query sulla vista INFORMATION_SCHEMA.COLUMNS, i risultati della query contengono una riga per ogni colonna (campo) di una tabella.

La vista INFORMATION_SCHEMA.COLUMNS ha il seguente schema:

Esempi

L'esempio seguente recupera i metadati dalla vista INFORMATION_SCHEMA.COLUMNS per la tabella population_by_zip_2010 nel set di dati census_bureau_usa. Questo set di dati fa parte del programma per i set di dati pubblici di BigQuery.

Poiché la tabella su cui stai eseguendo la query si trova in un altro progetto, il progetto bigquery-public-data, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

La seguente colonna è esclusa dai risultati della query:

• IS_UPDATABLE

  SELECT
    * EXCEPT(is_updatable)
  FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
  WHERE
    table_name = 'population_by_zip_2010';

Il risultato è simile al seguente. Per motivi di leggibilità, alcune colonne sono escluse dal risultato.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position | policy_tags |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL | 0 rows      |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL | 0 rows      |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+-------------+
  

COLUMN_FIELD_PATHS visualizzazione

Quando esegui una query sulla vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, i risultati della query contengono una riga per ogni colonna nidificata all'interno di una colonna RECORD (o STRUCT).

La vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS ha il seguente schema:

Esempi

L'esempio seguente recupera i metadati dalla vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS per la tabella commits nel set di dati github_repos. Questo set di dati fa parte del programma per i set di dati pubblici di BigQuery.

Poiché la tabella su cui stai eseguendo la query si trova in un altro progetto, il progetto bigquery-public-data, aggiungi l'ID progetto al set di dati nel seguente formato: `project_id`.dataset.INFORMATION_SCHEMA.view; ad esempio, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

La tabella commits contiene le seguenti colonne nidificate e ripetute:

• author: colonna RECORD nidificata
• committer: colonna RECORD nidificata
• trailer: colonna RECORD nidificata e ripetuta
• difference: colonna RECORD nidificata e ripetuta

Per visualizzare i metadati relativi alle colonne author e difference, esegui questa query.

SELECT
  *
FROM
  `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE
  table_name = 'commits'
  AND (column_name = 'author' OR column_name = 'difference');

Il risultato è simile al seguente. Per motivi di leggibilità, alcune colonne sono escluse dal risultato.

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description | policy_tags |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        | 0 rows      |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        | 0 rows      |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        | 0 rows      |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        | 0 rows      |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        | 0 rows      |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        | 0 rows      |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-------------+
  

TABLE_STORAGE visualizzazione

Le viste TABLE_STORAGE e TABLE_STORAGE_BY_ORGANIZATION hanno il seguente schema:

Esempi

Esempio 1:

L'esempio seguente mostra i byte logici totali fatturati per il progetto corrente.

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

Il risultato è simile al seguente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+

Esempio 2:

L'esempio seguente mostra diversi byte di archiviazione in GiB a livello di set di dati per il progetto corrente.

SELECT
  table_schema AS dataset_name,
  -- Logical
  SUM(total_logical_bytes) / power(1024, 3) AS total_logical_gib,
  SUM(active_logical_bytes) / power(1024, 3) AS active_logical_gib,
  SUM(long_term_logical_bytes) / power(1024, 3) AS long_term_logical_gib,
  -- Physical
  SUM(total_physical_bytes) / power(1024, 3) AS total_physical_gib,
  SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
  SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
  SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
  SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
  SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE
WHERE
  table_type ='BASE TABLE'
GROUP BY
  table_schema
ORDER BY
  dataset_name

Esempio 3:

L'esempio seguente mostra come prevedere la differenza di prezzo per set di dati tra i modelli di fatturazione logica e fisica per i prossimi 30 giorni. Questo esempio presuppone che l'utilizzo dello spazio di archiviazione futuro sia costante nei successivi 30 giorni dal momento in cui è stata eseguita la query. Tieni presente che la previsione è limitata alle tabelle di base ed esclude tutti gli altri tipi di tabelle all'interno di un set di dati.

I prezzi utilizzati nelle variabili di prezzo per questa query si riferiscono alla regione us-central1. Se vuoi eseguire questa query per una regione diversa, aggiorna le variabili dei prezzi in modo appropriato. Per informazioni sui prezzi, consulta Prezzi di Storage.

1. Apri la pagina BigQuery nella console Cloud de Confiance .

   Vai alla pagina BigQuery

2. Inserisci la seguente query GoogleSQL nella casella Editor di query. INFORMATION_SCHEMA richiede la sintassi GoogleSQL. GoogleSQL è la sintassi predefinita nella console Cloud de Confiance .

   DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
   DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
   DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
   DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;
   
   WITH
    storage_sizes AS (
      SELECT
        table_schema AS dataset_name,
        -- Logical
        SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
        SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
        -- Physical
        SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
        SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
        SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
        -- Restorable previously deleted physical
        SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
        SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
      FROM
        `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
      WHERE total_physical_bytes + fail_safe_physical_bytes > 0
        -- Base the forecast on base tables only for highest precision results
        AND table_type  = 'BASE TABLE'
        GROUP BY 1
    )
   SELECT
     dataset_name,
     -- Logical
     ROUND(active_logical_gib, 2) AS active_logical_gib,
     ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
     -- Physical
     ROUND(active_physical_gib, 2) AS active_physical_gib,
     ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
     ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
     ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
     -- Compression ratio
     ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
     ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
     -- Forecast costs logical
     ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
     ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
     -- Forecast costs physical
     ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
     ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
     -- Forecast costs total
     ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
        (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
   FROM
     storage_sizes
   ORDER BY
     (forecast_active_logical_cost + forecast_active_physical_cost) DESC;

3. Fai clic su Esegui.

Il risultato è simile al seguente:

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |

Risoluzione dei problemi

Per attivare questa visualizzazione, puoi impostare il valore di enable_info_schema_storage su TRUE nel progetto o nell'organizzazione. Per saperne di più sulla gestione della configurazione, consulta Gestisci le impostazioni di configurazione.

Se non hai configurato questa impostazione, verrà visualizzato il seguente errore:

INFORMATION_SCHEMA.TABLE_STORAGE hasn't been enabled for project <myproject>.
Consider using one of the following SQL statements to enable data collection:
ALTER PROJECT `<myproject>`
SET OPTIONS (`region-<region>.enable_info_schema_storage` = TRUE)

Or to enable for the entire organization:
ALTER ORGANIZATION
SET OPTIONS (`region-<region>.enable_info_schema_storage` = TRUE)

After enabling, please allow around 1 day for the complete historical data to
become available.

Esegui le istruzioni SQL descritte nel messaggio di errore per abilitare la visualizzazione.

Elenca le tabelle in un set di dati

Puoi elencare le tabelle nei set di dati nei seguenti modi:

• Utilizzando la console Cloud de Confiance .
• Utilizzo del comando bq ls dello strumento a riga di comando bq.
• Chiamata del metodo API tables.list.
• Utilizzo delle librerie client.

Autorizzazioni obbligatorie

Per elencare le tabelle in un set di dati, devi disporre almeno delle autorizzazioni bigquery.tables.list. I seguenti ruoli IAM predefiniti includono le autorizzazioni bigquery.tables.list:

• bigquery.user
• bigquery.metadataViewer
• bigquery.dataViewer
• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

Per saperne di più su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.

Elenca tabelle

Per elencare le tabelle in un set di dati:

using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

import (
	"context"
	"fmt"
	"io"

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

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, 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()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	return nil
}

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

  public static void listTables(String projectId, 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();

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + e.toString());
    }
  }
}

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

async function listTables() {
  // Lists tables in 'my_dataset'.

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

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

use Google\Cloud\BigQuery\BigQueryClient;

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

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

Cronologia della tabella di controllo

Puoi controllare la cronologia delle tabelle BigQuery eseguendo query su Cloud Audit Logs in Esplora log. Questi log ti aiutano a monitorare quando le tabelle sono state create, aggiornate o eliminate e a identificare l'utente o il account di servizio che ha apportato le modifiche.

Autorizzazioni obbligatorie

Per sfogliare gli audit log, devi disporre del ruolo roles/logging.privateLogViewer. Per saperne di più sui ruoli e sulle autorizzazioni IAM in Cloud Logging, consulta Controllo dell'accesso con IAM.

Recupera i dati di controllo

Puoi accedere alle informazioni di controllo dalla console Cloud de Confiance , dalla riga di comando gcloud, dall'API REST e da tutti i linguaggi supportati utilizzando le librerie client. Il filtro di logging mostrato nell'esempio seguente può essere utilizzato indipendentemente dal metodo utilizzato.

1. Nella console Cloud de Confiance , vai alla pagina Logging.

   Vai a Logging

2. Utilizza la seguente query per accedere ai dati di controllo:

   logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity"
   AND resource.type = "bigquery_dataset"
   AND timestamp >= "STARTING_TIMESTAMP"
   AND protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog"
   AND (
     protoPayload.metadata.tableCreation :*
     OR protoPayload.metadata.tableChange :*
     OR protoPayload.metadata.tableDeletion :*
   )
   AND protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/"
   

Sostituisci quanto segue:

• PROJECT_ID: il progetto che contiene i set di dati e le tabelle che ti interessano.
• STARTING_TIMESTAMP: i log meno recenti che vuoi visualizzare. Utilizza il formato ISO 8601, ad esempio 2025-01-01 o 2025-02-03T04:05:06Z.
• DATASET_ID: il set di dati in base al quale vuoi filtrare.

Interpretazione dei risultati

Nel riquadro dei risultati di Esplora log, espandi la voce che ti interessa, quindi fai clic su Espandi i campi nidificati per visualizzare l'intero messaggio.

La voce di log contiene solo uno dei seguenti oggetti per indicare l'operazione eseguita:

• protoPayload.metadata.tableCreation: è stata creata una tabella.
• protoPayload.metadata.tableChange: i metadati della tabella sono stati modificati, ad esempio aggiornamento dello schema, modifica della descrizione o sostituzione della tabella.
• protoPayload.metadata.tableDeletion: una tabella è stata eliminata.

I contenuti di questi oggetti descrivono l'azione richiesta. Per una descrizione dettagliata, consulta BigQueryAuditMetadata.

Spiegazione della query

• logName = "projects/PROJECT_ID/logs/cloudaudit.googleapis.com%2Factivity": questa riga filtra gli audit log delle attività di amministrazione all'interno del tuo progetto Cloud de Confiance by S3NS. Questi log registrano le chiamate API e le azioni che modificano la configurazione o i metadati delle risorse.
• resource.type = "bigquery_dataset": restringe la ricerca agli eventi relativi ai set di dati BigQuery, in cui vengono registrate le operazioni sulle tabelle.
• timestamp >= "STARTING_TIMESTAMP": filtra le voci di log per mostrare solo quelle create in corrispondenza o dopo il timestamp specificato.
• protoPayload.@type = "type.googleapis.com/google.cloud.audit.AuditLog": garantisce che il messaggio di log sia conforme alla struttura standard degli audit log di Cloud.
• ( ... ): questo blocco raggruppa le condizioni per trovare diversi tipi di eventi della tabella, come descritto nella sezione precedente. L'operatore :* indica che la chiave deve essere presente. Se ti interessa un solo evento, ad esempio la creazione di una tabella, rimuovi le condizioni non necessarie da questo blocco.

• protoPayload.resourceName : "projects/PROJECT_ID/datasets/DATASET_ID/tables/": seleziona le voci di log corrispondenti alle tabelle contenute nel set di dati specificato. L'operatore due punti (:) esegue una ricerca di sottostringhe.

  • Per filtrare le voci per una singola tabella, sostituisci la condizione con la seguente: protoPayload.resourceName = "projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_NAME".
  • Per includere tutte le tabelle in tutti i set di dati nel progetto specifico, rimuovi questa condizione.

Per saperne di più sul filtro dei log, consulta Linguaggio di query di logging.

Sicurezza delle tabelle

Per controllare l'accesso alle tabelle in BigQuery, consulta Controlla l'accesso alle risorse con IAM.

Passaggi successivi

• Per saperne di più sui set di dati, consulta Introduzione ai set di dati.
• Per saperne di più sulla gestione dei dati delle tabelle, consulta Gestione dei dati delle tabelle.
• Per saperne di più sulla specifica degli schemi delle tabelle, consulta Specifica di uno schema.
• Per ulteriori informazioni sulla modifica degli schemi delle tabelle, consulta Modifica degli schemi delle tabelle.
• Per saperne di più sulla gestione delle tabelle, consulta Gestione delle tabelle.
• Per una panoramica di INFORMATION_SCHEMA, vai a Introduzione a BigQuery INFORMATION_SCHEMA.