Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Creare e utilizzare le tabelle

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

Dopo aver creato una tabella puoi:

  • Controllare l'accesso ai dati della tabella
  • Ottenere informazioni sulle tabelle
  • Elenca le tabelle in un set di dati
  • Recupero metadati tabella

Per ulteriori informazioni sulla gestione delle tabelle, tra cui l'aggiornamento delle proprietà di una tabella, la copia di una tabella ed l'eliminazione di una tabella, consulta la sezione Gestione delle tabelle.

Prima di iniziare

Prima di creare una tabella in BigQuery:

Denominazione tabella

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

  • Contenere fino a 1024 caratteri.
  • Contengono caratteri Unicode nella categoria L (lettera), M (mark), N (numero), Pc (connettore, incluso il trattino basso), Pd (trattino), Zs (spazio). Per ulteriori informazioni, consulta la categoria generale.

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

Avvertenze:

  • Alcuni nomi di tabella e prefissi dei nomi di tabella sono riservati. Se viene visualizzato un errore che indica che il nome o il prefisso della tabella è prenotato, seleziona un altro nome e riprova.
  • Se includi più operatori di punti (.) in una sequenza, gli operatori duplicati vengono implicitamente rimossi.

    Ad esempio: project_name....datasest_name..table_name

    Diventa questo: project_name.dataset_name.table_name

Creare tabelle

Puoi creare una tabella in BigQuery nei seguenti modi:

  • L'utilizzo manuale della console di Google Cloud o del comando a riga di comando bq bq mk.
  • A livello di programmazione 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) di CREATE TABLE.

Autorizzazioni obbligatorie

Per creare una tabella, devi disporre delle seguenti autorizzazioni IAM:

  • bigquery.tables.create
  • bigquery.tables.updateData
  • bigquery.jobs.create

Inoltre, potresti aver bisogno dell'autorizzazione bigquery.tables.getData per accedere ai dati scritti nella tabella.

Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per creare una tabella:

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin (include l'autorizzazione bigquery.jobs.create)
  • roles/bigquery.user (include l'autorizzazione bigquery.jobs.create)
  • roles/bigquery.jobUser (include l'autorizzazione bigquery.jobs.create)

Inoltre, se disponi dell'autorizzazione bigquery.datasets.create, puoi creare e aggiornare le tabelle nei set di dati che crei.

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

Creare una tabella vuota con una definizione di schema

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

  • Inserisci lo schema utilizzando Google Cloud Console.
  • Fornisci lo schema incorporato 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 della tabella quando chiami il metodo tables.insert dell'API.

Per saperne di più su come specificare uno schema di tabella, vedi Specificare uno schema.

Dopo aver creato la tabella, puoi caricarla o compilarla scrivendo i risultati della query.

Per creare una tabella vuota con una definizione di schema:

Console

  1. In Google Cloud Console, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni sul set di dati, fai clic su Crea tabella.
  4. Nel riquadro Crea tabella, specifica i seguenti dettagli:
    1. Nella sezione Origine, seleziona Tabella vuota nell'elenco Crea tabella da.
    2. Nella sezione Destinazione, specifica i seguenti dettagli:
      1. Per Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
      2. Nel campo Tabella, inserisci il nome della tabella che vuoi creare.
      3. Verifica che il campo Tipo di tabella sia impostato su Tabella nativa.
    3. Nella sezione Schema, inserisci la definizione di schema. Puoi inserire manualmente le informazioni dello schema utilizzando uno dei seguenti metodi:
      • Opzione 1: fai clic su Modifica come testo e incolla lo schema sotto forma di array JSON. Quando utilizzi un array JSON, generi lo schema seguendo la stessa procedura della creazione di un file di schema JSON. Puoi visualizzare lo schema di una tabella esistente in formato JSON inserendo il seguente comando:
            bq show --format=prettyjson dataset.table
            
      • Opzione 2: fai clic su Aggiungi campo e inserisci lo schema della tabella. Specifica il Nome, il Tipo e la Modalità di ogni campo.
    4. (Facoltativo) Specifica le impostazioni di partizionamento e del cluster. Per ulteriori informazioni, consulta Creazione di tabelle partizionate e Creazione e utilizzo delle tabelle in cluster.
    5. Facoltativo: nella sezione Opzioni avanzate, se vuoi utilizzare una chiave di crittografia gestita dal cliente, seleziona l'opzione Utilizza una chiave di crittografia gestita dal cliente (CMEK). Per impostazione predefinita, BigQuery cripta i contenuti inattivi dei clienti archiviati utilizzando una chiave gestita da Google.
    6. Fai clic su Crea tabella.

SQL

L'esempio seguente crea una tabella denominata newtable che scade il 1° gennaio 2023:

  1. In Google Cloud Console, vai alla pagina BigQuery.

    Vai a BigQuery

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

    CREATE TABLE mydataset.newtable (
      x INT64 OPTIONS (description = 'An optional INTEGER field'),
      y STRUCT <
        a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'),
        b BOOL
      >
    ) OPTIONS (
        expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC',
        description = 'a table that expires in 2023',
        labels = [('org_unit', 'development')]);
    

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, consulta la sezione Esecuzione di query interattive.

bq

Utilizza il comando bq mk con il flag --table o -t. Puoi fornire le informazioni dello schema della tabella in linea o tramite un file di schema JSON. I parametri facoltativi includono:

  • --expiration
  • --description
  • --time_partitioning_field
  • --time_partitioning_type
  • --range_partitioning
  • --clustering_fields
  • --destination_kms_key
  • --label

--time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields e --destination_kms_key non sono dimostrati qui. Per ulteriori informazioni su questi parametri facoltativi, consulta i link riportati di seguito.

Se stai creando una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: project_id:dataset.

Per creare una tabella vuota in un set di dati esistente con una definizione di schema, inserisci quanto segue:

bq mk \
--table \
--expiration integer \
--description description \
--label key_1:value_1 \
--label key_2:value_2 \
project_id:dataset.table \
schema

Sostituisci quanto segue:

  • integer indica la durata predefinita (in secondi) della tabella. Il valore minimo è 3600 secondi (un'ora). La scadenza corrisponde al tempo UTC attuale più il valore intero. Se imposti l'ora di scadenza quando crei una tabella, l'impostazione predefinita di scadenza della tabella del set di dati viene ignorata.
  • description è una descrizione della tabella tra virgolette.
  • key_1:value_1 e key_2:value_2 sono coppie chiave/valore che specificano le etichette.
  • project_id è l'ID progetto.
  • dataset è un set di dati del tuo progetto.
  • table è il nome della tabella che stai creando.
  • schema è una definizione di schema in linea nel formato field:data_type,field:data_type o nel percorso del file di schema JSON sulla macchina locale.

Quando specifichi lo schema nella riga di comando, non puoi includere un tipo RECORD (STRUCT), non puoi includere una descrizione della colonna e la modalità della colonna Il valore predefinito di tutte le modalità è NULLABLE. Per includere descrizioni, modalità e tipi di RECORD, fornisci invece un file di schema JSON.

Esempi:

Inserisci il comando seguente per creare una tabella utilizzando una definizione di schema incorporata. Questo comando crea una tabella denominata mytable in mydataset nel progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization:development. Il comando utilizza la scorciatoia -t anziché --table. Lo schema è specificato in linea come: qtr:STRING,sales:FLOAT,year:STRING.

bq mk \
  -t \
  --expiration 3600 \
  --description "This is my table" \
  --label organization:development \
  mydataset.mytable \
  qtr:STRING,sales:FLOAT,year:STRING

Inserisci il comando seguente per creare una tabella utilizzando un file di schema JSON. Questo comando crea una tabella denominata mytable in mydataset nel progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization:development. Il percorso del file di schema è /tmp/myschema.json.

bq mk \
  --table \
  --expiration 3600 \
  --description "This is my table" \
  --label organization:development \
  mydataset.mytable \
  /tmp/myschema.json

Inserisci il comando seguente per creare una tabella utilizzando un file di schema JSON. Questo comando crea una tabella denominata mytable in mydataset in myotherproject. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta è impostata su organization:development. Il percorso del file di schema è /tmp/myschema.json.

bq mk \
  --table \
  --expiration 3600 \
  --description "This is my table" \
  --label organization:development \
  myotherproject:mydataset.mytable \
  /tmp/myschema.json

Dopo aver creato la tabella, puoi aggiornarne la scadenza, la descrizione e le etichette. Puoi anche modificare la definizione dello schema.

API

Chiama il metodo tables.insert con una risorsa tabella definita.

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API C# di BigQuery.


using Google.Cloud.BigQuery.V2;
using System;

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

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

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
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

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());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

// 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.`);
}

PHP

Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di BigQuery.

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.

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

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Ruby di BigQuery.

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 definizione di schema

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

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 da un risultato della query

Per creare una tabella da un risultato della query, scrivi i risultati in una tabella di destinazione.

Console

  1. Apri la pagina BigQuery in Google Cloud Console.

    Vai alla pagina BigQuery

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

  3. Inserisci una query SQL valida.

  4. Fai clic su Altro e seleziona Impostazioni query.

    Impostazioni query

  5. Seleziona l'opzione Imposta una tabella di destinazione per i risultati della query.

    Imposta destinazione

  6. Nella sezione Destinazione, seleziona il Set di dati in cui vuoi creare la tabella, poi scegli un ID tabella.

  7. Nella sezione Preferenza di scrittura tabella di destinazione, scegli una delle seguenti opzioni:

    • Scrivi se vuoto: scrive i risultati della query nella tabella solo se la tabella è vuota.
    • Aggiungi a tabella: aggiunge i risultati della query a una tabella esistente.
    • Sovrascrivi tabella: sovrascrive una tabella esistente con lo stesso nome utilizzando i risultati della query.
  8. (Facoltativo) Per Località dei dati, scegli la tua località.

  9. Per aggiornare le impostazioni della query, fai clic su Salva.

  10. Fai clic su Esegui. In questo modo viene creato un job di query che scrive i risultati della query nella tabella specificata.

In alternativa, se ti dimentichi di specificare una tabella di destinazione prima di eseguire la query, puoi copiare la tabella dei risultati memorizzati nella cache in una tabella permanente facendo clic sul pulsante Salva risultati sopra l'editor.

SQL

L'esempio seguente utilizza l'istruzione CREATE TABLE per creare la tabella trips dai dati nella tabella bikeshare_trips pubblica:

  1. In Google Cloud Console, vai alla pagina BigQuery.

    Vai a BigQuery

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

    CREATE TABLE mydataset.trips AS (
      SELECT
        bikeid,
        start_time,
        duration_minutes
      FROM
        bigquery-public-data.austin_bikeshare.bikeshare_trips
    );
    

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, consulta la sezione Esecuzione di query interattive.

Per ulteriori informazioni, consulta Creazione di una nuova tabella da una tabella esistente.

bq

Inserisci il comando bq query e specifica il flag --destination_table per creare una tabella permanente in base ai risultati della query. Specifica il flag use_legacy_sql=false per utilizzare la sintassi SQL standard. Per scrivere i risultati della query in una tabella che non è inclusa nel tuo progetto predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

Facoltativo: fornisci il flag --location e imposta il valore sulla tua posizione.

Per controllare la disposizione di scrittura di una tabella di destinazione esistente, specifica uno dei seguenti flag facoltativi:

  • --append_table: se la tabella di destinazione esiste, vengono aggiunti i risultati della query.
  • --replace: se la tabella di destinazione esiste, viene sovrascritta con i risultati della query.
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

Sostituisci quanto segue:

  • location è il nome della località utilizzata per elaborare la query. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nell'area geografica di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando il file .bigqueryrc.
  • project_id è l'ID progetto.
  • dataset è il nome del set di dati che contiene la tabella in cui stai scrivendo i risultati della query.
  • table è il nome della tabella in cui stai scrivendo i risultati della query.
  • query è una query con sintassi SQL standard.

Se non viene specificato alcun flag di scrittura, il comportamento predefinito è scrivere i risultati nella tabella solo se è vuoto. Se la tabella esiste e non è vuota, viene restituito il seguente errore: `Errore BigQuery in operazione query: errore durante l'elaborazione del job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

Esempi:

Inserisci il comando seguente per scrivere i risultati della query in una tabella di destinazione denominata mytable in mydataset. Il set di dati è nel tuo progetto predefinito. Poiché non è specificato alcun flag di disposizione delle operazioni di scrittura, la tabella deve essere nuova o vuota. In caso contrario, viene restituito un errore Already exists. La query recupera i dati dal set di dati pubblico dei dati negli Stati Uniti.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=false \
'SELECT
  name,
  number
FROM
  `bigquery-public-data`.usa_names.usa_1910_current
WHERE
  gender = "M"
ORDER BY
  number DESC'

Inserisci il comando seguente per utilizzare i risultati della query per sovrascrivere una tabella di destinazione denominata mytable in mydataset. Il set di dati è nel tuo progetto predefinito. Il comando utilizza il flag --replace per sovrascrivere la tabella di destinazione.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=false \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

Inserisci il comando seguente per aggiungere risultati di query a una tabella di destinazione denominata mytable in mydataset. Il set di dati si trova in my-other-project, non nel progetto predefinito. Il comando utilizza il flag --append_table per aggiungere i risultati della query alla tabella di destinazione.

bq query \
--append_table \
--use_legacy_sql=false \
--destination_table my-other-project:mydataset.mytable \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

L'output di ciascuno di questi esempi è simile al seguente: Per una migliore leggibilità, alcuni output vengono troncati.

Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

Per salvare i risultati delle query in una tabella permanente, chiama il metodo jobs.insert, configura un job query e includi un valore per la proprietà destinationTable. Per controllare la disposizione di scrittura di una tabella di destinazione esistente, configura la proprietà writeDisposition.

Per controllare la località di elaborazione del job di query, specifica la proprietà location nella sezione jobReference della risorsa job.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

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
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

Per salvare i risultati della query in una tabella permanente, imposta la tabella di destinazione sul valore TableId desiderato in una QueryJobConfiguration.

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());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

// 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}`);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.

Per salvare i risultati della query in una tabella permanente, crea una funzione QueryJobConfig e imposta la destinazione sul valore TableTable desiderato. Passa la configurazione del job al metodo di query.
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))

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

Un'origine dati esterna è un'origine dati su cui puoi eseguire query direttamente da BigQuery, anche se i dati non sono archiviati in BigQuery.

BigQuery supporta le seguenti origini dati esterne:

Per ulteriori informazioni, consulta Introduzione a origini dati esterne.

Creare una tabella quando carichi i dati

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

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

Per ulteriori informazioni sul caricamento dei dati, consulta Introduzione al caricamento dei dati in BigQuery.

Controllare 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 consentito (dal più grande al più basso):

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

L'accesso con qualsiasi risorsa protetta da IAM è cumulative. Ad esempio, se un'entità non ha accesso ad alto livello come un progetto, potresti concedere l'accesso all'entità a livello di set di dati, dopodiché l'entità avrà accesso alle tabelle e alle viste nel set di dati. Allo stesso modo, se l'entità non ha accesso a livello di alto livello o del set di dati, potresti concedere l'accesso all'entità a livello di tabella o vista.

La concessione dei ruoli IAM a un livello superiore nella gerarchia delle risorse di Google Cloud, ad esempio a livello di progetto, cartella o organizzazione, fornisce all'entità l'accesso a un set di risorse ampio. Ad esempio, se concedi un ruolo a un'entità a livello di progetto, le autorizzazioni dell'entità che si applicano a tutti i set di dati dell'intero progetto.

La concessione di un ruolo a livello di set di dati specifica le operazioni che un'entità è autorizzata a eseguire su tabelle e visualizzazioni in quel set di dati specifico, anche se l'entità non dispone dell'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à è autorizzata a eseguire su tabelle e viste specifiche, anche se non dispone dell'accesso a un livello superiore. Per informazioni sulla configurazione dei controlli di accesso 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 concesse dipendono dalle operazioni specifiche che vuoi che l'entità sia in grado di eseguire.

Non puoi impostare un'autorizzazione di tipo "deny"; per qualsiasi risorsa protetta da IAM.

Per maggiori informazioni su ruoli e autorizzazioni, consulta la sezione Informazioni sui ruoli nella documentazione IAM e i ruoli e autorizzazioni IAM di BigQuery.

Chiedi informazioni sulle tabelle

Puoi ottenere informazioni o metadati sulle tabelle nei seguenti modi:

  • Utilizzando la console Google Cloud.
  • Utilizzando lo strumento a riga di comando bq bq show.
  • Chiamata al metodo API tables.get.
  • Utilizzo delle librerie client.
  • Esecuzione della query sulle viste INFORMATION_SCHEMA (beta).

Autorizzazioni obbligatorie

Come minimo, per ottenere informazioni sulle tabelle, devi disporre di 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 di 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 ulteriori informazioni sui ruoli IAM e sulle autorizzazioni in BigQuery, consulta la pagina Controllo dell'accesso.

Ricevere informazioni sulla tabella

Per ottenere informazioni sulle tabelle:

Console

  1. Nella sezione Risorse del pannello di navigazione, espandi il progetto e seleziona un set di dati.

  2. Fai clic sul nome del set di dati per espanderlo. Vengono visualizzate le tabelle e le viste nel set di dati.

  3. Fai clic sul nome della tabella.

  4. Nel riquadro Dettagli, fai clic su Dettagli per visualizzare la descrizione della tabella e le relative informazioni.

  5. Facoltativamente, passa alla scheda Schema per visualizzare la definizione dello schema della tabella.

bq

Esegui il comando bq show per visualizzare tutte le informazioni della tabella. Utilizza il flag --schema per visualizzare solo le informazioni sugli schemi delle tabelle. Il flag --format può essere utilizzato per controllare l'output.

Se ricevi informazioni su una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: project_id:dataset.

bq show \
--schema \
--format=prettyjson \
project_id:dataset.table

Dove:

  • project_id è l'ID progetto.
  • dataset è il nome del set di dati.
  • table è il nome della tabella.

Esempi:

Inserisci il comando seguente per visualizzare tutte le informazioni su mytable in mydataset. mydataset è nel progetto predefinito.

bq show --format=prettyjson mydataset.mytable

Inserisci il comando seguente per visualizzare tutte le informazioni su mytable in mydataset. mydataset si trova in myotherproject, non nel progetto predefinito.

bq show --format=prettyjson myotherproject:mydataset.mytable

Inserisci il comando seguente per visualizzare solo le informazioni sullo schema relative a mytable in mydataset. mydataset si trova in myotherproject, non nel progetto predefinito.

bq show --schema --format=prettyjson myotherproject:mydataset.mytable

API

Chiama il metodo tables.get e fornisci eventuali parametri pertinenti.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

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
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

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());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

// 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();

PHP

Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di BigQuery.

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.


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

Recupera informazioni sulla tabella utilizzando INFORMATION_SCHEMA

INFORMATION_SCHEMA è una serie di viste che forniscono accesso a metadati relativi a set di dati, routine, tabelle, viste, job, prenotazioni e flussi di dati.

Per ottenere informazioni sulle tabelle, puoi eseguire query sulle seguenti viste:

  • 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 sulle colonne (campi) in una tabella.
  • Utilizza le viste INFORMATION_SCHEMA.TABLE_STORAGE e INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_* per recuperare i metadati sull'utilizzo attuale e storico dello spazio di archiviazione da una tabella.

Le viste TABLES e TABLE_OPTIONS contengono anche informazioni generali sulle viste. Per informazioni dettagliate, esegui una query sulla visualizzazione INFORMATION_SCHEMA.VIEWS.

TABLES vista

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

La vista INFORMATION_SCHEMA.TABLES ha il seguente schema:

Nome colonna Tipo di dati Valore
table_catalog STRING L'ID del progetto che contiene il set di dati.
table_schema STRING Il nome del set di dati che contiene la tabella o la vista. Chiamato anche datasetId.
table_name STRING Il nome della tabella o della visualizzazione. Chiamato anche tableId.
table_type STRING Il tipo di tabella; uno dei seguenti:
is_insertable_into STRING YES o NO a seconda che la tabella supporti le istruzioni DML INSERT
is_typed STRING Il valore è sempre NO
creation_time TIMESTAMP L'ora di creazione della tabella
ddl STRING L'istruzione DDL che può essere utilizzata per ricreare la tabella, come CREATE TABLE o CREATE VIEW
clone_time TIMESTAMP Per i cloni delle tabelle (anteprima), il momento in cui la tabella di base è stata clonata per creare questa tabella. Se è stato utilizzato il viaggio nel tempo, questo campo contiene il timestamp del viaggio nel tempo. In caso contrario, il campo clone_time è uguale al campo creation_time. Applicabile solo alle tabelle con table_type impostato su CLONE.
base_table_catalog STRING Per i cloni delle tabelle (Anteprima), il progetto della tabella di base. Applicabile solo alle tabelle con table_type impostato su CLONE.
base_table_schema STRING Per i cloni delle tabelle (Anteprima), il set di dati della tabella di base. Applicabile solo alle tabelle con il valore table_type impostato su CLONE.
base_table_name STRING Per i cloni delle tabelle (Anteprima), il nome della tabella di base. Applicabile solo alle tabelle con il valore table_type impostato su CLONE.
default_collation_name STRING Il nome della specifica di confronto predefinita, se esistente; altrimenti, NULL.

Esempi

Esempio 1:

L'esempio seguente recupera i metadati della tabella per tutte le tabelle nel set di dati denominato mydataset. La query seleziona tutte le colonne dalla vista INFORMATION_SCHEMA.TABLES ad eccezione di is_typed, che è riservata per l'uso futuro. I metadati restituiti vengono visualizzati per tutti i tipi di tabelle in mydataset nel progetto predefinito.

mydataset contiene le seguenti tabelle:

  • mytable1: una tabella BigQuery standard
  • myview1: una visualizzazione 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
    * EXCEPT(is_typed)
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES;

Il risultato è simile al seguente. Per una migliore 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 tutte le tabelle di tipo BASE TABLE dalla visualizzazione INFORMATION_SCHEMA.TABLES. La colonna is_typed è esclusa. I metadati restituiti sono per le tabelle in mydataset del 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
    * EXCEPT(is_typed)
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'BASE TABLE';

Il risultato è simile al seguente. Per una migliore 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-31 22:40:05 | CREATE TABLE myproject.mydataset.mytable1 |
  |                |               |                |            |                    |                     | (                                           |
  |                |               |                |            |                    |                     |   id INT64                                  |
  |                |               |                |            |                    |                     | );                                          |
  +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
  

Esempio 3:

L'esempio seguente recupera le colonne table_name e ddl dalla visualizzazione 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 del set di dati pubblico BigQuery.

Poiché la tabella su cui stai eseguendo query è 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 vista

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 in un set di dati. Per informazioni dettagliate sulle viste, esegui una query sulla vista INFORMATION_SCHEMA.VIEWS.

La vista INFORMATION_SCHEMA.TABLE_OPTIONS ha il seguente schema:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto che contiene il set di dati
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella o la vista, noto anche come datasetId
TABLE_NAME STRING Il nome della tabella o della visualizzazione, noto anche come tableId
OPTION_NAME STRING Uno dei valori del nome nella tabella delle opzioni
OPTION_TYPE STRING Uno dei valori del tipo di dati nella tabella delle opzioni
OPTION_VALUE STRING Una delle opzioni di valore nella tabella delle opzioni
Tabella opzioni
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 La durata predefinita, in giorni, di tutte le partizioni in una tabella partizionata
expiration_timestamp FLOAT64 L'ora di scadenza della tabella
kms_key_name STRING Il nome della chiave Cloud KMS utilizzata per criptare la tabella
friendly_name STRING Il nome descrittivo della tabella
description STRING Una descrizione della tabella
labels ARRAY<STRUCT<STRING, STRING>> Un array di STRUCT's che rappresentano le etichette nella tabella
require_partition_filter BOOL Indica se le query sulla tabella richiedono un filtro di partizione
enable_refresh BOOL Indica se è abilitato l'aggiornamento automatico per una vista materializzata
refresh_interval_minutes FLOAT64 La frequenza di aggiornamento di una vista materializzata

Per le tabelle esterne sono disponibili le seguenti opzioni:

Opzioni
allow_jagged_rows

BOOL

Se true, consenti le righe senza colonne finali facoltative.

Si applica ai dati CSV.

allow_quoted_newlines

BOOL

Se true, consenti nel file le sezioni di dati tra virgolette che contengono caratteri di nuova riga.

Si applica ai dati CSV.

compression

STRING

Il tipo di compressione dell'origine dati. I valori supportati includono: GZIP. Se non è specificato, l'origine dati non è compressa.

Si applica ai dati CSV e JSON.

description

STRING

Una descrizione della tabella.

enable_logical_types

BOOL

Se true, converti i tipi logici di Avro nei tipi SQL corrispondenti. Per ulteriori informazioni, consulta Tipi di log.

Si applica ai dati di Avro.

enum_as_string

BOOL

Se true, deduci il tipo logico ENUM Parquet come STRING invece di BYTES per impostazione predefinita.

Si applica ai dati Parquet.

enable_list_inference

BOOL

Se true, utilizza l'inferenza schema specificamente per il tipo logico Parquet LIST.

Si applica ai dati Parquet.

encoding

STRING

La codifica dei caratteri dei dati. I valori supportati includono: UTF8 (o UTF-8), ISO_8859_1 (o ISO-8859-1).

Si applica ai dati CSV.

expiration_timestamp

TIMESTAMP

L'ora di scadenza della tabella. Se non specificato, la tabella non scade.

Esempio: "2025-01-01 00:00:00 UTC".

field_delimiter

STRING

Il separatore per i campi in un file CSV.

Si applica ai dati CSV.

format

STRING

Il formato dei dati esterni. I valori supportati per CREATE EXTERNAL TABLE includono: AVRO, CSV, DATASTORE_BACKUP, GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (o JSON), ORC, PARQUET, CLOUD_BIGTABLE.

I valori supportati per LOAD DATA includono: AVRO, CSV, NEWLINE_DELIMITED_JSON (o JSON), ORC, PARQUET.

Il valore JSON equivale a NEWLINE_DELIMITED_JSON.

decimal_target_types

ARRAY<STRING>

Determina come convertire un tipo di Decimal. Equivalente a ExternalDataConfiguration.decimal_target_types

Esempio: ["NUMERIC", "BIGNUMERIC"].

json_extension

STRING

Per i dati JSON, indica un particolare formato di scambio JSON. Se non specificato, BigQuery legge i dati come record JSON generici.

I valori supportati includono:
GEOJSON. Dati GeoJSON delimitati da righe. Per ulteriori informazioni, consulta la sezione Creare una tabella esterna da un file GeoJSON delimitato da nuova riga.

hive_partition_uri_prefix

STRING

Un prefisso comune per tutti gli URI di origine prima dell'inizio della codifica della chiave di partizione. Si applica solo alle tabelle esterne partizionate da hive.

Si applica ai dati Avro, CSV, JSON, Parquet e ORC.

Esempio: "gs://bucket/path".

ignore_unknown_values

BOOL

Se true, ignora i valori aggiuntivi che non sono rappresentati nello schema della tabella, senza restituire un errore.

Si applica ai dati CSV e JSON.

max_bad_records

INT64

Il numero massimo di record non validi da ignorare durante la lettura dei dati.

Si applica a: CSV, JSON e dati di Fogli.

null_marker

STRING

La stringa che rappresenta i valori NULL in un file CSV.

Si applica ai dati CSV.

preserve_ascii_control_characters

BOOL

Se true, vengono conservati i caratteri di controllo ASCII incorporati, che sono i primi 32 caratteri della tabella ASCII, compresa tra '\x00' e '\x1F'.

Si applica ai dati CSV.

projection_fields

STRING

Elenco di proprietà dell'entità da caricare.

Si applica ai dati del datastore.

quote

STRING

La stringa utilizzata per citare le sezioni di dati in un file CSV. Se i dati contengono caratteri di nuova riga tra virgolette, imposta anche la proprietà allow_quoted_newlines su true.

Si applica ai dati CSV.

reference_file_schema_uri

STRING

File di riferimento fornito dall'utente con lo schema della tabella.

Si applica ai dati Parquet/ORC/AVRO.

Esempio: "gs://bucket/path/reference_schema_file.parquet".

require_hive_partition_filter

BOOL

Se true, tutte le query su questa tabella richiedono un filtro di partizione che può essere utilizzato per eliminare le partizioni durante la lettura dei dati. Si applica solo alle tabelle esterne partizionate da hive.

Si applica ai dati Avro, CSV, JSON, Parquet e ORC.

sheet_range

STRING

Intervallo di un foglio di lavoro di Fogli da cui eseguire la query.

Si applica ai dati di Fogli.

Esempio: “sheet1!A1:B20”,

skip_leading_rows

INT64

Il numero di righe nella parte superiore di un file da saltare durante la lettura dei dati.

Si applica ai dati CSV e Fogli.

uris

Per le tabelle esterne che non sono tabelle Cloud Bigtable:

ARRAY<STRING>

Un array di URI completi per le posizioni dei dati esterni.

Esempio: ["gs://bucket/path1/*", "gs://bucket/path2/*"].


Per le tabelle Bigtable:

STRING

L'URI che identifica la tabella Bigtable da utilizzare come origine dati. Puoi specificare un solo URI Bigtable.

Esempio: https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Per ulteriori informazioni sulla creazione di un URI Bigtable, consulta la pagina Recupero dell'URI Bigtable.

bigtable_options

STRING

Obbligatorio solo quando si crea una tabella esterna Bigtable.

Specifica lo schema della tabella esterna Bigtable in formato JSON.

Per un elenco di opzioni di definizione della tabella Bigtable, consulta BigtableOptions nel riferimento API REST.

Esempi

Esempio 1:

L'esempio seguente recupera i tempi predefiniti per le tabelle predefinite per tutte le tabelle in mydataset nel progetto predefinito (myproject) eseguendo una query sulla visualizzazione 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 i dati di test. La query utilizza i valori nell'opzione description per trovare tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset è incluso nel 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 vista

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

La vista INFORMATION_SCHEMA.COLUMNS ha il seguente schema:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto che contiene il set di dati
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella è denominato anche datasetId
TABLE_NAME STRING Il nome della tabella o della visualizzazione, noto anche come tableId
COLUMN_NAME STRING Il nome della colonna
ORDINAL_POSITION INT64 Lo scostamento indicizzato della colonna all'interno della tabella; se si tratta di una pseudo-colonna come _PARTITIONTIME o _PARTITIONDATE, il valore è NULL
IS_NULLABLE STRING YES o NO a seconda che la modalità della colonna consenta i valori NULL
DATA_TYPE STRING Il tipo di dati SQL standard della colonna.
IS_GENERATED STRING Il valore è sempre NEVER
GENERATION_EXPRESSION STRING Il valore è sempre NULL
IS_STORED STRING Il valore è sempre NULL
IS_HIDDEN STRING YES o NO a seconda che la colonna sia una pseudo-colonna come _PARTITIONTIME o _PARTITIONDATE
IS_UPDATABLE STRING Il valore è sempre NULL
IS_SYSTEM_DEFINED STRING YES o NO a seconda che la colonna sia una pseudo-colonna come _PARTITIONTIME o _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES o NO a seconda che la colonna sia una colonna partizionata
CLUSTERING_ORDINAL_POSITION INT64 L'offset indicizzato con 1 della colonna all'interno delle colonne di clustering della tabella. Il valore è NULL se la tabella non è una tabella in cluster.
COLLATION_NAME STRING Il nome della specifica di confronto se esiste; in caso contrario, NULL

Se viene passato un valore STRING o ARRAY<STRING>, viene inviata la specifica di confronto; in caso contrario, viene restituito NULL
COLUMN_DEFAULT STRING Il valore predefinito della colonna, se esistente; altrimenti, il valore è NULL

Esempi

L'esempio seguente recupera i metadati dalla visualizzazione 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 del set di dati pubblico BigQuery.

Poiché la tabella su cui stai eseguendo query è in un altro progetto, il progetto bigquery-public-data aggiungerai 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.

Le seguenti colonne sono escluse dai risultati della query perché al momento sono prenotate per l'uso futuro:

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE
  SELECT
    * EXCEPT(is_generated, generation_expression, is_stored, 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 una migliore 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 |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
  

COLUMN_FIELD_PATHS vista

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

La vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS ha il seguente schema:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto che contiene il set di dati
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella è denominato anche datasetId
TABLE_NAME STRING Il nome della tabella o della visualizzazione, noto anche come tableId
COLUMN_NAME STRING Il nome della colonna
FIELD_PATH STRING Il percorso di una colonna nidificato all'interno di una colonna"RECORD"o"STRUCT".
DATA_TYPE STRING Il tipo di dati standard della colonna SQL.
DESCRIPTION STRING La descrizione della colonna
COLLATION_NAME STRING Il nome della specifica di confronto se esiste; in caso contrario, NULL

Se viene passato un campo STRING, ARRAY<STRING> o STRING in un STRUCT, viene inviata la specifica di confronto; in caso contrario, NULL viene restituito

Esempi

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

Poiché la tabella su cui stai eseguendo query è in un altro progetto, il progetto bigquery-public-data aggiungerai 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 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 delle colonne author e difference, esegui la query seguente.

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 una migliore leggibilità, alcune colonne sono escluse dal risultato.

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

TABLE_STORAGE vista

La vista INFORMATION_SCHEMA.TABLE_STORAGE ha il seguente schema:

Nome colonna Tipo di dati Valore
PROJECT_ID STRING L'ID del progetto che contiene il set di dati
PROJECT_NUMBER INT64 Il numero del progetto contenente il set di dati
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella o la vista materializzata, noto anche come datasetId
TABLE_NAME STRING Il nome della tabella o della vista materializzata, noto anche come tableId
CREATION_TIME TIMESTAMP L'ora di creazione della tabella
TOTAL_ROWS INT64 Il numero totale di righe nella tabella o nella vista materializzata
TOTAL_PARTITIONS INT64 Il numero di partizioni presenti nella tabella o nella vista materializzata. Le tabelle non partizionate restituiscono 0.
TOTAL_LOGICAL_BYTES INT64 Numero totale di byte logici (non compressi) nella tabella o nella visualizzazione materializzata
ACTIVE_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) precedenti a 90 giorni
LONG_TERM_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) più vecchi di 90 giorni
TOTAL_PHYSICAL_BYTES INT64 Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi byte attivi, a lungo termine e nel tempo (per tabelle eliminate)
ACTIVE_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) risalenti a meno di 90 giorni fa
LONG_TERM_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) più vecchi di 90 giorni
TIME_TRAVEL_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione nel tempo (dati eliminati o modificati)

Esempi

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:

+---------------------+---------------------+
|     project_id      | total_logical_bytes |
+---------------------+---------------------+
| projecta            |     971329178274633 |
+---------------------+---------------------+

TABLE_STORAGE_TIMELINE_BY_* visualizzazione

Le visualizzazioni della sequenza temporale dello spazio di archiviazione della tabella restituiscono una riga per ogni evento che attiva una modifica dello spazio di archiviazione per la tabella, ad esempio la scrittura, l'aggiornamento o l'eliminazione di una riga. Ciò significa che possono esserci più righe per una tabella per un solo giorno. Quando esegui una query su una vista per un intervallo di tempo, utilizza il timestamp più recente nel giorno dell'interesse.

Questa visualizzazione presenta il seguente schema:

Nome colonna Tipo di dati Valore
TIMESTAMP TIMESTAMP Timestamp relativo al momento dell'ultimo calcolo dello spazio di archiviazione. Il ricalcolo viene attivato da modifiche ai dati nella tabella.
DELETED BOOLEAN Indica se la tabella è stata eliminata o meno
PROJECT_ID STRING L'ID del progetto che contiene il set di dati
PROJECT_NUMBER INT64 Il numero del progetto contenente il set di dati
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella o la vista materializzata, noto anche come datasetId
TABLE_NAME STRING Il nome della tabella o della vista materializzata, noto anche come tableId
CREATION_TIME TIMESTAMP L'ora di creazione della tabella
TOTAL_ROWS INT64 Il numero totale di righe nella tabella o nella vista materializzata
TOTAL_PARTITIONS INT64 Il numero di partizioni per la tabella o la vista materializzata. Le tabelle non partizionate restituiranno 0.
TOTAL_LOGICAL_BYTES INT64 Numero totale di byte logici (non compressi) nella tabella o nella visualizzazione materializzata
ACTIVE_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) precedenti a 90 giorni
LONG_TERM_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) più vecchi di 90 giorni
TOTAL_PHYSICAL_BYTES INT64 Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi byte attivi, a lungo termine e nel tempo (per tabelle eliminate)
ACTIVE_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) risalenti a meno di 90 giorni fa
LONG_TERM_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) più vecchi di 90 giorni
TIME_TRAVEL_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione nel tempo (dati eliminati o modificati)

Esempi

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto nel seguente formato:

PROJECT_ID.DATASET_ID.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
Sostituisci quanto segue:

  • PROJECT_ID: l'ID del progetto.
  • DATASET_ID: l'ID del set di dati.

Ad esempio: myproject.mydataset.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION.

L'esempio seguente mostra la somma dello spazio di archiviazione fisico utilizzato da ciascun progetto nell'organizzazione in un determinato momento:

WITH most_recent_records as (
  SELECT
    project_id,
    table_schema,
    table_name,
    MAX(timestamp) as max_timestamp
  FROM
    `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
  WHERE
    timestamp <= 'TIMESTAMP'
  GROUP BY
    project_id, table_schema, table_name
  )
  SELECT
    i_s.project_id,
    SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes
  FROM
    `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s
  JOIN
    most_recent_records
  ON
    i_s.project_id = most_recent_records.project_id
    AND i_s.table_schema = most_recent_records.table_schema
    AND i_s.table_name = most_recent_records.table_name
    AND i_s.timestamp = most_recent_records.max_timestamp
  GROUP BY
    project_id;

Il risultato è simile al seguente:

-----------------+------------------------+
|  project_id    |  TotalPhysicalBytes    |
+----------------+------------------------+
| projecta       | 3844                   |
| projectb       | 16022778               |
| projectc       | 8934009                |
+----------------+------------------------+

Elenca tabelle in un set di dati

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

  • Utilizzando la console Google Cloud.
  • Utilizzando lo strumento a riga di comando bq bq ls.
  • Chiamata al metodo API tables.list.
  • Utilizzo delle librerie client.

Autorizzazioni obbligatorie

Come minimo, per elencare le tabelle in un set di dati, devi disporre 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 ulteriori informazioni sui ruoli IAM e sulle autorizzazioni in BigQuery, consulta la pagina Controllo dell'accesso.

Elenca tabelle

Per elencare le tabelle in un set di dati:

Console

  1. In Google Cloud Console, nel riquadro di navigazione, fai clic sul set di dati per espanderlo. Vengono visualizzate le tabelle e le viste nel set di dati.

  2. Scorri l'elenco per visualizzare le tabelle nel set di dati. Le tabelle e le viste sono identificate da icone diverse.

bq

Esegui il comando bq ls. Il flag --format può essere utilizzato per controllare l'output. Se hai elencato tabelle in un progetto diverso da quello predefinito, aggiungi l'ID progetto al set di dati nel seguente formato: project_id:dataset.

Ulteriori flag includono:

  • --max_results o -n: un numero intero che indica il numero massimo di risultati. Il valore predefinito è 50.
bq ls \
--format=pretty \
--max_results integer \
project_id:dataset

Dove:

  • integer è un numero intero che rappresenta il numero di tabelle da elencare.
  • project_id è l'ID progetto.
  • dataset è il nome del set di dati.

Quando esegui il comando, nel campo Type viene visualizzato TABLE o VIEW. Ad esempio:

+-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

Esempi:

Inserisci il comando seguente per elencare le tabelle nel set di dati mydataset nel progetto predefinito.

    bq ls --format=pretty mydataset

Inserisci il comando seguente per restituire un numero di output superiore a quello predefinito di 50 tabelle da mydataset. mydataset è nel progetto predefinito.

    bq ls --format=pretty --max_results 60 mydataset

Inserisci il comando seguente per elencare le tabelle nel set di dati mydataset in myotherproject.

    bq ls --format=pretty myotherproject:mydataset

API

Per elencare le tabelle utilizzando l'API, chiama il metodo tables.list.

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API C# di BigQuery.


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.");
        }
    }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

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
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

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());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

// 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));
}

PHP

Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di BigQuery.

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.


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

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Ruby di BigQuery.

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

Sicurezza delle tabelle

Per controllare l'accesso alle tabelle in BigQuery, consulta Introduzione ai controlli di accesso alle tabelle.

Passaggi successivi

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare le prestazioni di BigQuery in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova BigQuery gratuitamente