Crie tabelas agrupadas

Pode reduzir a quantidade de dados processados por uma consulta através de tabelas agrupadas no BigQuery.

Com as tabelas agrupadas, os dados das tabelas são organizados com base nos valores das colunas especificadas, também denominadas colunas de agrupamento. O BigQuery ordena os dados pelas colunas agrupadas e, em seguida, armazena as linhas com valores semelhantes nos blocos físicos iguais ou próximos. Quando uma consulta filtra uma coluna agrupada, o BigQuery analisa de forma eficiente apenas os blocos relevantes e ignora os dados que não correspondem ao filtro.

Para mais informações, consulte o seguinte:

Antes de começar

Funções necessárias

Para receber as autorizações de que precisa para criar uma tabela, peça ao seu administrador que lhe conceda as seguintes funções do IAM:

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Estas funções predefinidas contêm as autorizações necessárias para criar uma tabela. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações para criar uma tabela:

  • bigquery.tables.create no conjunto de dados onde está a criar a tabela.
  • bigquery.tables.getData em todas as tabelas e vistas a que a sua consulta faz referência se estiver a guardar os resultados da consulta como uma tabela.
  • bigquery.jobs.create no projeto, se estiver a criar a tabela carregando dados ou guardando resultados de consultas numa tabela.
  • bigquery.tables.updateData na tabela se estiver a anexar ou substituir uma tabela com resultados da consulta.

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Requisitos de nomenclatura de tabelas

Quando cria uma tabela no BigQuery, o nome da tabela tem de ser único por conjunto de dados. O nome da tabela pode:

  • Conter carateres com um total de até 1024 bytes UTF-8.
  • Conter carateres Unicode nas categorias L (letra), M (marca), N (número), Pc (conetor, incluindo sublinhado), Pd (travessão) e Zs (espaço). Para mais informações, consulte Categoria geral.

Seguem-se exemplos de nomes de tabelas válidos: table 01, ग्राहक, 00_お客様, étudiant-01.

Advertências:

  • Os nomes das tabelas são sensíveis a maiúsculas e minúsculas por predefinição. mytable e MyTable podem coexistir no mesmo conjunto de dados, a menos que façam parte de um conjunto de dados com a opção de distinção entre maiúsculas e minúsculas desativada.
  • Alguns nomes de tabelas e prefixos de nomes de tabelas são reservados. Se receber um erro a indicar que o nome ou o prefixo da tabela está reservado, selecione um nome diferente e tente novamente.

  • Se incluir vários operadores de ponto (.) numa sequência, os operadores duplicados são removidos implicitamente.

    Por exemplo, isto: project_name....dataset_name..table_name

    Torna-se: project_name.dataset_name.table_name

Requisitos de colunas agrupadas

Pode especificar as colunas usadas para criar a tabela agrupada quando cria uma tabela no BigQuery. Depois de criar a tabela, pode modificar as colunas usadas para criar a tabela agrupada. Para obter detalhes, consulte o artigo Modificar a especificação de agrupamento.

As colunas de agrupamento têm de ser colunas de nível superior, não repetidas e têm de ser um dos seguintes tipos de dados:

  • BIGNUMERIC
  • BOOL
  • DATE
  • DATETIME
  • GEOGRAPHY
  • INT64
  • NUMERIC
  • RANGE
  • STRING
  • TIMESTAMP

Pode especificar até quatro colunas de agrupamento. Quando especifica várias colunas, a ordem das colunas determina a forma como os dados são ordenados. Por exemplo, se a tabela estiver agrupada pelas colunas a, b e c, os dados são ordenados pela mesma ordem: primeiro pela coluna a, depois pela coluna b e, em seguida, pela coluna c. Como prática recomendada, coloque a coluna mais frequentemente filtrada ou agregada em primeiro lugar.

A ordem das colunas de agrupamento também afeta o desempenho das consultas e os preços. Para mais informações sobre as práticas recomendadas de consultas para tabelas agrupadas, consulte o artigo Consultar tabelas agrupadas.

Crie uma tabela agrupada vazia com uma definição de esquema

Para criar uma tabela agrupada vazia com uma definição de esquema:

Consola

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No painel Explorador, expanda o seu projeto e, de seguida, selecione um conjunto de dados.
  3. Na secção Informações do conjunto de dados, clique em Criar tabela.
  4. No painel Criar tabela, especifique os seguintes detalhes:
    1. Na secção Origem, selecione Tabela vazia na lista Criar tabela a partir de.
    2. Na secção Destino, especifique os seguintes detalhes:
      1. Para Conjunto de dados, selecione o conjunto de dados no qual quer criar a tabela.
      2. No campo Tabela, introduza o nome da tabela que quer criar.
      3. Verifique se o campo Tipo de tabela está definido como Tabela nativa.
    3. Na secção Esquema, introduza a definição do esquema. Pode introduzir manualmente informações do esquema através de um dos seguintes métodos:
      • Opção 1: clique em Editar como texto e cole o esquema sob a forma de uma matriz JSON. Quando usa uma matriz JSON, gera o esquema através do mesmo processo que criar um ficheiro de esquema JSON. Pode ver o esquema de uma tabela existente no formato JSON introduzindo o seguinte comando: 
            bq show --format=prettyjson dataset.table
      • Opção 2: clique em Adicionar campo e introduza o esquema da tabela. Especifique o Nome, Tipo e Modo de cada campo.
    4. Para Ordem de agrupamento, introduza entre um e quatro nomes de colunas separados por vírgulas.
    5. Opcional: na secção Opções avançadas, se quiser usar uma chave de encriptação gerida pelo cliente, selecione a opção Usar uma chave de encriptação gerida pelo cliente (CMEK). Por predefinição, o BigQuery encripta o conteúdo do cliente armazenado em repouso através de um Google-owned and Google-managed encryption key.
    6. Clique em Criar tabela.

SQL

Use o comando CREATE TABLE DDL statement com a opção CLUSTER BY. O exemplo seguinte cria uma tabela agrupada com o nome myclusteredtable em mydataset:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, introduza a seguinte declaração:

    CREATE TABLE mydataset.myclusteredtable
(
  customer_id STRING,
  transaction_amount NUMERIC
)
CLUSTER BY
  customer_id
  OPTIONS (
    description = 'a table clustered by customer_id');

  3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

bq

Use o comando bq mk com as seguintes flags:

  • --table (ou o atalho -t).
  • --schema. Pode fornecer a definição do esquema da tabela inline ou usar um ficheiro de esquema JSON.
  • --clustering_fields. Pode especificar até quatro colunas de agrupamento.

Os parâmetros opcionais incluem --expiration, --description, --time_partitioning_type, --time_partitioning_field, --time_partitioning_expiration, --destination_kms_key e --label.

Se estiver a criar uma tabela num projeto que não seja o projeto predefinido, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset.

A funcionalidade --destination_kms_key não é demonstrada aqui. Para obter informações sobre a utilização de --destination_kms_key, consulte o artigo sobre as chaves de encriptação geridas pelo cliente.

Introduza o seguinte comando para criar uma tabela agrupada vazia com uma definição de esquema:

bq mk \
    --table \
    --expiration INTEGER1 \
    --schema SCHEMA \
    --clustering_fields CLUSTER_COLUMNS \
    --description "DESCRIPTION" \
    --label KEY:VALUE,KEY:VALUE \
    PROJECT_ID:DATASET.TABLE

Substitua o seguinte:

  • INTEGER1: o tempo de vida predefinido, em segundos, para a tabela. O valor mínimo é de 3600 segundos (uma hora). O tempo de expiração é avaliado como a hora UTC atual mais o valor inteiro. Se definir a hora de validade da tabela quando cria uma tabela, a definição de validade da tabela predefinida do conjunto de dados é ignorada. Se definir este valor, a tabela é eliminada após o tempo especificado.
  • SCHEMA: uma definição de esquema inline no formato COLUMN:DATA_TYPE,COLUMN:DATA_TYPE ou o caminho para o ficheiro de esquema JSON no seu computador local.
  • CLUSTER_COLUMNS: uma lista separada por vírgulas de até quatro colunas de agrupamento. A lista não pode conter espaços.
  • DESCRIPTION: uma descrição da tabela entre aspas.
  • KEY:VALUE: o par de chave-valor que representa uma etiqueta. Pode introduzir várias etiquetas através de uma lista separada por vírgulas.
  • PROJECT_ID: o ID do seu projeto.
  • DATASET: um conjunto de dados no seu projeto.
  • TABLE: o nome da tabela que está a criar.

Quando especifica o esquema na linha de comandos, não pode incluir um tipo RECORD (STRUCT), não pode incluir uma descrição da coluna e não pode especificar o modo da coluna. Todos os modos têm NULLABLE como predefinição. Para incluir descrições, modos e tipos, forneça um ficheiro de esquema JSON.RECORD

Exemplos:

Introduza o seguinte comando para criar uma tabela agrupada com o nome myclusteredtable em mydataset no seu projeto predefinido. A validade da tabela está definida como 2 592 000 (1 mês de 30 dias), a descrição está definida como This is my clustered table e a etiqueta está definida como organization:development. O comando usa o atalho -t em vez de --table.

O esquema é especificado inline como: timestamp:timestamp,customer_id:string,transaction_amount:float. O campo de agrupamento especificado customer_id é usado para agrupar a tabela.

bq mk \
    -t \
    --expiration 2592000 \
    --schema 'timestamp:timestamp,customer_id:string,transaction_amount:float' \
    --clustering_fields customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    mydataset.myclusteredtable

Introduza o seguinte comando para criar uma tabela agrupada denominada myclusteredtable em myotherproject, e não no seu projeto predefinido. A descrição está definida como This is my clustered table e a etiqueta está definida como organization:development. O comando usa o atalho -t em vez de --table. Este comando não especifica uma validade da tabela. Se o conjunto de dados tiver uma expiração da tabela predefinida, esta é aplicada. Se o conjunto de dados não tiver uma expiração da tabela predefinida, a tabela nunca expira.

O esquema é especificado num ficheiro JSON local: /tmp/myschema.json. O campo customer_id é usado para agrupar a tabela.

bq mk \
    -t \
    --expiration 2592000 \
    --schema /tmp/myschema.json \
    --clustering_fields=customer_id \
    --description "This is my clustered table" \
    --label org:dev \
    myotherproject:mydataset.myclusteredtable

Depois de criar a tabela, pode atualizar a descrição e as etiquetas da tabela.

Terraform

Use o recurso google_bigquery_table.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

O exemplo seguinte cria uma tabela denominada mytable que está agrupada nas colunas ID e Created:

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

  clustering = ["ID", "Created"]

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

}

Para aplicar a configuração do Terraform num Google Cloud projeto, conclua os passos nas secções seguintes.

Prepare o Cloud Shell

  1. Inicie o Cloud Shell.

  2. Defina o Google Cloud projeto predefinido onde quer aplicar as suas configurações do Terraform.

    Só tem de executar este comando uma vez por projeto e pode executá-lo em qualquer diretório.

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    As variáveis de ambiente são substituídas se definir valores explícitos no ficheiro de configuração do Terraform.

Prepare o diretório

Cada ficheiro de configuração do Terraform tem de ter o seu próprio diretório (também denominado módulo raiz).

  1. No Cloud Shell, crie um diretório e um novo ficheiro nesse diretório. O nome do ficheiro tem de ter a extensão .tf, por exemplo, main.tf. Neste tutorial, o ficheiro é denominado main.tf. 
    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Se estiver a seguir um tutorial, pode copiar o código de exemplo em cada secção ou passo.

    Copie o exemplo de código para o ficheiro main.tf criado recentemente.

    Opcionalmente, copie o código do GitHub. Isto é recomendado quando o fragmento do Terraform faz parte de uma solução completa.

  3. Reveja e modifique os parâmetros de exemplo para aplicar ao seu ambiente.
  4. Guarde as alterações.
  5. Inicialize o Terraform. Só tem de fazer isto uma vez por diretório. 
    terraform init

    Opcionalmente, para usar a versão mais recente do fornecedor Google, inclua a opção -upgrade: 

    terraform init -upgrade

Aplique as alterações

  1. Reveja a configuração e verifique se os recursos que o Terraform vai criar ou atualizar correspondem às suas expetativas: 
    terraform plan

    Faça as correções necessárias à configuração.

  2. Aplique a configuração do Terraform executando o seguinte comando e introduzindo yes no comando: 
    terraform apply

    Aguarde até que o Terraform apresente a mensagem "Apply complete!" (Aplicação concluída!).

  3. Abra o seu Google Cloud projeto para ver os resultados. Na Google Cloud consola, navegue para os seus recursos na IU para se certificar de que o Terraform os criou ou atualizou.

API

Chame o método tables.insert com um recurso de tabela definido que especifique a propriedade clustering.fields e a propriedade schema.

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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"),
    bigquery.SchemaField("city", "STRING"),
    bigquery.SchemaField("zipcode", "INTEGER"),
]

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

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

import (
	"context"
	"fmt"
	"time"

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

// createTableClustered demonstrates creating a BigQuery table with advanced properties like
// partitioning and clustering features.
func createTableClustered(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: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	metaData := &bigquery.TableMetadata{
		Schema: sampleSchema,
		TimePartitioning: &bigquery.TimePartitioning{
			Field:      "timestamp",
			Expiration: 90 * 24 * time.Hour,
		},
		Clustering: &bigquery.Clustering{
			Fields: []string{"origin", "destination"},
		},
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); err != nil {
		return err
	}
	return nil
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Clustering;
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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class CreateClusteredTable {
  public static void runCreateClusteredTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    createClusteredTable(datasetName, tableName);
  }

  public static void createClusteredTable(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);

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      StandardTableDefinition tableDefinition =
          StandardTableDefinition.newBuilder()
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

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

Crie uma tabela agrupada a partir do resultado de uma consulta

Existem duas formas de criar uma tabela agrupada a partir do resultado de uma consulta:

Pode criar uma tabela agrupada consultando uma tabela particionada ou uma tabela não particionada. Não é possível alterar uma tabela existente para uma tabela agrupada usando os resultados da consulta.

Quando cria uma tabela agrupada a partir do resultado de uma consulta, tem de usar SQL padrão. Atualmente, o SQL antigo não é suportado para consultar tabelas agrupadas nem para escrever resultados de consultas em tabelas agrupadas.

SQL

Para criar uma tabela agrupada a partir de um resultado de consulta, use a declaração DDL CREATE TABLE com a opção CLUSTER BY. O exemplo seguinte cria uma nova tabela agrupada por customer_id consultando uma tabela não agrupada existente:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, introduza a seguinte declaração:

    CREATE TABLE mydataset.clustered_table
(
  customer_id STRING,
  transaction_amount NUMERIC
)
CLUSTER BY
  customer_id
AS (
  SELECT * FROM mydataset.unclustered_table
);

  3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

bq

Introduza o seguinte comando para criar uma nova tabela de destino agrupada a partir do resultado de uma consulta:

bq --location=LOCATION query \
    --use_legacy_sql=false 'QUERY'

Substitua o seguinte:

  • LOCATION: o nome da sua localização. A flag --location é opcional. Por exemplo, se estiver a usar o BigQuery na região de Tóquio, pode definir o valor da flag como asia-northeast1. Pode definir um valor predefinido para a localização através do ficheiro.bigqueryrc.
  • QUERY: uma consulta na sintaxe GoogleSQL. Atualmente, não pode usar o SQL antigo para consultar tabelas agrupadas nem para escrever resultados de consultas em tabelas agrupadas. A consulta pode conter uma declaração CREATE TABLE DDL que especifica as opções para criar a sua tabela agrupada. Pode usar o LDD em vez de especificar as flags individuais da linha de comandos.

Exemplos:

Introduza o seguinte comando para escrever os resultados da consulta numa tabela de destino agrupada denominada myclusteredtable em mydataset. mydataset está no seu projeto predefinido. A consulta obtém dados de uma tabela não particionada: mytable. A coluna customer_id da tabela é usada para agrupar a tabela. A coluna timestamp da tabela é usada para criar uma tabela particionada.

bq query --use_legacy_sql=false \
    'CREATE TABLE
       mydataset.myclusteredtable
     PARTITION BY
       DATE(timestamp)
     CLUSTER BY
       customer_id
     AS (
       SELECT
         *
       FROM
         `mydataset.mytable`
     );'

API

Para guardar os resultados da consulta numa tabela agrupada, chame o método jobs.insert, configure uma tarefa query e inclua uma declaração CREATE TABLE DDL que crie a tabela agrupada.

Especifique a sua localização na propriedade location na secção jobReference do recurso job.

Crie uma tabela agrupada quando carregar dados

Pode criar uma tabela agrupada especificando colunas de agrupamento quando carregar dados para uma nova tabela. Não precisa de criar uma tabela vazia antes de carregar dados para a mesma. Pode criar a tabela agrupada e carregar os dados ao mesmo tempo.

Para mais informações sobre o carregamento de dados, consulte o artigo Introdução ao carregamento de dados no BigQuery.

Para definir o clustering quando define uma tarefa de carregamento:

SQL

Use a declaração LOAD DATA. O exemplo seguinte carrega dados AVRO para criar uma tabela com partição pelo campo transaction_date e agrupamento pelo campo customer_id. Também configura as partições para expirarem após três dias.

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. No editor de consultas, introduza a seguinte declaração:

    LOAD DATA INTO mydataset.mytable
PARTITION BY transaction_date
CLUSTER BY customer_id
  OPTIONS (
    partition_expiration_days = 3)
FROM FILES(
  format = 'AVRO',
  uris = ['gs://bucket/path/file.avro']);

  3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

API

Para definir uma configuração de clustering quando cria uma tabela através de uma tarefa de carregamento, pode preencher as propriedades Clustering da tabela.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

import (
	"context"
	"fmt"

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

// importClusteredTable demonstrates creating a table from a load job and defining partitioning and clustering
// properties.
func importClusteredTable(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "timestamp", Type: bigquery.TimestampFieldType},
		{Name: "origin", Type: bigquery.StringFieldType},
		{Name: "destination", Type: bigquery.StringFieldType},
		{Name: "amount", Type: bigquery.NumericFieldType},
	}
	loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
	loader.TimePartitioning = &bigquery.TimePartitioning{
		Field: "timestamp",
	}
	loader.Clustering = &bigquery.Clustering{
		Fields: []string{"origin", "destination"},
	}
	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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Clustering;
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;
import com.google.cloud.bigquery.TimePartitioning;
import com.google.common.collect.ImmutableList;

public class LoadTableClustered {

  public static void runLoadTableClustered() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    loadTableClustered(datasetName, tableName, sourceUri);
  }

  public static void loadTableClustered(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      TimePartitioning partitioning = TimePartitioning.of(TimePartitioning.Type.DAY);

      Clustering clustering =
          Clustering.newBuilder().setFields(ImmutableList.of("name", "post_abbr")).build();

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .setClustering(clustering)
              .build();

      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).build());

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Data successfully loaded into clustered table during load job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Data not loaded into clustered table during load job \n" + e.toString());
    }
  }
}

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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(
    skip_leading_rows=1,
    source_format=bigquery.SourceFormat.CSV,
    schema=[
        bigquery.SchemaField("timestamp", bigquery.SqlTypeNames.TIMESTAMP),
        bigquery.SchemaField("origin", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("destination", bigquery.SqlTypeNames.STRING),
        bigquery.SchemaField("amount", bigquery.SqlTypeNames.NUMERIC),
    ],
    time_partitioning=bigquery.TimePartitioning(field="timestamp"),
    clustering_fields=["origin", "destination"],
)

job = client.load_table_from_uri(
    ["gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv"],
    table_id,
    job_config=job_config,
)

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

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

O que se segue?