Crie vistas lógicas

Este documento descreve como criar vistas lógicas no BigQuery.

Pode criar uma vista lógica das seguintes formas:

• Usar a Google Cloud consola.
• Usando o comando bq mk da ferramenta de linhas de comando bq.
• Chamar o método da API tables.insert.
• Usando as bibliotecas cliente.
• Enviar uma declaração de CREATE VIEW linguagem de definição de dados (LDD).

Veja as limitações

As visualizações de propriedade do BigQuery estão sujeitas às seguintes limitações:

• As vistas são só de leitura. Por exemplo, não pode executar consultas que insiram, atualizem ou eliminem dados.
• O conjunto de dados que contém a sua vista e o conjunto de dados que contém as tabelas referenciadas pela vista têm de estar na mesma localização.
• Uma referência dentro de uma vista tem de ser qualificada com um conjunto de dados. O conjunto de dados predefinido não afeta o corpo de uma vista.
• Não pode usar o método da API JSON TableDataList para obter dados de uma vista. Para mais informações, consulte o artigo Tabledata: list.
• Não pode misturar consultas GoogleSQL e SQL antigo quando usa vistas. Uma consulta GoogleSQL não pode fazer referência a uma vista definida através da sintaxe SQL antiga.
• Não pode fazer referência a parâmetros de consulta em visualizações de propriedade.
• Os esquemas das tabelas subjacentes são armazenados com a vista quando esta é criada. Se forem adicionadas, eliminadas ou modificadas colunas após a criação da vista, a vista não é atualizada automaticamente e o esquema comunicado permanece impreciso até que a definição SQL da vista seja alterada ou a vista seja recriada. Embora o esquema comunicado possa ser impreciso, todas as consultas enviadas produzem resultados precisos.
• Não pode atualizar automaticamente uma visualização de SQL antiga para a sintaxe do GoogleSQL. Para modificar a consulta usada para definir uma vista, pode usar o seguinte:
  • A opção Editar consulta na Google Cloud consola
  • O comando bq update --view na ferramenta de linhas de comando bq
  • As bibliotecas de cliente do BigQuery
  • Os métodos da API update ou patch.
• Não pode incluir uma função definida pelo utilizador temporária nem uma tabela temporária na consulta SQL que define uma vista.
• Não pode fazer referência a uma vista numa consulta de tabela com carateres universais.

Para informações sobre as quotas e os limites aplicáveis às visualizações, consulte o artigo Limites de visualização.

Antes de começar

Conceda funções de gestão de identidade e acesso (IAM) que dão aos utilizadores as autorizações necessárias para realizar cada tarefa neste documento.

Autorizações necessárias

As vistas são tratadas como recursos de tabelas no BigQuery, pelo que a criação de uma vista requer as mesmas autorizações que a criação de uma tabela. Também tem de ter autorizações para consultar quaisquer tabelas referenciadas pela consulta SQL da vista.

Para criar uma visualização de propriedade, precisa da autorização da bigquery.tables.createIAM A roles/bigquery.dataEditorfunção de IAM predefinida inclui as autorizações de que precisa para criar uma visualização de propriedade.

Além disso, se tiver a autorização bigquery.datasets.create, pode criar vistas nos conjuntos de dados que criar. Para criar uma vista para dados que não são seus, tem de ter autorização bigquery.tables.getData para essa tabela.

Para mais informações sobre as funções e as autorizações do IAM no BigQuery, consulte o artigo Funções e autorizações predefinidas.

Nota: para criar ou atualizar uma visualização autorizada ou uma visualização num conjunto de dados autorizado, precisa de autorizações adicionais. Para mais informações, consulte as autorizações necessárias para vistas autorizadas e as autorizações necessárias para vistas em conjuntos de dados autorizados.

Nomenclatura das visualizações

Quando cria uma vista no BigQuery, o nome da vista tem de ser único por conjunto de dados. O nome da vista 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 visualização válidos: view 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 vistas e prefixos de nomes de vistas estão reservados. Se receber um erro a indicar que o nome ou o prefixo da vista 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

Crie uma vista

Pode criar uma vista compondo uma consulta SQL que é usada para definir os dados acessíveis à vista. A consulta SQL tem de consistir numa declaração SELECT. Outros tipos de declarações (como declarações DML) e consultas com várias declarações não são permitidos em consultas de visualização.

Para criar uma visualização de propriedade:

Consola

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

   Aceda ao BigQuery

2. Clique em Consulta SQL.

3. No editor de consultas, introduza uma consulta SQL válida.

   Em alternativa, pode abrir uma consulta guardada.

4. Clique em Guardar > Guardar vista.

   

5. Na caixa de diálogo Guardar vista:

   • No menu Projeto, selecione um projeto para armazenar a visualização.
   • No menu Conjunto de dados, selecione um conjunto de dados ou crie um novo para armazenar a vista. O conjunto de dados de destino de uma vista guardada tem de estar na mesma região que a origem.
   • No campo Tabela, introduza o nome da vista.
   • Clique em Guardar.

Nota: quando cria uma vista através da Google Cloud consola, não pode adicionar uma etiqueta, uma descrição nem um prazo de validade. Pode adicionar estas propriedades opcionais quando cria uma vista através da API ou da ferramenta de linha de comandos bq. Depois de criar uma vista através da Google Cloud consola, pode adicionar uma data de validade, uma descrição e etiquetas. Para mais informações, consulte o artigo Atualizar vistas.

SQL

Use a declaração CREATE VIEW. O exemplo seguinte cria uma vista denominada usa_male_names a partir do conjunto de dados público USA names:

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

   Aceda ao BigQuery

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

   CREATE VIEW mydataset.usa_male_names(name, number) AS (
     SELECT
       name,
       number
     FROM
       `bigquery-public-data.usa_names.usa_1910_current`
     WHERE
       gender = 'M'
     ORDER BY
       number DESC
   );

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 a flag --view. Para consultas GoogleSQL, adicione a flag --use_legacy_sql e defina-a como false. Alguns parâmetros opcionais incluem --add_tags, --expiration, --description e --label. Para ver uma lista completa de parâmetros, consulte a referência do comando bq mk.

Se a sua consulta fizer referência a recursos de funções definidas pelo utilizador (UDF) externos armazenados no Cloud Storage ou em ficheiros locais, use a sinalização --view_udf_resource para especificar esses recursos. A sinalização --view_udf_resource não é demonstrada aqui. Para mais informações sobre a utilização de UDFs, consulte o artigo UDFs.

Se estiver a criar uma visualização de propriedade num projeto que não seja o projeto predefinido, especifique o ID do projeto através da flag --project_id.

Nota: o conjunto de dados que contém a vista e o conjunto de dados que contém as tabelas referenciadas pela vista têm de estar na mesma localização.

bq mk \
--use_legacy_sql=false \
--view_udf_resource=PATH_TO_FILE \
--expiration=INTEGER \
--description="DESCRIPTION" \
--label=KEY_1:VALUE_1 \
--add_tags=KEY_2:VALUE_2[,...] \
--view='QUERY' \
--project_id=PROJECT_ID \
DATASET.VIEW

Substitua o seguinte:

• PATH_TO_FILE é o URI ou o caminho do sistema de ficheiros local para um ficheiro de código a ser carregado e avaliado imediatamente como um recurso de FDU usado pela vista. Repita a flag para especificar vários ficheiros.
• INTEGER define o tempo de vida (em segundos) da visualização. Se INTEGER for 0, a vista não expira. Se não incluir a flag --expiration, o BigQuery cria a vista com o tempo de vida predefinido da tabela do conjunto de dados.
• DESCRIPTION é uma descrição da visualização entre aspas.
• KEY_1:VALUE_1 é o par de chave-valor que representa uma etiqueta. Repita a flag --label para especificar várias etiquetas.
• KEY_2:VALUE_2 é o par de chave-valor que representa uma etiqueta. Adicione várias etiquetas sob a mesma flag com vírgulas entre os pares chave:valor.
• QUERY é uma consulta válida.
• PROJECT_ID é o ID do seu projeto (se não tiver um projeto predefinido configurado).
• DATASET é um conjunto de dados no seu projeto.
• VIEW é o nome da vista que quer criar.

Exemplos:

Introduza o seguinte comando para criar uma vista denominada myview em mydataset no seu projeto predefinido. O tempo de validade está definido como 3600 segundos (1 hora), a descrição está definida como This is my view e a etiqueta está definida como organization:development. A consulta usada para criar a vista consulta dados do conjunto de dados público USA Name Data.

bq mk \
--use_legacy_sql=false \
--expiration 3600 \
--description "This is my view" \
--label organization:development \
--view \
'SELECT
  name,
  number
FROM
  `bigquery-public-data.usa_names.usa_1910_current`
WHERE
  gender = "M"
ORDER BY
  number DESC' \
mydataset.myview

Introduza o seguinte comando para criar uma vista denominada myview em mydataset em myotherproject. A descrição está definida como This is my view, a etiqueta está definida como organization:development e a validade da vista está definida como a validade predefinida da tabela do conjunto de dados. A consulta usada para criar a vista consulta dados do conjunto de dados público USA Name Data.

bq mk \
--use_legacy_sql=false \
--description "This is my view" \
--label organization:development \
--project_id myotherproject \
--view \
'SELECT
  name,
  number
FROM
  `bigquery-public-data.usa_names.usa_1910_current`
WHERE
  gender = "M"
ORDER BY
  number DESC' \
mydataset.myview

Depois de criar a visualização de propriedade, pode atualizar a respetiva data de validade, descrição e etiquetas. Para mais informações, consulte o artigo Atualizar vistas.

Terraform

Use o recurso google_bigquery_table.

Nota: para criar objetos do BigQuery com o Terraform, tem de ativar a API Cloud Resource Manager.

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 visualização de propriedade com o nome myview:

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            = "myview"
  deletion_protection = false # set to "true" in production

  view {
    query          = "SELECT global_id, faa_identifier, name, latitude, longitude FROM `bigquery-public-data.faa.us_airports`"
    use_legacy_sql = false
  }

}

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.

Nota: os exemplos do Terraform partem geralmente do princípio de que as APIs necessárias estão ativadas no seu Google Cloud projeto.

API

Chame o método tables.insert com um recurso de tabela que contenha uma propriedade view.

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

// createView demonstrates creation of a BigQuery logical view.
func createView(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()

	meta := &bigquery.TableMetadata{
		// This example shows how to create a view of the shakespeare sample dataset, which
		// provides word frequency information.  This view restricts the results to only contain
		// results for works that contain the "king" in the title, e.g. King Lear, King Henry V, etc.
		ViewQuery: "SELECT word, word_count, corpus, corpus_date FROM `bigquery-public-data.samples.shakespeare` WHERE corpus LIKE '%king%'",
	}
	if err := client.Dataset(datasetID).Table(tableID).Create(ctx, meta); 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.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.ViewDefinition;

// Sample to create a view
public class CreateView {

  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";
    String viewName = "MY_VIEW_NAME";
    String query =
        String.format(
            "SELECT TimestampField, StringField, BooleanField FROM %s.%s", datasetName, tableName);
    createView(datasetName, viewName, query);
  }

  public static void createView(String datasetName, String viewName, 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();

      TableId tableId = TableId.of(datasetName, viewName);

      ViewDefinition viewDefinition =
          ViewDefinition.newBuilder(query).setUseLegacySql(false).build();

      bigquery.create(TableInfo.of(tableId, viewDefinition));
      System.out.println("View created successfully");
    } catch (BigQueryException e) {
      System.out.println("View was not created. \n" + e.toString());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js 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 the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createView() {
  // Creates a new view named "my_shared_view" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const myDatasetId = "my_table"
  // const myTableId = "my_table"
  // const projectId = "bigquery-public-data";
  // const sourceDatasetId = "usa_names"
  // const sourceTableId = "usa_1910_current";
  const myDataset = await bigquery.dataset(myDatasetId);

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    view: `SELECT name 
    FROM \`${projectId}.${sourceDatasetId}.${sourceTableId}\`
    LIMIT 10`,
  };

  // Create a new view in the dataset
  const [view] = await myDataset.createTable(myTableId, options);

  console.log(`View ${view.id} created.`);
}

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

client = bigquery.Client()

view_id = "my-project.my_dataset.my_view"
source_id = "my-project.my_dataset.my_table"
view = bigquery.Table(view_id)

# The source table in this example is created from a CSV file in Google
# Cloud Storage located at
# `gs://cloud-samples-data/bigquery/us-states/us-states.csv`. It contains
# 50 US states, while the view returns only those states with names
# starting with the letter 'W'.
view.view_query = f"SELECT name, post_abbr FROM `{source_id}` WHERE name LIKE 'W%'"

# Make an API request to create the view.
view = client.create_table(view)
print(f"Created {view.table_type}: {str(view.reference)}")

Depois de criar a vista, consulte-a como se consultasse uma tabela.

Ver segurança

Para controlar o acesso a vistas no BigQuery, consulte o artigo Vistas autorizadas.

O que se segue?

• Para obter informações sobre como criar uma vista autorizada, consulte o artigo Criar vistas autorizadas.
• Para obter informações sobre como receber metadados de visualizações, consulte o artigo Receber informações sobre visualizações.
• Para mais informações sobre a gestão de visualizações de propriedade, consulte o artigo Gerir visualizações de propriedade.