Creare e utilizzare le tabelle

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

Dopo aver creato una tabella, puoi:

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

Per ulteriori informazioni sulla gestione delle tabelle, ad esempio l'aggiornamento delle proprietà delle tabelle, la copia e l'eliminazione delle tabelle, consulta Gestire le tabelle.

Prima di iniziare

Prima di creare una tabella in BigQuery:

Denominazione delle tabelle

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

  • Contenere caratteri per un totale massimo di 1024 byte UTF-8.
  • Contengono caratteri Unicode della categoria L (lettera), M (segno), N (numero), Pc (connettore, incluso il trattino basso), Pd (tratto), Zs (spazio). Per ulteriori informazioni, consulta la sezione Categoria generale.

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

Limitazioni:

  • I nomi delle tabelle sono sensibili alle maiuscole per impostazione predefinita. mytable e MyTable possono coesistere nello stesso set di dati, a meno che non facciano parte di un set di dati con la sensibilità alle maiuscole disattivata.
  • Alcuni nomi di tabelle e prefissi dei nomi di tabelle sono riservati. Se viene visualizzato un messaggio di errore che indica che il nome o il prefisso della tabella è riservato, seleziona un nome diverso e riprova.
  • Se includi più operatori punto (.) in una sequenza, gli operatori duplicati vengono rimossi implicitamente.

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

    Diventa: project_name.dataset_name.table_name

Creare tabelle

Puoi creare una tabella in BigQuery nei seguenti modi:

  • Utilizzo manuale della console Google Cloud o dello strumento a riga di comando bq bq mk.
  • In modo programmatico chiamando il metodo dell'API tables.insert.
  • Utilizzando le librerie client.
  • Dai risultati della query.
  • Definisci una tabella che fa riferimento a un'origine dati esterna.
  • Quando carichi i dati.
  • Utilizzando un'istruzione DDL (Data Definition Language) 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 richiedere l'autorizzazione bigquery.tables.getData per accedere ai dati che scrivi 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 dello schema

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

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

Per ulteriori informazioni su come specificare uno schema di tabella, consulta Specificare uno schema.

Una volta creata la tabella, puoi caricarvi i dati o completarla scrivendo i risultati delle query.

Per creare una tabella vuota con una definizione dello schema:

Console

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

    Vai a BigQuery

  2. Nel riquadro Explorer, espandi il progetto e seleziona un set di dati.
  3. Nella sezione Informazioni 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. In Set di dati, seleziona il set di dati in cui vuoi creare la tabella.
      2. Nel campo Table (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 dello 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 utilizzando la stessa procedura utilizzata per creare 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 Nome, Tipo e Modalità di ogni campo.
    4. (Facoltativo) Specifica le impostazioni di partizionamento e clustering. Per ulteriori informazioni, consulta Creare tabelle partizionate e Creare e utilizzare 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 dei clienti archiviati in stato inattivo utilizzando una chiave di proprietà di Google e 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. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nell'editor di 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 query, consulta Eseguire una query interattiva.

bq

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

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Utilizza il comando bq mk con il flag --table o -t. Puoi fornire le informazioni sullo schema della tabella in linea o con un file di schema JSON. Per un elenco completo dei parametri, consulta la documentazione di riferimento di bq mk --table. Alcuni 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 mostrati qui. Per ulteriori informazioni su questi parametri facoltativi, consulta i seguenti link:

    Se crei 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 \
    --add_tags=key_3:value_3[,...] \
    project_id:dataset.table \
    schema

    Sostituisci quanto segue:

    • integer è la durata predefinita (in secondi) della tabella. Il valore minimo è 3600 secondi (un'ora). La scadenza viene valutata come l'ora UTC corrente più il valore intero. Se imposti la data e l'ora di scadenza quando crei una tabella, l'impostazione predefinita 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.
    • key_3:value_3 sono coppie chiave-valore che specificano i tag. Aggiungi più tag nello stesso flag con virgole tra le coppie chiave:valore.
    • project_id è l'ID progetto.
    • dataset è un set di dati nel 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 il percorso del file dello schema JSON sul computer locale.

    Quando specifichi lo schema sulla riga di comando, non puoi includere un tipo RECORD (STRUCT), una descrizione della colonna e non puoi specificare la modalità della colonna. Per impostazione predefinita, tutte le modalità sono impostate su NULLABLE. Per includere descrizioni, modi e tipi di RECORD, fornisci un file di schema JSON.

    Esempi:

    Inserisci il seguente comando per creare una tabella utilizzando una definizione di schema in linea. Questo comando crea una tabella denominata mytable in mydataset nel tuo progetto predefinito. La scadenza della tabella è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my table e l'etichetta su organization:development. Il comando utilizza la scorciatoia -t anziché --table. Lo schema viene 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 seguente comando 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 su This is my table e l'etichetta su organization:development. Il percorso del file dello schema è /tmp/myschema.json.

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

    Inserisci il seguente comando 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 su This is my table e l'etichetta su organization:development. Il percorso del file dello schema è /tmp/myschema.json.

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

    Una volta creata la tabella, puoi aggiornarne la scadenza, la descrizione e le etichette. Puoi anche modificare la definizione dello schema.

Terraform

Utilizza la risorsa google_bigquery_table.

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

Creare una tabella

Il seguente esempio crea una tabella denominata mytable:

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

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

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

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

}

Creare una tabella e concederne l'accesso

L'esempio seguente crea una tabella denominata mytable e poi utilizza la risorsa google_bigquery_table_iam_policy per concedervi l'accesso. Esegui questo passaggio solo se vuoi concedere l'accesso alla tabella a entità che non hanno accesso al set di dati in cui risiede la tabella.

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

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

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

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

}

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

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

Creare una tabella con una chiave di crittografia gestita dal cliente

L'esempio seguente crea una tabella denominata mytable e utilizza anche le risorse google_kms_crypto_key e google_kms_key_ring per specificare una chiave Cloud Key Management Service per la tabella. Devi abilitare l'API Cloud Key Management Service prima di eseguire questo esempio.

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

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

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

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

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

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

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

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

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

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

Per applicare la configurazione Terraform in un progetto Google Cloud, completa i passaggi nelle seguenti sezioni.

Prepara Cloud Shell

  1. Avvia Cloud Shell.
  2. Imposta il progetto Google Cloud predefinito in cui vuoi applicare le configurazioni Terraform.

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

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione di Terraform deve avere una propria directory (chiamata anche modulo principale).

  1. In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
    mkdir DIRECTORY && cd DIRECTORY && touch main.tf
  2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

    Copia il codice campione nel main.tf appena creato.

    Se vuoi, copia il codice da GitHub. Questa opzione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

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

    Se vuoi, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade:

    terraform init -upgrade

Applica le modifiche

  1. Rivedi la configurazione e verifica che le risorse che Terraform sta per creare o aggiornare corrispondano alle tue aspettative:
    terraform plan

    Apporta le correzioni necessarie alla configurazione.

  2. Applica la configurazione di Terraform eseguendo il seguente comando e inserendo yes al prompt:
    terraform apply

    Attendi che Terraform mostri il messaggio "Applicazione completata".

  3. Apri il tuo progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

API

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

C#

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

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


using Google.Cloud.BigQuery.V2;

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

Vai

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

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

import (
	"context"
	"fmt"
	"time"

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

// 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 Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

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

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 Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

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

// Import the Google Cloud client library 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 PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

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

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 Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

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

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 Ruby riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Ruby.

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

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

Creare una tabella vuota senza una definizione dello schema

Java

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

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

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

Creare una tabella da un risultato di query

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

Console

  1. Apri la pagina BigQuery nella console Google Cloud.

    Vai alla pagina BigQuery

  2. Nel riquadro Spazio di esplorazione, 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.

    Impostare la destinazione

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

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

    • Scrive se vuota: scrive i risultati della query nella tabella solo se la tabella è vuota.
    • Aggiungi alla tabella: aggiunge i risultati della query a una tabella esistente.
    • Sovrascrive 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. Viene creato un job di query che scrive i risultati della query nella tabella specificata.

In alternativa, se 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 della tabella pubblica bikeshare_trips:

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

    Vai a BigQuery

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

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

  3. Fai clic su Esegui.

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

Per ulteriori informazioni, consulta la sezione Creare una nuova tabella da una tabella esistente.

bq

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

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. 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 GoogleSQL. Per scrivere i risultati della query in una tabella che non si trova nel 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 l'impostazione di scrittura per una tabella di destinazione esistente, specifica uno dei seguenti flag facoltativi:

    • --append_table: se la tabella di destinazione esiste, i risultati della query vengono aggiunti.
    • --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 nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la posizione 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 in sintassi GoogleSQL.

      Se non viene specificato alcun flag di impostazione di scrittura, il comportamento predefinito è scrivere i risultati nella tabella solo se è vuota. Se la tabella esiste e non è vuota, viene restituito il seguente errore: BigQuery error in query operation: Error processing 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 si trova nel tuo progetto predefinito. Poiché nel comando non è specificato alcun flag di impostazione 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 USA Name Data.

      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 seguente comando per utilizzare i risultati della query per sovrascrivere una tabella di destinazione denominata mytable in mydataset. Il set di dati si trova nel 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 seguente comando per accodare i risultati della query a una tabella di destinazione denominata mytable in mydataset. Il set di dati si trova in my-other-project, non nel tuo progetto predefinito. Il comando utilizza il flag --append_table per accodare 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 è il seguente. Per motivi di leggibilità, parte dell'output è troncata.

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

API

Per salvare i risultati della query in una tabella permanente, chiama il metodo jobs.insert, configura un job query e includi un valore per la proprietà destinationTable. Per controllare l'impostazione di scrittura per 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.

Vai

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

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

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 Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

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

Per salvare i risultati della query in una tabella permanente, imposta la tabella di destinazione sul TableId desiderato in un 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 Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

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

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

async function 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 Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

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

Per salvare i risultati della query in una tabella permanente, crea un QueryJobConfig e imposta la destinazione sul TableReference desiderato. Passa la configurazione del job al metodo 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 in cui puoi eseguire query direttamente da BigQuery, anche se i dati non vengono archiviati in BigQuery. Ad esempio, potresti avere dati in un database Google Cloud diverso, in file in Cloud Storage o in un prodotto cloud diverso che vorresti analizzare in BigQuery, ma non avere ancora la possibilità di eseguire una migrazione.

Per ulteriori informazioni, consulta Introduzione alle 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 accodare i dati a una tabella o partizione esistente o puoi sovrascrivere una tabella o una partizione. Non è necessario creare una tabella vuota prima di caricarvi i dati. Puoi creare la nuova tabella e caricare i dati contemporaneamente.

Quando carichi i dati in BigQuery, puoi fornire lo schema della tabella o della partizione oppure, per i formati 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 visualizzazioni, puoi concedere un ruolo IAM a un'entità ai seguenti livelli, elencati in ordine di intervallo di risorse consentito (dal più grande al più piccolo):

  • un livello elevato della gerarchia delle risorse Google Cloud, come il livello di progetto, cartella o organizzazione
  • a livello di set di dati
  • il livello della tabella o della visualizzazione

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

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

La concessione di ruoli IAM a un livello superiore nella gerarchia delle risorse di Google Cloud, ad esempio a livello di progetto, cartella o organizzazione, consente all'entità di accedere a un insieme ampio di risorse. Ad esempio, l'assegnazione di un ruolo a un'entità a livello di progetto assegna a quell'entità le autorizzazioni che si applicano a tutti i set di dati del progetto.

La concessione di un ruolo a livello di set di dati specifica le operazioni che un'entità è autorizzata a eseguire sulle tabelle e sulle visualizzazioni in quel set di dati specifico, anche se l'entità non ha accesso a un livello superiore. Per informazioni sulla configurazione dei controlli di accesso a livello di set di dati, consulta Controllare l'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 l'entità non ha 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 IAM personalizzati. Se crei un ruolo personalizzato, le autorizzazioni che concedi dipendono dalle operazioni specifiche che vuoi che l'entità possa eseguire.

Non puoi impostare un'autorizzazione di tipo "deny" su nessuna risorsa protetta da IAM.

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

Visualizzare informazioni sulle tabelle

Puoi ottenere informazioni o metadati sulle tabelle nei seguenti modi:

  • Utilizzando la console Google Cloud.
  • Utilizzo del comando bq show dello strumento a riga di comando bq.
  • Chiamata del metodo dell'API tables.get.
  • Utilizzo delle librerie client.
  • Esegui una query sulla vista INFORMATION_SCHEMA.VIEWS.

Autorizzazioni obbligatorie

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

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

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

Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.

Ottenere informazioni sulla tabella

Per informazioni sulle tabelle:

Console

  1. Nel pannello di navigazione, nella sezione Risorse, 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 visualizzazioni nel set di dati.

  3. Fai clic sul nome della tabella.

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

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

bq

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

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Esegui il comando bq show per visualizzare tutte le informazioni della tabella. Utilizza il flag --schema per visualizzare solo le informazioni sullo schema della tabella. 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 seguente comando per visualizzare tutte le informazioni su mytable in mydataset. mydataset si trova nel tuo progetto predefinito.

    bq show --format=prettyjson mydataset.mytable

    Inserisci il seguente comando 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 seguente comando per visualizzare solo le informazioni sullo schema relative a mytable in mydataset. mydataset si trova in myotherproject, non nel tuo progetto predefinito.

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

API

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

Vai

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

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

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 Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

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

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 Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

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

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

async function 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 PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

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

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 Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

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


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

Ottenere informazioni sulla tabella utilizzando INFORMATION_SCHEMA

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

Puoi eseguire query sulle seguenti viste per ottenere informazioni sulle tabelle:

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

Le visualizzazioni TABLES e TABLE_OPTIONS contengono anche informazioni di alto livello sulle visualizzazioni. Per informazioni dettagliate, esegui una query sulla vista INFORMATION_SCHEMA.VIEWS.

TABLES visualizzazione

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

La vista INFORMATION_SCHEMA.TABLES ha lo schema seguente:

Nome colonna Tipo di dati Valore
table_catalog STRING L'ID del progetto contenente il set di dati.
table_schema STRING Il nome del set di dati contenente la tabella o la visualizzazione. 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
is_change_history_enabled STRING YES o NO a seconda che sia attivata o meno la modifica della cronologia.
creation_time TIMESTAMP L'ora di creazione della tabella
base_table_catalog STRING Per i cloni di tabelle e gli snapshot delle tabelle, il progetto della tabella di base. Applicabile solo alle tabelle con table_type impostato su CLONE o SNAPSHOT.
base_table_schema STRING Per i cloni di tabelle e gli snapshot delle tabelle, il set di dati della tabella di base. Applicabile solo alle tabelle con table_type impostato su CLONE o SNAPSHOT.
base_table_name STRING Per i cloni di tabella e gli snapshot di tabella, il nome della tabella di base. Applicabile solo alle tabelle con table_type impostato su CLONE o SNAPSHOT.
snapshot_time_ms TIMESTAMP Per i cloni di tabelle e gli snapshot di tabelle, l'ora in cui è stata eseguita l'operazione di clonazione o di snapshot sulla tabella di base 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 snapshot_time_ms è uguale al campo creation_time. Applicabile solo alle tabelle con table_type impostato su CLONE o SNAPSHOT.
replica_source_catalog STRING Per le repliche delle viste materializzate, il progetto della vista materializzata di base.
replica_source_schema STRING Per le repliche delle viste materializzate, il set di dati della vista materializzata di base.
replica_source_name STRING Per le repliche delle viste materializzate, il nome della vista materializzata di base.
replication_status STRING Per le repliche delle viste materializzate, lo stato della replica dalla vista materializzata di base alla replica della vista materializzata; uno dei seguenti:
  • REPLICATION_STATUS_UNSPECIFIED
  • ACTIVE: la replica è attiva senza errori
  • SOURCE_DELETED: la vista materializzata di origine è stata eliminata
  • PERMISSION_DENIED: la vista materializzata di origine non è stata autorizzata nel set di dati contenente le tabelle BigLake di Amazon S3 di origine utilizzate nella query che ha creato la vista materializzata.
  • UNSUPPORTED_CONFIGURATION: si è verificato un problema con i prerequisiti della replica, diversi dall'autorizzazione della vista materializzata di origine.
replication_error STRING Se replication_status indica un problema di replica per una replica della vista materializzata, replication_error fornisce ulteriori dettagli sul problema.
ddl STRING L'istruzione DDL che può essere utilizzata per ricreare la tabella, ad esempio CREATE TABLE o CREATE VIEW
default_collation_name STRING Il nome della specifica di regole di confronto predefinita se esistente; in caso contrario, NULL.
upsert_stream_apply_watermark TIMESTAMP Per le tabelle che utilizzano la tecnologia Change Data Capture (CDC), l'ora dell'ultima applicazione delle modifiche alle righe. Per ulteriori informazioni, consulta Monitorare l'avanzamento dell'operazione di upsert della tabella.

Esempi

Esempio 1:

L'esempio seguente recupera i metadati delle tabelle per tutte le tabelle nel set di dati denominato mydataset. I metadati che vengono restituito si riferiscono a tutti i tipi di tabelle in mydataset nel progetto predefinito.

mydataset contiene le seguenti tabelle:

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

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

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

Il risultato è simile al seguente. Per una maggiore leggibilità, alcune colonne vengono escluse dal risultato.

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

L'esempio seguente recupera i metadati delle tabelle per tutte le tabelle di tipo CLONE o SNAPSHOT dalla visualizzazione INFORMATION_SCHEMA.TABLES. I metadati restituiti si riferiscono alle tabelle in mydataset nel tuo progetto predefinito.

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

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

Il risultato è simile al seguente. Per una maggiore leggibilità, alcune colonne vengono escluse dal risultato.

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

Esempio 3:

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

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

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

Il risultato è simile al seguente:

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

TABLE_OPTIONS visualizzazione

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

La vista INFORMATION_SCHEMA.TABLE_OPTIONS ha lo schema seguente:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto contenente 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
OPTION_NAME STRING Uno dei valori di 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 delle opzioni

OPTION_NAME

OPTION_TYPE

OPTION_VALUE

description

STRING

Una descrizione della tabella

enable_refresh

BOOL

Indica se l'aggiornamento automatico è abilitato per una vista materializzata

expiration_timestamp

TIMESTAMP

L'ora di scadenza di questa tabella

friendly_name

STRING

Il nome descrittivo della tabella

kms_key_name

STRING

Il nome della chiave Cloud KMS utilizzata per criptare la tabella

labels

ARRAY<STRUCT<STRING, STRING>>

Un array di STRUCT che rappresentano le etichette nella tabella

partition_expiration_days

FLOAT64

La durata predefinita, in giorni, di tutte le partizioni di una tabella partizionata

refresh_interval_minutes

FLOAT64

La frequenza di aggiornamento di una vista materializzata

require_partition_filter

BOOL

Indica se le query sulla tabella richiedono un filtro di partizionamento

tags

ARRAY<STRUCT<STRING, STRING>>

Tag associati a una tabella in una sintassi <key, value> con spazio dei nomi. Per ulteriori informazioni, consulta Tag e accesso condizionale.

Per le tabelle esterne sono possibili le seguenti opzioni:

Opzioni
allow_jagged_rows

BOOL

Se true, consenti le righe che non hanno le colonne finali facoltative.

Si applica ai dati CSV.

allow_quoted_newlines

BOOL

Se true, consenti nel file sezioni di dati tra virgolette contenenti caratteri di fine riga.

Si applica ai dati CSV.

bigtable_options

STRING

Obbligatorio solo per la creazione di una tabella esterna Bigtable.

Specifica lo schema della tabella esterna Bigtable in formato JSON.

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

column_name_character_map

STRING

Definisce l'ambito dei caratteri supportati per i nomi colonna e la modalità di gestione dei caratteri non supportati. L'impostazione predefinita è STRICT, il che significa che i caratteri non supportati causano l'emissione di errori da parte di BigQuery. V1 e V2 sostituiscono eventuali caratteri non supportati con trattini bassi.

I valori supportati sono:

  • STRICT. Attiva i nomi delle colonne flessibili. Questo è il valore predefinito. I job di caricamento con caratteri non supportati nei nomi delle colonne non vanno a buon fine e viene visualizzato un messaggio di errore. Per configurare la sostituzione dei caratteri non supportati con gli underscore in modo che il job di caricamento vada a buon fine, specifica l'impostazione di configurazione default_column_name_character_map.
  • V1. I nomi delle colonne possono contenere solo caratteri standard per i nomi delle colonne. I caratteri non supportati vengono sostituiti con trattini bassi. Questo è il comportamento predefinito per le tabelle create prima dell'introduzione di column_name_character_map.
  • V2. Oltre ai caratteri dei nomi delle colonne standard, supporta anche nomi delle colonne flessibili. I caratteri non supportati vengono sostituiti con trattini bassi.
  • Si applica ai dati CSV e Parquet.

compression

STRING

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

Si applica ai dati CSV e JSON.

decimal_target_types

ARRAY<STRING>

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

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

description

STRING

Una descrizione di questa tabella.

enable_list_inference

BOOL

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

Si applica ai dati Parquet.

enable_logical_types

BOOL

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

Si applica ai dati Avro.

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.

enum_as_string

BOOL

Se true, deduco il tipo logico ENUM di Parquet come STRING instead of BYTES per impostazione predefinita.

Si applica ai dati Parquet.

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, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (anteprima), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (o JSON), ORC, PARQUET.

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

Il valore JSON è equivalente a NEWLINE_DELIMITED_JSON.

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

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

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

file_set_spec_type

STRING

Specifica come interpretare gli URI di origine per i job di caricamento e le tabelle esterne.

I valori supportati sono:

  • FILE_SYSTEM_MATCH. Espande gli URI di origine elencando i file dall'object store. Questo è il comportamento predefinito se FileSetSpecType non è impostato.
  • NEW_LINE_DELIMITED_MANIFEST. Indica che gli URI forniti sono file manifest delimitati da riga nuova, con un URI per riga. Gli URI con caratteri jolly non sono supportati nei file manifest e tutti i file di dati a cui viene fatto riferimento devono trovarsi nello stesso bucket del file manifest.

Ad esempio, se hai un URI di origine "gs://bucket/path/file" e file_set_spec_type è FILE_SYSTEM_MATCH, il file viene utilizzato direttamente come file di dati. Se file_set_spec_type è NEW_LINE_DELIMITED_MANIFEST, ogni riga del file viene interpretata come un URI che rimanda a un file di dati.

ignore_unknown_values

BOOL

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

Si applica ai dati CSV e JSON.

json_extension

STRING

Per i dati JSON, indica un determinato formato di interscambio JSON. Se non viene specificato, BigQuery legge i dati come record JSON generici.

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

max_bad_records

INT64

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

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

max_staleness

INTERVAL

Applicabile per tabelle BigLake e tabelle degli oggetti.

Specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella e quanto devono essere aggiornati per poter essere utilizzati dall'operazione.

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

Per attivare la memorizzazione nella cache dei metadati, specifica un valore di letterale intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se sono stati aggiornati nelle ultime 4 ore. Se i metadati memorizzati nella cache sono precedenti a questa data, l'operazione ricorre al recupero dei metadati da Cloud Storage.

null_marker

STRING

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

Si applica ai dati CSV.

object_metadata

STRING

Obbligatorio solo per la creazione di una tabella di oggetti.

Imposta il valore di questa opzione su SIMPLE quando crei una tabella di oggetti.

preserve_ascii_control_characters

BOOL

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

Si applica ai dati CSV.

projection_fields

STRING

Un elenco di proprietà delle entità da caricare.

Si applica ai dati di Datastore.

quote

STRING

La stringa utilizzata per citare le sezioni di dati in un file CSV. Se i dati contengono caratteri di a capo 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 Hive.

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

sheet_range

STRING

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

Si applica ai dati di Fogli Google.

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 di Fogli Google.

uris

Per le tabelle esterne, incluse le tabelle di oggetti, che non sono tabelle Bigtable:

ARRAY<STRING>

Un array di URI completi per le posizioni dei dati esterni. Ogni URI può contenere un asterisco (*) carattere jolly, che deve trovarsi dopo il nome del bucket. Quando specifichi valori uris che hanno come target più file, tutti questi file devono condividere uno schema compatibile.

Gli esempi seguenti mostrano valori uris validi:

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

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 Recupero dell'URI Bigtable.

Esempi

Esempio 1:

L'esempio seguente recupera le date di scadenza predefinite delle tabelle 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 di tutte le tabelle in mydataset che contengono dati di test. La query utilizza i valori dell'opzione description per trovare le tabelle che contengono "test" in qualsiasi punto della descrizione. mydataset si trova 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 visualizzazione

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

La vista INFORMATION_SCHEMA.COLUMNS ha lo schema seguente:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto contenente il set di dati
TABLE_SCHEMA STRING Il nome del set di dati contenente la tabella, chiamato anche il datasetId
TABLE_NAME STRING Il nome della tabella o della visualizzazione, chiamato anche tableId
COLUMN_NAME STRING Il nome della colonna
ORDINAL_POSITION INT64 L'offset indicizzato per 1 della colonna all'interno della tabella. Se si tratta di una colonna pseudo come _PARTITIONTIME o _PARTITIONDATE, il valore è NULL
IS_NULLABLE STRING YES o NO a seconda che la modalità della colonna consenta valori NULL
DATA_TYPE STRING Il tipo di dati GoogleSQL 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 pseudocolonna 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 pseudocolonna come _PARTITIONTIME o _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES o NO a seconda che la colonna sia una colonna di partizionamento
CLUSTERING_ORDINAL_POSITION INT64 L'offset con indice 1 della colonna all'interno delle colonne di clustering della tabella. Il valore è NULL se la tabella non è una tabella raggruppata
COLLATION_NAME STRING Il nome della specifica di ordinamento se esistente; altrimenti NULL

Se viene passato un valore STRING o ARRAY<STRING>, viene restituita la specifica di ordinamento se esistente; altrimenti viene restituito NULL
COLUMN_DEFAULT STRING Il valore predefinito della colonna, se esistente; in caso contrario, il valore è NULL
ROUNDING_MODE STRING La modalità di arrotondamento utilizzata per i valori scritti nel campo se il suo tipo è un NUMERIC o BIGNUMERIC parametrizzato; in caso contrario, il valore è NULL

Esempi

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

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

Le seguenti colonne sono escluse dai risultati della query perché attualmente sono riservate per un 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 maggiore leggibilità, alcune colonne vengono 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 visualizzazione

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

La vista INFORMATION_SCHEMA.COLUMN_FIELD_PATHS ha lo schema seguente:

Nome colonna Tipo di dati Valore
TABLE_CATALOG STRING L'ID del progetto contenente il set di dati
TABLE_SCHEMA STRING Il nome del set di dati contenente la tabella, chiamato anche il datasetId
TABLE_NAME STRING Il nome della tabella o della visualizzazione, chiamato anche tableId
COLUMN_NAME STRING Il nome della colonna
FIELD_PATH STRING Il percorso di una colonna nidificata all'interno di una colonna "RECORD" o "STRUCT"
DATA_TYPE STRING Il tipo di dati GoogleSQL della colonna
DESCRIPTION STRING La descrizione della colonna
COLLATION_NAME STRING Il nome della specifica di ordinamento se esistente; in caso contrario, NULL

Se viene passato un campo STRING, ARRAY<STRING> o STRING in un STRUCT, viene restituita la specifica di ordinamento se esistente; in caso contrario, viene visualizzatoNULL
ROUNDING_MODE STRING La modalità di arrotondamento utilizzata per applicare la precisione e la scala ai valori NUMERIC o BIGNUMERIC parametroizzati. In caso contrario, il valore è NULL

Esempi

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

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

La tabella commits contiene le seguenti colonne nidificate e ripetute:

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

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

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

Il risultato è simile al seguente. Per una maggiore leggibilità, alcune colonne vengono 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 visualizzazione

Le viste TABLE_STORAGE e TABLE_STORAGE_BY_ORGANIZATION hanno il seguente schema:

Nome colonna Tipo di dati Valore
PROJECT_ID STRING L'ID del progetto contenente il set di dati.
PROJECT_NUMBER INT64 Il numero del progetto contenente il set di dati.
TABLE_CATALOG STRING L'ID del progetto contenente il set di dati.
TABLE_SCHEMA STRING Il nome del set di dati che contiene la tabella o la vista materializzata, chiamato anche datasetId.
TABLE_NAME STRING Il nome della tabella o della vista materializzata, chiamato anche 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 vista materializzata.
ACTIVE_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) risalenti a meno di 90 giorni fa.
LONG_TERM_LOGICAL_BYTES INT64 Numero di byte logici (non compressi) che risalgono a più di 90 giorni fa.
CURRENT_PHYSICAL_BYTES INT64 Numero totale di byte fisici per l'archiviazione corrente della tabella in tutte le partizioni.
TOTAL_PHYSICAL_BYTES INT64 Numero totale di byte fisici (compressi) utilizzati per l'archiviazione, inclusi i byte attivi, a lungo termine e di viaggio nel tempo (dati eliminati o modificati). I byte di fail-safe (dati eliminati o modificati conservati dopo la finestra di time-travel) non sono inclusi.
ACTIVE_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) meno recenti di 90 giorni, inclusi i byte con spostamento cronologico (dati eliminati o modificati).
LONG_TERM_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) risalenti a più di 90 giorni fa.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione del viaggio nel tempo (dati eliminati o modificati).
STORAGE_LAST_MODIFIED_TIME TIMESTAMP L'ora più recente in cui i dati sono stati scritti nella tabella.
DELETED BOOLEAN Indica se la tabella viene eliminata o meno.
TABLE_TYPE STRING Il tipo di tabella. Ad esempio, EXTERNAL o BASE TABLE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Numero di byte fisici (compressi) utilizzati dallo spazio di archiviazione di riserva (dati eliminati o modificati).
LAST_METADATA_INDEX_REFRESH_TIME TIMESTAMP L'ora dell'ultimo aggiornamento dell'indice dei metadati della tabella.

Esempi

Esempio 1:

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

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

Il risultato è simile al seguente:

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Esempio 2:

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

I prezzi utilizzati nelle variabili di prezzo per questa query si riferiscono alla regione us-central1. Se vuoi eseguire questa query per una regione diversa, aggiorna le variabili di prezzo di conseguenza. Per informazioni sui prezzi, vedi Prezzi di archiviazione.

  1. Apri la pagina BigQuery nella console Google Cloud.

    Vai alla pagina BigQuery

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

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

Il risultato è simile al seguente:

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

Elenca le tabelle in un set di dati

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

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

Autorizzazioni obbligatorie

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

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

Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, consulta Controllo dell'accesso.

Elenca tabelle

Per elencare le tabelle in un set di dati:

Console

  1. Nella console Google Cloud, nel riquadro di navigazione, fai clic sul set di dati per espanderlo. Vengono visualizzate le tabelle e le visualizzazioni nel set di dati.

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

bq

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

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

    Altri 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, il campo Type mostra 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 tuo progetto predefinito.

       bq ls --format=pretty mydataset

    Inserisci il seguente comando per restituire più dell'output predefinito di 50 tabelle da mydataset. mydataset si trova nel tuo progetto predefinito.

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

    Inserisci il seguente comando per elencare le tabelle del 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 C# riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery C#.

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


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

Vai

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

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

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 Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

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

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 Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

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

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

async function 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 PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

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

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 Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

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


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 Ruby riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Ruby.

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

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