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

Specifica di uno schema

BigQuery ti consente di specificare lo schema di una tabella quando carichi dati in una tabella e quando crei una tabella vuota. In alternativa, puoi utilizzare il rilevamento automatico dello schema per i formati di dati supportati.

Quando carichi i file di esportazione Avro, Parquet, ORC, Firestore o Datastore, lo schema viene recuperato automaticamente dai dati di origine autodescrittivi.

Puoi specificare lo schema di una tabella nei seguenti modi:

  • Specifica manualmente lo schema:
    • Tramite la console Google Cloud.
    • In linea utilizzando lo strumento a riga di comando bq.
    • Utilizzare l'istruzione SQL CREATE TABLE.
  • Creare un file di schema in formato JSON.
  • Chiama il metodo jobs.insert e configura la proprietà schema nella configurazione del job load.
  • Chiama il metodo tables.insert e configura lo schema nella risorsa della tabella utilizzando la proprietà schema.

Dopo aver caricato i dati o creato una tabella vuota, puoi modificare la definizione dello schema della tabella.

Componenti dello schema

Quando specifichi uno schema di tabella, devi fornire il nome e il tipo di dati di ogni colonna. Puoi anche specificare la descrizione, la modalità e il valore predefinito di una colonna.

Nomi colonne

Il nome della colonna deve contenere solo lettere (a-z, A-Z), numeri (0-9) o trattini bassi (_) e deve iniziare con una lettera o un trattino basso. La lunghezza massima del nome della colonna è di 300 caratteri. Il nome di una colonna non può utilizzare i seguenti prefissi:

  • _TABLE_
  • _FILE_
  • _PARTITION
  • _ROW_TIMESTAMP
  • __ROOT__
  • _COLIDENTIFIER

Non sono consentiti nomi di colonna duplicati anche se differiscono da maiuscole e minuscole. Ad esempio, una colonna denominata Column1 è considerata identica a una colonna denominata column1.

Descrizioni delle colonne

Ogni colonna può includere una descrizione facoltativa. La descrizione è una stringa con una lunghezza massima di 1024 caratteri.

Tipi di dati SQL standard di Google

Google Standard SQL ti consente di specificare i seguenti tipi di dati nel tuo schema. Il tipo di dati è obbligatorio.

Nome Tipo di dati Descrizione
Intero INT64 Valori numerici senza componenti frazionari
Valore in virgola mobile FLOAT64 Valori numerici approssimativi con componenti frazionari
Numerico NUMERIC Valori numerici esatti con componenti frazionari
Numeriche grandi BIGNUMERIC Valori numerici esatti con componenti frazionari
Booleano BOOL TRUE o FALSE (senza distinzione tra maiuscole e minuscole)
Stringa STRING Dati relativi ai caratteri a lunghezza variabile (Unicode)
Byte BYTES Dati binari a lunghezza variabile
Date DATE Una data logica del calendario.
Data/ora DATETIME Un anno, un mese, un giorno, un'ora, un minuto, un secondo e un secondo
Ora TIME Una data, indipendentemente da una data specifica
Timestamp TIMESTAMP Un momento assoluto, con una precisione di microsecondi
Struct (Registra) STRUCT Contenitore dei campi ordinati, ciascuno con un tipo (obbligatorio) e un nome di campo (facoltativo)
Area geografica GEOGRAPHY Un punto sulla superficie terrestre (un insieme di punti, linee e poligoni sullo sferoide di riferimento WGS84, con bordi geodetici)
JSON JSON Rappresenta JSON, un formato leggero di interscambio dati

Per ulteriori informazioni sui tipi di dati in Google Standard SQL, vedi Tipi di dati di Google Standard SQL.

Puoi anche dichiarare un tipo di array quando esegui query sui dati. Per ulteriori informazioni, consulta la pagina relativa all'utilizzo degli array.

Modalità

BigQuery supporta le seguenti modalità per le colonne. La modalità è facoltativa. Se la modalità non è specificata, il valore predefinito della colonna è NULLABLE.

Modalità Descrizione
Ammette valori Null La colonna consente valori NULL (valore predefinito)
Obbligatoria I valori NULL non sono consentiti
Repeated La colonna contiene una matrice di valori del tipo specificato

Per saperne di più sulle modalità, vedi mode in TableFieldSchema.

Modalità di arrotondamento

Se una colonna è di tipo NUMERIC o BIGNUMERIC con parametri, puoi impostare l'opzione di colonna rounding_mode, che determina il modo in cui i valori in quella colonna vengono arrotondati quando vengono scritti nella tabella. Puoi impostare l'opzione rounding_mode in una colonna di primo livello o in un campo STRUCT. Sono supportate le seguenti modalità di arrotondamento:

  • "ROUND_HALF_AWAY_FROM_ZERO": questa modalità (impostazione predefinita) arrotonda a metà i casi da zero.
  • "ROUND_HALF_EVEN": questa modalità arrotonda la metà per le maiuscole verso la cifra pari più vicina.

Impossibile impostare l'opzione rounding_mode per una colonna di tipo NUMERIC o BIGNUMERIC. Per informazioni sul comportamento dell'arrotondamento per questi tipi, consulta Tipi di decimali con parametri.

L'esempio seguente crea una tabella e inserisce valori arrotondati in base alla modalità di arrotondamento della colonna:

CREATE TABLE mydataset.mytable (
  x NUMERIC(5,2) OPTIONS (rounding_mode='ROUND_HALF_EVEN'),
  y NUMERIC(5,2) OPTIONS (rounding_mode='ROUND_HALF_AWAY_FROM_ZERO')
);
INSERT mydataset.mytable (x, y)
VALUES (NUMERIC "1.025", NUMERIC "1.025"),
       (NUMERIC "1.0251", NUMERIC "1.0251"),
       (NUMERIC "1.035", NUMERIC "1.035"),
       (NUMERIC "-1.025", NUMERIC "-1.025");

La tabella mytable ha il seguente aspetto:

+-------+-------+
| x     | y     |
+-------+-------+
| 1.02  | 1.03  |
| 1.03  | 1.03  |
| 1.04  | 1.04  |
| -1.02 | -1.03 |
+-------+-------+

Per maggiori informazioni, consulta roundingMode in TableFieldSchema.

Specificare manualmente gli schemi

Quando carichi i dati o crei una tabella vuota, puoi specificare manualmente lo schema della tabella utilizzando la console Google Cloud o lo strumento a riga di comando bq. La specifica manuale di uno schema è supportata quando carichi i file CSV e JSON (delimitato da nuova riga). Quando carichi i dati di esportazione Avro, Parquet, ORC, Firestore o Datastore, lo schema viene recuperato automaticamente dai dati di origine autodescrittivi.

Per specificare manualmente uno schema di tabella:

Console

Nella console Google Cloud, puoi specificare uno schema utilizzando l'opzione Aggiungi campo o l'opzione Modifica come testo.

  1. Nella console Google Cloud, apri la pagina BigQuery.

    Vai a BigQuery

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

  3. Espandi l'opzione Azioni e fai clic su Apri.

  4. Nel riquadro dei dettagli, fai clic su Crea tabella .

  5. Nella pagina Crea tabella, nella sezione Origine, seleziona Tabella vuota.

  6. Nella pagina Crea tabella, nella sezione Destinazione:

    • In Nome set di dati, scegli il set di dati appropriato

      Seleziona il set di dati.

    • Nel campo Nome tabella, inserisci il nome della tabella che stai creando.

    • Verifica che Tipo di tabella sia impostato su Tabella nativa.

  7. Nella sezione Schema, inserisci la definizione di schema.

    • Opzione 1: utilizza il campo Aggiungi campo e specifica il nome, il tipo e la modalità di ogni campo.
    • Opzione 2: fai clic su Modifica come testo e incolla lo schema sotto forma di array array JSON. Quando usi un array JSON, generi lo schema utilizzando la stessa procedura della creazione di un file di schema JSON.
  8. Fai clic su Crea tabella.

SQL

Utilizza l'istruzione CREATE TABLE. Specifica lo schema utilizzando l'opzione colonna. L'esempio seguente crea una nuova tabella denominata newtable con le colonne x, y, z dei tipi interi, stringhe e booleani:

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

    Vai a BigQuery

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

    CREATE TABLE IF NOT EXISTS mydataset.newtable (x INT64, y STRING, z BOOL)
      OPTIONS(
        description = 'My example table');
    

  3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, vedi Esecuzione di query interattive.

bq

Fornisci manualmente lo schema in linea nel formato field:data_type,field:data_type utilizzando uno dei seguenti comandi:

  • Se stai caricando i dati, utilizza il comando bq load.
  • Se stai creando una tabella vuota, utilizza il comando bq mk.

Quando specifichi lo schema dalla riga di comando, non puoi includere il tipo RECORD (STRUCT), non la descrizione della colonna e la modalità della colonna. Tutte le modalità sono impostate in modo predefinito su NULLABLE. Per includere descrizioni, modalità e tipi RECORD, fornisci invece un file schema JSON.

Per caricare i dati in una tabella utilizzando una definizione di schema in linea, inserisci il comando load e specifica il formato dei dati utilizzando il flag --source_format. Se stai caricando dati in una tabella di un progetto diverso da quello predefinito, includi l'ID progetto nel seguente formato: project_id:dataset.table_name.

(Facoltativo) Fornisci il flag --location e imposta il valore sulla tua località.

bq --location=location load \
--source_format=format \
project_id:dataset.table_name \
path_to_source \
schema

Sostituisci quanto segue:

  • location: il nome della località. 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 località utilizzando il file.bigqueryrc.
  • format: NEWLINE_DELIMITED_JSON o CSV.
  • project_id: l'ID del tuo progetto.
  • dataset: il set di dati che contiene la tabella in cui stai caricando i dati.
  • table_name: il nome della tabella in cui stai caricando i dati.
  • path_to_source: la posizione del file di dati CSV o JSON sulla macchina locale o in Cloud Storage.
  • schema: definizione dello schema incorporato.

Esempio:

Inserisci questo comando per caricare i dati da un file CSV locale denominato myfile.csv in mydataset.mytable nel progetto predefinito. Lo schema viene specificato manualmente in linea.

bq load \
--source_format=CSV \
mydataset.mytable \
./myfile.csv \
qtr:STRING,sales:FLOAT,year:STRING

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

Per specificare una definizione di schema in linea quando crei una tabella vuota, inserisci il comando bq mk con il flag --table o -t. Se stai creando una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al comando nel seguente formato: project_id:dataset.table.

bq mk --table project_id:dataset.table schema

Sostituisci quanto segue:

  • project_id: l'ID del tuo progetto.
  • dataset: un set di dati nel tuo progetto.
  • table: il nome della tabella che stai creando.
  • schema: una definizione di schema incorporata.

Ad esempio, il comando seguente crea una tabella vuota denominata mytable nel progetto predefinito. Lo schema viene specificato manualmente in linea.

bq mk --table mydataset.mytable qtr:STRING,sales:FLOAT,year:STRING

Per ulteriori informazioni sulla creazione di una tabella vuota, consulta Creazione di una tabella vuota con una definizione di schema.

C#

Per specificare lo schema di una tabella quando carichi i dati in una tabella:


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsJson
{
    public void LoadTableGcsJson(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.NewlineDelimitedJson
        };
        // Create and run job
        BigQueryJob loadJob = client.CreateLoadJob(
            sourceUri: gcsURI, destination: destinationTableRef,
            schema: schema, options: jobOptions);
        loadJob = loadJob.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

Per specificare uno schema quando crei una tabella vuota:


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

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

Go

Per specificare lo schema di una tabella quando carichi i dati in una tabella:

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
	}
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Per specificare uno schema quando crei una tabella vuota:

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

Per specificare lo schema di una tabella quando carichi i dati in una tabella:

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.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCS {

  public static void runLoadJsonFromGCS() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCS(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCS(
      String datasetName, String tableName, String sourceUri, 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);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Json from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Per specificare uno schema quando crei una tabella vuota:

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

Python

Per specificare lo schema di una tabella quando carichi i dati in una tabella, configura la proprietà LoadJobConfig.schema.

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"

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    table_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Per specificare uno schema quando crei una tabella vuota, configura la proprietà Table.schema.

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

Specificare un file di schema JSON

Se preferisci, puoi specificare lo schema utilizzando un file di schema JSON anziché una definizione di schema incorporata. Un file di schema JSON è costituito da un array JSON che contiene quanto segue:

  • Il nome della colonna
  • Il tipo di dati della colonna.
  • Facoltativo: la modalità della colonna (se non specificata, la modalità è predefinita su NULLABLE)
  • Facoltativo: i campi della colonna se è di tipo STRUCT
  • Facoltativo: la descrizione della colonna
  • Facoltativo: i tag di criteri della colonna, utilizzati per il controllo dell'accesso a livello di campo
  • Facoltativo: la lunghezza massima dei valori della colonna per i tipi STRING o BYTES
  • Facoltativo: la precisione della colonna per i tipi NUMERIC o BIGNUMERIC
  • (Facoltativo) La scala della colonna per i tipi NUMERIC o BIGNUMERIC
  • Facoltativo: le regole di confronto della colonna per i tipi di STRING
  • (Facoltativo) Il valore predefinito della colonna
  • (Facoltativo) La modalità di arrotondamento della colonna, se è di tipo NUMERIC o BIGNUMERIC parametrizzato.

Creazione di un file di schema JSON

Per creare un file di schema JSON, inserisci TableFieldSchema per ogni colonna. I campi name e type sono obbligatori. Tutti gli altri campi sono facoltativi.

[
  {
    "name": string,
    "type": string,
    "mode": string,
    "fields": [
      {
        object (TableFieldSchema)
      }
    ],
    "description": string,
    "policyTags": {
      "names": [
        string
      ]
    },
    "maxLength": string,
    "precision": string,
    "scale": string,
    "collation": string,
    "defaultValueExpression": string,
    "roundingMode": string
  },
  {
    "name": string,
    "type": string,
    ...
  }
]
L'array JSON è indicato dalle parentesi di inizio e fine `[]`. Ogni voce di colonna deve essere separata da una virgola: `},`. Puoi scrivere uno schema di tabella esistente in un file locale inserendo il seguente comando:
bq show \
--schema \
--format=prettyjson \
project_id:dataset.table > path_to_file

Puoi utilizzare il file di output come punto di partenza per il tuo file di schema JSON. Se utilizzi questo approccio, assicurati che il file contenga solo l'array JSON che rappresenta lo schema della tabella.

Ad esempio, il seguente array JSON rappresenta uno schema di tabella di base. Questo schema ha tre colonne: qtr (REQUIRED STRING), rep (NULLABLE STRING) e sales (NULLABLE FLOAT).

[
  {
    "name": "qtr",
    "type": "STRING",
    "mode": "REQUIRED",
    "description": "quarter"
  },
  {
    "name": "rep",
    "type": "STRING",
    "mode": "NULLABLE",
    "description": "sales representative"
  },
  {
    "name": "sales",
    "type": "FLOAT",
    "mode": "NULLABLE",
    "defaultValueExpression": "2.55"
  }
]

usando un file schema JSON.

Dopo aver creato il file di schema JSON, puoi specificarlo utilizzando lo strumento a riga di comando bq. Non puoi utilizzare un file di schema con la console Google Cloud o l'API.

Fornisci manualmente il file di schema:

  • Se stai caricando i dati, utilizza il comando bq load.
  • Se stai creando una tabella vuota, utilizza il comando bq mk.

Quando fornisci un file di schema JSON, devi archiviarlo in una posizione leggibile localmente. Non puoi specificare un file di schema JSON archiviato in Cloud Storage o Google Drive.

Specificare un file di schema quando si caricano i dati

Per caricare i dati in una tabella utilizzando una definizione di schema JSON, procedi come segue:

bq

bq --location=location load \
--source_format=format \
project_id:dataset.table \
path_to_data_file \
path_to_schema_file

Sostituisci quanto segue:

  • location: il nome della località. 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 località utilizzando il file .bigqueryrc.
  • format: NEWLINE_DELIMITED_JSON o CSV.
  • project_id: l'ID del tuo progetto.
  • dataset: il set di dati che contiene la tabella in cui stai caricando i dati.
  • table: il nome della tabella in cui stai caricando i dati.
  • path_to_data_file: la posizione del file di dati CSV o JSON sulla macchina locale o in Cloud Storage.
  • path_to_schema_file: il percorso del file di schema sulla macchina locale.

Esempio:

Inserisci questo comando per caricare i dati da un file CSV locale denominato myfile.csv in mydataset.mytable nel progetto predefinito. Lo schema è specificato in myschema.json nella directory attuale.

bq load --source_format=CSV mydataset.mytable ./myfile.csv ./myschema.json

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di BigQuery all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Python BigQuery.

Per caricare uno schema di tabella da un file JSON utilizzando la libreria client Python, chiama il metodo schema_from_json.
from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change uri variable to the path of your data file.
uri = "gs://your-bucket/path/to/your-file.csv"
# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table"
# TODO(dev): Change schema_path variable to the path of your schema file.
schema_path = "path/to/schema.json"
# To load a schema file use the schema_from_json method.
schema = client.schema_from_json(schema_path)

job_config = bigquery.LoadJobConfig(
    # To use the schema you loaded pass it into the
    # LoadJobConfig constructor.
    schema=schema,
    skip_leading_rows=1,
)

# Pass the job_config object to the load_table_from_file,
# load_table_from_json, or load_table_from_uri method
# to use the schema on a new table.
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

destination_table = client.get_table(table_id)  # Make an API request.
print(f"Loaded {destination_table.num_rows} rows to {table_id}.")

Specificare un file di schema durante la creazione di una tabella

Per creare una tabella vuota in un set di dati esistente utilizzando un file di schema JSON, segui questi passaggi:

bq

bq mk --table project_id:dataset.table path_to_schema_file

Sostituisci quanto segue:

  • project_id: l'ID del tuo progetto.
  • dataset: un set di dati nel tuo progetto.
  • table: il nome della tabella che stai creando.
  • path_to_schema_file: il percorso del file di schema sulla macchina locale.

Ad esempio, il comando seguente crea una tabella denominata mytable in mydataset nel progetto predefinito. Lo schema è specificato in myschema.json nella directory attuale:

bq mk --table mydataset.mytable ./myschema.json

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di BigQuery all'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Python BigQuery.

Per caricare uno schema di tabella da un file JSON utilizzando la libreria client Python, chiama il metodo schema_from_json.
from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table_name"
# TODO(dev): Change schema_path variable to the path of your schema file.
schema_path = "path/to/schema.json"
# To load a schema file use the schema_from_json method.
schema = client.schema_from_json(schema_path)

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # API request
print(f"Created table {table_id}.")

Specifica di uno schema nell'API

Specifica uno schema di tabella tramite l'API:

La specifica di uno schema mediante l'API è simile alla procedura per la creazione di un file di schema JSON.

Sicurezza delle tabelle

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

Passaggi successivi