Criar e usar tabelas
Este documento descreve como criar e usar tabelas padrão (integradas) no BigQuery. Para informações sobre como criar outros tipos de tabelas, consulte:
Depois de criar uma tabela, você pode:
- controlar o acesso aos dados de sua tabela;
- receber informações sobre suas tabelas;
- listar as tabelas em um conjunto de dados;
- Receber metadados de tabela
Para mais informações sobre como gerenciar tabelas, incluindo atualização de propriedades, cópia e exclusão de tabelas, consulte Como gerenciar tabelas.
Antes de começar
Antes de criar uma tabela no BigQuery:
- defina um projeto seguindo um Guia de primeiros passos do BigQuery;
- crie um conjunto de dados do BigQuery;
- se você quiser, leia Introdução a tabelas para entender as limitações, as cotas e os preços das tabelas.
Nomenclatura de tabelas
Ao criar uma tabela no BigQuery, o nome dela precisa ser exclusivo para cada conjunto de dados. Esse nome pode:
- conter até 1.024 caracteres;
- conter caracteres Unicode na categoria L (letra), M (marca), N (número), Pc (conector, inclusive sublinhado), Pd (travessão), Zs (espaço). Para mais informações, consulte Categoria geral.
Por exemplo, os nomes de tabela a seguir são válidos: table 01
, ग्राहक
, 00_お客様
, étudiant-01
.
Alguns nomes de tabelas e prefixos de nome de tabela são reservados. Se você receber um erro informando que o nome ou o prefixo da tabela está reservado, selecione um nome diferente e tente novamente.
crie tabelas
É possível criar uma tabela no BigQuery:
- usando manualmente o console do Cloud ou o comando
bq mk
da ferramenta de linha de comandobq
; - programaticamente, chamando o método da API
tables.insert
; - usando as bibliotecas de cliente;
- a partir dos resultados da consulta;
- definindo uma tabela que faz referência a uma fonte de dados externa;
- ao carregar dados;
- Usando uma instrução de linguagem de definição de dados (DDL, na sigla em inglês)
CREATE TABLE
.
Permissões necessárias
Para criar uma tabela, você precisa das seguintes permissões do IAM:
bigquery.tables.create
bigquery.tables.updateData
bigquery.jobs.create
Além disso, é possível exigir a permissão bigquery.tables.getData
para
acessar os dados gravados na tabela.
Cada um dos papéis predefinidos do IAM a seguir inclui as permissões necessárias para atualizar uma tabela:
roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin
(inclui a permissãobigquery.jobs.create
)roles/bigquery.user
(inclui a permissãobigquery.jobs.create
)roles/bigquery.jobUser
(inclui a permissãobigquery.jobs.create
)
Além disso, se você tiver a permissão bigquery.datasets.create
, será possível
criar e atualizar tabelas nos conjuntos de dados que criar.
Para mais informações sobre os papéis e as permissões do IAM no BigQuery, consulte Papéis e permissões predefinidos.
Para criar uma tabela vazia com definição de esquema, faça o seguinte:
É possível criar uma tabela vazia com uma definição de esquema das seguintes maneiras:
- inserir o esquema usando o console do Cloud;
- fornecer o esquema in-line usando a ferramenta de linha de comando
bq
; - usar a ferramenta de linha de comando
bq
para enviar um arquivo de esquema JSON; - fornecer o esquema em um recurso de tabela
ao chamar o método
tables.insert
da API.
Para mais informações sobre como especificar um esquema de tabela, consulte Como especificar um esquema.
Após a criação da tabela, é possível carregar dados nela ou preenchê-la gravando resultados da consulta.
Para criar uma tabela vazia com definição de esquema, faça o seguinte:
Console
No console do Cloud, abra a página do BigQuery.
No painel Explorer, expanda o projeto e selecione um conjunto de dados.
Expanda a opção
Ações e clique em Abrir.No painel de detalhes, clique em Criar tabela
.Na página Criar tabela, na seção Origem, selecione Tabela vazia.
Na página Criar tabela, na seção Destino:
Em Nome do conjunto de dados, escolha o conjunto de dados apropriado.
No campo Nome da tabela, insira o nome da tabela que você está criando no BigQuery.
Verifique se Tipo de tabela está definido como Tabela nativa.
Na seção Esquema, insira a definição do esquema.
Insira as informações do esquema manualmente:
Ative Editar como texto e insira o esquema da tabela como uma matriz JSON.
Use Adicionar campo para inserir manualmente o esquema.
Em Configurações de partição e cluster, use o valor padrão
No partitioning
.Na seção Opções avançadas, para Criptografia, use o valor padrão
Google-managed key
. Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso.Selecione Criar tabela.
SQL
Com as instruções de linguagem de definição de dados (DDL), é possível criar e modificar tabelas e visualizações usando a sintaxe de consulta do SQL padrão.
Saiba mais sobre Como usar as instruções da linguagem de definição de dados.
Para criar uma tabela no console do Cloud usando uma instrução DDL, siga estas instruções:
No console do Cloud, abra a página do BigQuery.
Clique em Escrever nova consulta.
Digite a instrução
CREATE TABLE
DDL na área de texto do editor de consulta.A consulta a seguir cria uma tabela chamada
newtable
que expira em 1º de janeiro de 2023. A descrição da tabela é "a table that expires in 2023" e o rótulo éorg_unit:development
.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")] )
Opcional: clique em Mais e selecione Configurações de consulta.
Opcional: em Local de processamento, clique em Seleção automática e escolha o local dos seus dados. Se você deixar o local de processamento definido como não especificado, ele será detectado automaticamente.
Clique em Executar. Quando a consulta for concluída, a tabela será exibida no painel Recursos.
bq
Use o comando bq mk
com a sinalização --table
ou -t
. Você pode fornecer informações de esquema de tabela in-line ou por meio de um arquivo JSON. Parâmetros opcionais incluem:
--expiration
--description
--time_partitioning_type
--destination_kms_key
--label
--time_partitioning_type
e --destination_kms_key
não são demonstrados aqui. Para mais informações sobre --time_partitioning_type
, consulte as tabelas particionadas. Para mais
informações sobre --destination_kms_key
, consulte
chaves de criptografia gerenciadas pelo cliente.
Se você estiver criando uma tabela em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset
.
Para criar uma tabela vazia em um conjunto de dados existente com uma definição de esquema, insira o seguinte:
bq mk \ --table \ --expiration integer \ --description description \ --label key_1:value_1 \ --label key_2:value_2 \ project_id:dataset.table \ schema
Substitua:
- integer é a vida útil padrão da tabela em segundos. O valor mínimo é de 3.600 segundos (uma hora). O prazo de validade é a soma do horário UTC atual com o valor inteiro. Quando você define um prazo de validade ao criar a tabela, a configuração de expiração da tabela padrão do conjunto de dados é ignorada;
- description é uma descrição da tabela entre aspas.
- key_1:value_1 e key_2:value_2 são pares de chave-valor que especificam rótulos.
- project_id é o ID do projeto.
- dataset é um conjunto de dados no projeto;
- table é o nome da tabela que você está criando;
- schema é uma definição de esquema in-line no formato field:data_type,field:data_type ou o caminho para o arquivo de esquema JSON na máquina local.
Quando você especifica o esquema na linha de comando, não é possível incluir um tipo RECORD
(STRUCT
), uma descrição de coluna nem especificar o modo da coluna. Todos os modos assumem NULLABLE
como padrão. Para incluir descrições, modos e tipos RECORD
, forneça um arquivo de esquema JSON.
Exemplos:
Digite o comando a seguir para criar uma tabela usando uma definição de esquema in-line. Esse comando cria uma tabela denominada mytable
em mydataset
no projeto padrão. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table
e o rótulo, como organization:development
. O comando usa o atalho -t
em vez de --table
. O esquema é especificado in-line como: 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
Digite o comando a seguir para criar uma tabela usando um arquivo de esquema JSON. Esse comando cria uma tabela denominada mytable
em mydataset
no projeto padrão. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table
e o rótulo, como organization:development
. O caminho para o arquivo de esquema é /tmp/myschema.json
.
bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ mydataset.mytable \ /tmp/myschema.json
Digite o comando a seguir para criar uma tabela usando um arquivo de esquema JSON.
Esse comando cria uma tabela denominada mytable
em mydataset
em myotherproject
. A expiração da tabela é configurada para 3.600 segundos (uma hora), a descrição é definida como This is my table
e o rótulo, como organization:development
. O caminho para o arquivo de esquema é /tmp/myschema.json
.
bq mk \ --table \ --expiration 3600 \ --description "This is my table" \ --label organization:development \ myotherproject:mydataset.mytable \ /tmp/myschema.json
Após a criação da tabela, é possível atualizar a expiração, a descrição e os rótulos da tabela. É possível também modificar a definição do esquema.
API
Chame o método tables.insert
com um recurso de tabela definido.
C#
Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.
Go
Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.
Java
Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.
Node.js
Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.
PHP
Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.
Python
Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.
Ruby
Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de Referência da API BigQuery Ruby.
Para criar uma tabela vazia sem definição de esquema:
Java
Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.
Criar uma tabela usando um resultado de consulta
Para criar uma tabela com base no resultado de uma consulta, grave-o em uma tabela de destino.
Console
Abra a página do BigQuery no console do Cloud.
No painel Explorer, expanda o projeto e selecione um conjunto de dados.
Insira uma consulta SQL válida.
Clique em Mais e selecione Configurações de consulta.
Selecione a opção Definir uma tabela de destino para os resultados da consulta.
Na seção Destino, selecione o Conjunto de dados em que você quer criar a tabela e escolha um ID de tabela.
Na seção Preferência de gravação na tabela de destino, escolha uma das seguintes opções:
- Gravar apenas se a tabela estiver vazia: grava os resultados da consulta na tabela apenas se ela estiver vazia.
- Anexar à tabela: anexa os resultados da consulta a uma tabela atual.
- Substituir tabela: usa os resultados da consulta para substituir uma tabela atual com o mesmo nome.
Opcional: em Local dos dados, escolha o local.
Para atualizar as configurações de consulta, clique em Salvar.
Clique em Executar. Isso cria um job de consulta que grava os resultados da consulta na tabela que você especificou.
Como alternativa, se você esquecer de especificar uma tabela de destino antes de executar a consulta, clique no botão Salvar resultados acima do editor para copiar a tabela de resultados em cache para uma tabela permanente.
SQL
Com as instruções de linguagem de definição de dados (DDL), é possível criar e modificar tabelas usando a sintaxe de consulta do SQL padrão.
Por exemplo, a instrução a seguir cria uma nova tabela chamada trips
a partir de dados na tabela bikeshare_trips
pública:
CREATE TABLE mydataset.trips AS SELECT bikeid, start_time, duration_minutes FROM bigquery-public-data.austin_bikeshare.bikeshare_trips;
Para mais informações, consulte a página de instrução CREATE TABLE
e o exemplo CREATE TABLE
: Como criar uma nova tabela a partir de uma atual.
bq
Insira o comando bq query
e especifique a sinalização --destination_table
para criar uma tabela permanente com base nos resultados da consulta. Especifique a sinalização use_legacy_sql=false
para usar a sintaxe SQL padrão. Para gravar os resultados da consulta em uma tabela que não esteja
em seu projeto padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte
formato: project_id:dataset
.
Opcional: forneça a sinalização --location
e defina o valor para seu local.
Para controlar a disposição de gravação de uma tabela de destino atual, especifique uma das seguintes sinalizações opcionais:
--append_table
: se a tabela de destino existir, os resultados da consulta serão anexados a ela.--replace
: se a tabela de destino existir, ela será substituída pelos resultados da consulta.
bq --location=location query \ --destination_table project_id:dataset.table \ --use_legacy_sql=false 'query'
Substitua:
location
é o nome do local usado para processar a consulta. A sinalização--location
é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, é possível definir o valor da sinalização comoasia-northeast1
. É possível definir um valor padrão para o local usando o arquivo.bigqueryrc
.project_id
é o ID do projeto.dataset
é o nome do conjunto de dados que contém a tabela na qual você está gravando os resultados da consulta.table
é o nome da tabela na qual você está gravando os resultados da consulta.query
é uma consulta na sintaxe SQL padrão.
Se nenhuma sinalização de disposição de gravação for especificada, o comportamento
padrão será gravar os resultados na tabela somente se ela estiver vazia. Se a tabela existir e não estiver vazia, o seguinte erro será retornado: "BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already
Exists: Table project_id:dataset.table
".
Exemplos:
Digite o comando a seguir para gravar resultados de consulta em uma tabela de destino chamada mytable
em mydataset
. O conjunto de dados está no projeto padrão.
Como nenhuma sinalização de disposição de gravação está especificada no comando, a tabela precisa ser nova ou estar vazia. Caso contrário, é retornado um erro Already exists
. A consulta
recupera dados do conjunto de dados público USA Name Data (link em inglês).
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'
Digite o comando a seguir para usar resultados da consulta e substituir uma tabela de destino chamada mytable
em mydataset
. O conjunto de dados está no projeto padrão. O comando usa a sinalização --replace
para substituir a tabela de destino.
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'
Digite o comando a seguir para anexar resultados de consulta a uma tabela de destino chamada mytable
em mydataset
. O conjunto de dados está em my-other-project
, e não no projeto padrão. O comando usa a sinalização --append_table
para anexar os resultados da consulta na tabela de destino.
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'
A saída de cada um desses exemplos será semelhante ao seguinte. Para facilitar a leitura, ocultamos parte do resultado.
Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE +---------+--------+ | name | number | +---------+--------+ | Robert | 10021 | | John | 9636 | | Robert | 9297 | | ... | +---------+--------+
API
Para salvar resultados de consulta em uma tabela permanente, chame o método jobs.insert
, configure um job query
e inclua um valor para a property destinationTable
. Para controlar a disposição de gravação de uma tabela de destino atual, configure a property writeDisposition
.
Para controlar o local de processamento do job de consulta, especifique a property location
na seção jobReference
do recurso do job.
Go
Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.
Java
Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.
Para salvar os resultados de consulta em uma tabela permanente, defina a tabela de destino como o TableId desejado em uma QueryJobConfiguration.
Node.js
Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.
Python
Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.
Para salvar resultados de consulta em uma tabela permanente, crie um QueryJobConfig e defina o destino como a TableReference desejada. Transmita a configuração do job para o método de consulta (links em inglês).: uma tabela que faz referência a uma fonte de dados externa
Uma fonte de dados externa pode ser consultada diretamente no BigQuery, mesmo que os dados não estejam no armazenamento do BigQuery.
O BigQuery é compatível com as seguintes fontes de dados externas:
Para mais informações, consulte Introdução às fontes de dados externas.
Como criar uma tabela ao carregar dados
Ao carregar dados no BigQuery, é possível: carregá-los a uma tabela ou partição nova, anexá-los a uma tabela ou partição ou substituir a tabela ou partição. Não é necessário criar uma tabela vazia antes de carregar dados nela. Você pode criar a nova tabela e carregar seus dados ao mesmo tempo.
Ao carregar dados no BigQuery, forneça o esquema de tabela ou partição. Para formatos de dados compatíveis, use a detecção automática de esquema.
Para mais informações sobre como carregar dados no BigQuery, acesse este link.
Controlar o acesso a tabelas
Para configurar o acesso a tabelas e visualizações, conceda um papel do IAM a uma entidade nos seguintes níveis, listados em ordem de intervalo de recursos permitidos (do maior para o menor):
- Um nível alto na hierarquia de recursos do Google Cloud, como o nível do projeto, da pasta ou da organização
- O nível do conjunto de dados
- o nível da tabela ou da visualização
Também é possível restringir o acesso a dados nas tabelas usando os métodos a seguir:
O acesso a qualquer recurso protegido pelo IAM é aditivo. Por exemplo, se uma entidade não tiver acesso no nível alto, como o projeto, uma opção será conceder à entidade o acesso no nível do conjunto de dados, e ela terá acesso às tabelas e visualizações no conjunto de dados. Da mesma forma, se a entidade não tiver nível acesso alto ou ao conjunto de dados, você tem a opção de conceder acesso à tabela/visualização.
A concessão de papéis do IAM em um nível mais alto na hierarquia de recursos do Google Cloud, como projeto, pasta ou organização, concede à entidade acesso a um amplo conjunto de recursos. Por exemplo, conceder um papel a uma entidade no nível do projeto fornece a ela permissões referentes aos conjuntos de dados em todo o projeto.
Conceder um papel no nível do conjunto de dados especifica as operações que uma entidade tem permissão de realizar em tabelas e define as visualizações nesse conjunto de dados específico, mesmo que a entidade não tenha acesso em um nível superior. Para informações sobre como configurar controles de acesso no nível do conjunto de dados, consulte este link.
A concessão de um papel no nível da tabela ou da visualização especifica as operações que uma entidade pode realizar em tabelas e visualizações específicas, mesmo que a entidade não tenha acesso em um nível superior. Para informações sobre como configurar controles de acesso no nível da tabela e da visualização, consulte este link.
Você também pode criar papéis personalizados do IAM. Se você criar um papel personalizado, as permissões concedidas dependerão das operações específicas que a entidade poderá executar.
Não é possível definir uma permissão "deny" em nenhum recurso protegido pelo IAM.
Para mais informações sobre papéis e permissões, consulte Noções básicas sobre papéis na documentação do IAM e os papéis e permissões do IAM do BigQuery.
Ver informações sobre tabelas
É possível conseguir informações ou metadados sobre tabelas das seguintes maneiras:
- Como usar o console do Cloud
- Como usar o comando
bq
da ferramenta de linha de comandobq show
. - Chamada do método de API
tables.get
- usando bibliotecas de cliente.
- consulte as visualizações
INFORMATION_SCHEMA
(Beta);
Permissões necessárias
Para ver informações sobre tabelas, é preciso ter pelo menos as permissões bigquery.tables.get
. Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.tables.get
:
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
Além disso, quando um usuário tem permissões bigquery.datasets.create
e cria um conjunto de dados, ele recebe o acesso bigquery.dataOwner
ao conjunto.
O acesso bigquery.dataOwner
permite que o usuário recupere metadados da tabela.
Para mais informações sobre papéis e permissões do IAM no BigQuery, consulte Controle de acesso.
Receber informações de tabelas
Para ver informações sobre tabelas:
Console
Na seção Recursos do painel de navegação, amplie o projeto e selecione um conjunto de dados. Clique no nome do conjunto de dados para expandi-lo. Isso exibe as tabelas e visualizações no conjunto de dados.
Clique no nome da tabela.
Abaixo do editor, clique em Detalhes. Essa página exibe a descrição e as informações da tabela.
Clique na guia Schema para ver a definição do esquema da tabela.
bq
Emita o comando bq show
para exibir todas as informações da tabela. Use a sinalização --schema
para exibir somente informações de esquema da tabela. É possível usar a sinalização --format
para controlar a saída.
Se você estiver recebendo informações sobre uma tabela em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: project_id:dataset
.
bq show \ --schema \ --format=prettyjson \ project_id:dataset.table
Em que:
- project_id é o ID do projeto;
- dataset é o nome do conjunto de dados.
- table é o nome da tabela.
Exemplos:
Digite o comando a seguir para exibir todas as informações sobre mytable
em mydataset
. mydataset
está em seu projeto padrão.
bq show --format=prettyjson mydataset.mytable
Digite o comando a seguir para exibir todas as informações sobre mytable
em mydataset
. mydataset
está em myotherproject
, e não no seu projeto padrão.
bq show --format=prettyjson myotherproject:mydataset.mytable
Digite o comando a seguir para exibir apenas informações de esquema sobre mytable
em mydataset
. mydataset
está em myotherproject
, não no projeto padrão.
bq show --schema --format=prettyjson myotherproject:mydataset.mytable
API
Chame o método tables.get
e forneça os parâmetros relevantes.
Go
Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.
Java
Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.
Node.js
Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.
PHP
Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.
Python
Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.
Receber informações de tabela usando INFORMATION_SCHEMA
INFORMATION_SCHEMA
é uma série de visualizações que fornecem acesso a metadados
sobre conjuntos de dados, rotinas, tabelas, visualizações, jobs, reservas e dados de streaming.
Consulte as seguintes visualizações para acessar informações da tabela:
- Use as visualizações
INFORMATION_SCHEMA.TABLES
eINFORMATION_SCHEMA.TABLE_OPTIONS
para recuperar metadados sobre tabelas e visualizações em um projeto. - Use as visualizações
INFORMATION_SCHEMA.COLUMNS
eINFORMATION_SCHEMA.COLUMN_FIELD_PATHS
para recuperar metadados sobre as colunas (campos) de uma tabela. - Use as visualizações
INFORMATION_SCHEMA.TABLE_STORAGE
eINFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_*
para recuperar metadados sobre o uso de armazenamento atual e histórico de uma tabela.
As visualizações TABLES
e TABLE_OPTIONS
também contêm informações de alto nível sobre visualizações. Para ver informações detalhadas, consulte a visualização INFORMATION_SCHEMA.VIEWS
.
Visualização TABLES
Os resultados das consultas na visualização INFORMATION_SCHEMA.TABLES
contêm uma linha para cada tabela ou visualização do conjunto de dados. Para informações detalhadas sobre
visualizações, consulte a visualização
INFORMATION_SCHEMA.VIEWS
.
A visualização INFORMATION_SCHEMA.TABLES
tem o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
table_catalog |
STRING |
O ID do projeto que contém o conjunto de dados. |
table_schema |
STRING |
O nome do conjunto de dados que contém a tabela ou visualização, também conhecido
como datasetId . |
table_name |
STRING |
O nome da tabela ou visualização, também conhecido como
tableId . |
table_type |
STRING |
O tipo de tabela, que pode ser:
|
is_insertable_into |
STRING |
YES ou NO dependendo da compatibilidade da tabela com as instruções DML INSERT |
is_typed |
STRING |
O valor sempre é NO . |
creation_time |
TIMESTAMP |
O horário de criação da tabela |
ddl |
STRING |
A instrução DDL
que pode ser usada para recriar a tabela, como
CREATE TABLE
ou CREATE VIEW |
clone_time |
TIMESTAMP |
Para clones de tabelas
(visualização),
a hora em que a tabela base foi
clonada para criar a
tabela. Se a
viagem no tempo foi usada, esse
campo vai conter o carimbo de data/hora da viagem. Caso contrário, o
campo clone_time será igual ao
campo creation_time . Aplicável apenas a
tabelas com table_type definido como CLONE .
|
base_table_catalog |
STRING |
Para clones de tabelas
(visualização),
o projeto da tabela base. Aplicável apenas a
tabelas com table_type definido como CLONE .
|
base_table_schema |
STRING |
Para clones de tabelas
(visualização),
o conjunto de dados da tabela base. Aplicável apenas a tabelas com
table_type definido como CLONE . |
base_table_name |
STRING |
Para clones de tabelas
(visualização),
o nome da tabela base. Aplicável apenas a tabelas com
table_type definido como CLONE . |
default_collation_name |
STRING |
Nome da especificação de compilação padrão, se houver. Caso contrário, NULL .
|
Examples
Exemplo 1:
O exemplo a seguir recupera metadados de tabela para todas as tabelas no
conjunto de dados chamado mydataset
. A consulta seleciona todas as colunas da
visualização INFORMATION_SCHEMA.TABLES
, exceto is_typed
, que é reservada para
uso futuro, e ddl
, que está oculta das consultas SELECT *
. Os metadados
retornados correspondem a todas as tabelas em mydataset
no projeto padrão.
mydataset
contém as seguintes tabelas:
mytable1
: uma tabela padrão do BigQuerymyview1
: uma visualização do BigQuery
Para executar a consulta em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
. Veja um exemplo: `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES'
Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+ | 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; | +----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Exemplo 2:
O exemplo a seguir recupera todas as tabelas do tipo BASE TABLE
da visualização INFORMATION_SCHEMA.TABLES
. A coluna is_typed
é excluída e a coluna ddl
está oculta. Os metadados retornados são para tabelas em
mydataset
no projeto padrão.
Para executar a consulta em um projeto diferente do padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; por exemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLES
.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES WHERE table_type="BASE TABLE"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES WHERE table_type="BASE TABLE"'
Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog | table_schema | table_name | table_type | is_insertable_into | creation_time | ddl |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject | mydataset | mytable1 | BASE TABLE | YES | 2018-10-31 22:40:05 | CREATE TABLE myproject.mydataset.mytable1
|
| | | | | | | ( |
| | | | | | | id INT64 |
| | | | | | | ); |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Exemplo 3:
O exemplo a seguir recupera colunas table_name
e ddl
da visualização INFORMATION_SCHEMA.TABLES
para a tabela population_by_zip_2010
no
conjunto de dados
census_bureau_usa
. Esse conjunto de dados faz parte do
programa de conjunto de dados públicos do BigQuery.
Como a tabela que você está consultando está em outro projeto, adicione o ID do projeto ao conjunto de dados no
seguinte formato:
`project_id`.dataset.INFORMATION_SCHEMA.view
.
Neste exemplo, o valor é
`bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT table_name, ddl FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES WHERE table_name="population_by_zip_2010"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT table_name, ddl FROM `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES WHERE table_name="population_by_zip_2010"'
Os resultados terão o seguinte formato:
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | 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", "")] | | | ); | +------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
Visualização TABLE_OPTIONS
Os resultados das consultas na visualização INFORMATION_SCHEMA.TABLE_OPTIONS
contêm uma linha para cada opção, para cada tabela ou visualização do conjunto de dados. Para informações detalhadas sobre visualizações, consulte a visualização INFORMATION_SCHEMA.VIEWS
.
A visualização INFORMATION_SCHEMA.TABLE_OPTIONS
tem o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
TABLE_CATALOG |
STRING |
O ID do projeto que contém o conjunto de dados |
TABLE_SCHEMA |
STRING |
O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId |
TABLE_NAME |
STRING |
O nome da tabela ou visualização, também conhecido como tableId |
OPTION_NAME |
STRING |
Um dos valores de nome na tabela opções. |
OPTION_TYPE |
STRING |
Um dos valores de tipo de dados na tabela de opções. |
OPTION_VALUE |
STRING |
Uma das opções de valor na tabela de opções. |
Tabela de opções
OPTION_NAME |
OPTION_TYPE |
OPTION_VALUE |
---|---|---|
partition_expiration_days |
FLOAT64 |
A vida útil padrão, em dias, de todas as partições em uma tabela particionada |
expiration_timestamp |
FLOAT64 |
A hora em que esta tabela expira |
kms_key_name |
STRING |
O nome da chave do Cloud KMS usada para criptografar a tabela |
friendly_name |
STRING |
O nome descritivo da tabela. |
description |
STRING |
Uma descrição da tabela |
labels |
ARRAY<STRUCT<STRING, STRING>> |
Uma matriz de STRUCT s que representa as identificações na tabela |
require_partition_filter |
BOOL |
Se as consultas na tabela exigem um filtro de partição |
enable_refresh |
BOOL |
Se a atualização automática está ativada para uma visualização materializada. |
refresh_interval_minutes |
FLOAT64 |
Com que frequência uma visualização materializada é atualizada |
Em tabelas externas, as seguintes opções também podem ser usadas:
Opções | |
---|---|
allow_jagged_rows |
Se Aplica-se a dados CSV. |
allow_quoted_newlines |
Se Aplica-se a dados CSV. |
compression |
O tipo de compactação da fonte de dados. Os valores aceitos são:
Aplica-se a dados CSV e JSON. |
enable_logical_types |
Se Aplica-se a dados Avro. |
encoding |
A codificação de caracteres dos dados. Os valores aceitos incluem:
Aplica-se a dados CSV. |
field_delimiter |
O separador de campos em um arquivo CSV. Aplica-se a dados CSV. |
format |
O formato dos dados externos.
Os valores aceitos são: O valor |
decimal_target_types |
Determina como converter um tipo Exemplo: |
json_extension |
Para dados JSON, indica um determinado formato de intercâmbio JSON. Se não for especificado, o BigQuery lerá os dados como registros JSON genéricos. Os valores aceitos são: |
hive_partition_uri_prefix |
Um prefixo comum para todos os URIs de origem antes do início da codificação da chave de partição. Aplica-se apenas a tabelas externas particionadas pelo Hive. Aplica-se aos dados Avro, CSV, JSON, Parquet e ORC. Exemplo: |
ignore_unknown_values |
Se for Aplica-se a dados CSV e JSON. |
max_bad_records |
O número máximo de registros corrompidos a serem ignorados durante a leitura dos dados. Aplica-se a: dados CSV, JSON e Planilhas. |
null_marker |
A string que representa os valores Aplica-se a dados CSV. |
projection_fields |
Uma lista de propriedades da entidade a serem carregadas. Aplica-se aos dados do Datastore. |
quote |
A string usada para citar seções de dados em um arquivo CSV. Se os dados
contiverem caracteres de nova linha entre aspas, defina também a
propriedade Aplica-se a dados CSV. |
require_hive_partition_filter |
Se Aplica-se aos dados Avro, CSV, JSON, Parquet e ORC. |
sheet_range |
Intervalo de uma planilha do Planilhas a ser consultada. Aplicável aos dados do Planilhas. Exemplo: |
skip_leading_rows |
O número de linhas na parte superior de um arquivo a ser ignorado na leitura dos dados. Aplicável aos dados CSV e Planilhas. |
uris |
Uma matriz de URIs totalmente qualificados para os locais de dados externos. Exemplo: |
Exemplos
Exemplo 1:
O exemplo a seguir recupera os prazos de validade da tabela padrão para todas as tabelas em mydataset
no seu projeto padrão (myproject
) consultando a visualização INFORMATION_SCHEMA.TABLE_OPTIONS
.
Para executar a consulta em um projeto diferente do projeto padrão, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
. Veja um exemplo: `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name="expiration_timestamp"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name="expiration_timestamp"'
Os resultados terão o seguinte formato:
+----------------+---------------+------------+----------------------+-------------+--------------------------------------+ | 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" | +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
Exemplo 2:
O exemplo a seguir recupera os metadados sobre todas as tabelas em mydataset
que contêm dados de teste. A consulta usa os valores da opção description
para encontrar tabelas que contenham "teste" em qualquer parte da descrição. mydataset
está no projeto padrão (myproject
).
Para executar a consulta em um projeto diferente do projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
(por exemplo, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
).
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name="description" AND option_value LIKE "%test%"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS WHERE option_name="description" AND option_value LIKE "%test%"'
Os resultados terão o seguinte formato:
+----------------+---------------+------------+-------------+-------------+--------------+ | 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" | +----------------+---------------+------------+-------------+-------------+--------------+
Visualização COLUMNS
Os resultados das consultas na visualização INFORMATION_SCHEMA.COLUMNS
contêm uma linha para cada coluna (campo) da tabela.
A visualização INFORMATION_SCHEMA.COLUMNS
tem o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
TABLE_CATALOG |
STRING |
O ID do projeto que contém o conjunto de dados |
TABLE_SCHEMA |
STRING |
O nome do conjunto de dados que contém a tabela, também conhecido como datasetId |
TABLE_NAME |
STRING |
O nome da tabela ou visualização, também conhecido como tableId |
COLUMN_NAME |
STRING |
O nome da coluna |
ORDINAL_POSITION |
INT64 |
O deslocamento de índice 1 da coluna na tabela. Se for uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE, o valor será NULL |
IS_NULLABLE |
STRING |
YES ou NO , dependendo do modo da coluna permitir valores NULL |
DATA_TYPE |
STRING |
O tipo de dados SQL padrão da coluna |
IS_GENERATED |
STRING |
O valor sempre é NEVER . |
GENERATION_EXPRESSION |
STRING |
O valor sempre é NULL |
IS_STORED |
STRING |
O valor sempre é NULL . |
IS_HIDDEN |
STRING |
YES ou NO , dependendo do tipo de coluna (se é ou não é uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE) |
IS_UPDATABLE |
STRING |
O valor sempre é NULL . |
IS_SYSTEM_DEFINED |
STRING |
YES ou NO , dependendo do tipo de coluna (se é ou não é uma pseudocoluna, como _PARTITIONTIME ou _PARTITIONDATE) |
IS_PARTITIONING_COLUMN |
STRING |
YES ou NO dependendo se a coluna é uma coluna de particionamento ou não |
CLUSTERING_ORDINAL_POSITION |
INT64 |
O deslocamento de índice 1 da coluna nas colunas de cluster da tabela. O valor será NULL se a tabela não for uma tabela em cluster |
COLLATION_NAME |
STRING |
Nome da especificação da compilação, se ela existir; Caso contrário, NULL Se um STRING ou ARRAY<STRING> for transmitido,
a especificação de compilação será retornada, se existir; Caso contrário,
NULL é retornado.
|
Examples
O exemplo a seguir recupera metadados da visualização INFORMATION_SCHEMA.COLUMNS
para a tabela population_by_zip_2010
no conjunto de dados census_bureau_usa
. Ele faz parte do programa de conjunto de dados públicos do BigQuery.
Como a tabela que você está consultando está em outro projeto, bigquery-public-data
, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; por exemplo, `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
.
As colunas a seguir são excluídas dos resultados da consulta porque atualmente estão reservadas para uso futuro:
IS_GENERATED
GENERATION_EXPRESSION
IS_STORED
IS_UPDATABLE
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.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"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ '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"'
Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+ | 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 | +------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
Visualização COLUMN_FIELD_PATHS
Os resultados das consultas na visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
contêm uma linha para cada coluna aninhada dentro de uma coluna RECORD
(ou STRUCT
).
A visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
tem o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
TABLE_CATALOG |
STRING |
O ID do projeto que contém o conjunto de dados |
TABLE_SCHEMA |
STRING |
O nome do conjunto de dados que contém a tabela, também conhecido como datasetId |
TABLE_NAME |
STRING |
O nome da tabela ou visualização, também conhecido como tableId |
COLUMN_NAME |
STRING |
O nome da coluna |
FIELD_PATH |
STRING |
O caminho para uma coluna aninhada em uma coluna `RECORD` ou `STRUCT`. |
DATA_TYPE |
STRING |
O tipo de dados SQL padrão da coluna. |
DESCRIPTION |
STRING |
A descrição da coluna |
COLLATION_NAME |
STRING |
Nome da especificação da compilação, se ela existir; Caso contrário, NULL Se um campo STRING , ARRAY<STRING> ou
STRING em um STRUCT for transmitido, a
especificação de compilação será retornada, se existir. Caso contrário,
NULL é retornado.
|
Examples
O exemplo a seguir recupera metadados da visualização INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
para a tabela commits
no conjunto de dados github_repos
.
Ele faz parte do programa de conjunto de dados públicos do BigQuery.
Como a tabela que você está consultando está em outro projeto, bigquery-public-data
, adicione o código do projeto ao conjunto de dados no seguinte formato: `project_id`.dataset.INFORMATION_SCHEMA.view
; por exemplo, `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
.
A tabela commits
contém as seguintes colunas aninhadas e repetidas ou só aninhadas:
author
: colunaRECORD
aninhadacommitter
: colunaRECORD
aninhadatrailer
: colunaRECORD
aninhada e repetidadifference
: colunaRECORD
aninhada e repetida
A consulta vai recuperar os metadados sobre as colunas author
e difference
.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT * FROM `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS WHERE table_name="commits" AND column_name="author" OR column_name="difference"
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT * FROM `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS WHERE table_name="commits" AND column_name="author" OR column_name="difference"'
Os resultados terão a aparência abaixo. Para facilitar a leitura, algumas colunas são excluídas dos resultados.
+------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+ | 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 | +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
Visualização TABLE_STORAGE
A visualização INFORMATION_SCHEMA.TABLE_STORAGE
fornece um snapshot atual do
uso do armazenamento das tabelas
e visualizações materializadas. Quando você consulta a visualização INFORMATION_SCHEMA.TABLE_STORAGE
,
os resultados da consulta contêm uma linha para cada tabela ou visualização materializada. Os
dados dessa tabela não são mantidos em tempo real e podem atrasar de
alguns segundos a alguns minutos.
Os dados da visualização são regionalizados. Portanto, é necessário usar um qualificador de região em consultas na visualização. O projeto padrão será usado se você não especificar um.
Os exemplos a seguir mostram como retornar dados de um projeto ou região.
Retorna informações de armazenamento de tabelas em um projeto especificado:
SELECT * FROM myProject.`region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;
Retorna informações de armazenamento de tabelas em uma região especificada:
SELECT * FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;
A visualização INFORMATION_SCHEMA.TABLE_STORAGE
tem o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
PROJECT_ID |
STRING |
O ID do projeto que contém o conjunto de dados |
PROJECT_NAME |
INT64 |
O número do projeto que contém o conjunto de dados |
TABLE_SCHEMA |
STRING |
O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId |
TABLE_NAME |
STRING |
O nome da tabela ou visualização, também conhecido como tableId |
CREATION_TIME |
TIMESTAMP |
O horário de criação da tabela |
TOTAL_ROWS |
INT64 |
O número total de linhas na tabela ou visualização materializada |
TOTAL_PARTITIONS |
INT64 |
O número de partições presentes na tabela ou na visualização materializada. Tabelas não particionadas retornam 0. |
TOTAL_LOGICAL_BYTES |
INT64 |
Número total de bytes lógicos na tabela ou visualização materializada |
ACTIVE_LOGICAL_BYTES |
INT64 |
Número de bytes lógicos com menos de 90 dias |
LONG_TERM_LOGICAL_BYTES |
INT64 |
Número de bytes lógicos com mais de 90 dias |
TOTAL_PHYSICAL_BYTES |
INT64 |
Número total de bytes físicos usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (para tabelas excluídas) |
ACTIVE_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos com menos de 90 dias |
LONG_TERM_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos com mais de 90 dias |
TIME_TRAVEL_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados) |
Examples
O exemplo a seguir mostra quais projetos da organização estão usando mais armazenamento.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT project_id, SUM(total_logical_bytes) AS total_logical_bytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE GROUP BY project_id ORDER BY total_logical_bytes DESC;
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT project_id, SUM(total_logical_bytes) AS total_logical_bytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE GROUP BY project_id ORDER BY total_logical_bytes DESC;'
Os resultados vão ter o seguinte formato:
+---------------------+---------------------+ | project_id | total_logical_bytes | +---------------------+---------------------+ | projecta | 971329178274633 | +---------------------+---------------------+ | projectb | 834638211024843 | +---------------------+---------------------+ | projectc | 562910385625126 | +---------------------+---------------------+
VisualizaçõesTABLE_STORAGE_TIMELINE_BY_
As visualizações da linha do tempo do armazenamento de tabela retornam uma linha para cada evento que aciona uma alteração de armazenamento, como gravação, atualização ou exclusão de uma linha. Isso significa que pode haver várias linhas para uma tabela em um único dia. Ao consultar uma visualização para um período, use o carimbo de data/hora mais recente no dia pretendido.
As seguintes visualizações de linha do tempo do armazenamento de tabelas estão disponíveis:
INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT
retorna informações de todas as tabelas no projeto atual ou especificado.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION
retorna informações de todas as tabelas na pasta pai do projeto atual ou especificado, incluindo os projetos em subpastas abaixo dele.
Os dados da visualização são regionalizados. Portanto, é necessário usar um qualificador de região em consultas na visualização.
As visualizações da linha do tempo do armazenamento da tabela têm o seguinte esquema:
Nome da coluna | Tipo de dados | Valor |
---|---|---|
TIMESTAMP |
TIMESTAMP |
Carimbo de data/hora do último cálculo do armazenamento. O novo cálculo é acionado por alterações nos dados da tabela. |
DELETED |
BOOLEAN |
Indica se a tabela foi excluída. |
PROJECT_ID |
STRING |
O ID do projeto que contém o conjunto de dados |
PROJECT_NAME |
INT64 |
O número do projeto que contém o conjunto de dados |
TABLE_SCHEMA |
STRING |
O nome do conjunto de dados que contém a tabela ou visualização, também conhecido como datasetId |
TABLE_NAME |
STRING |
O nome da tabela ou visualização, também conhecido como tableId |
CREATION_TIME |
TIMESTAMP |
O horário de criação da tabela |
TOTAL_ROWS |
INT64 |
O número total de linhas na tabela ou visualização materializada |
TOTAL_PARTITIONS |
INT64 |
O número de partições da tabela ou da visualização materializada. Tabelas não particionadas retornam 0. |
TOTAL_LOGICAL_BYTES |
INT64 |
Número total de bytes lógicos na tabela ou visualização materializada |
ACTIVE_LOGICAL_BYTES |
INT64 |
Número de bytes lógicos com menos de 90 dias |
LONG_TERM_LOGICAL_BYTES |
INT64 |
Número de bytes lógicos com mais de 90 dias |
TOTAL_PHYSICAL_BYTES |
INT64 |
Número total de bytes físicos usados para armazenamento, incluindo bytes ativos, de longo prazo e de viagem no tempo (para tabelas excluídas) |
ACTIVE_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos com menos de 90 dias |
LONG_TERM_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos com mais de 90 dias |
TIME_TRAVEL_PHYSICAL_BYTES |
INT64 |
Número de bytes físicos usados pelo armazenamento de viagem no tempo (dados excluídos ou alterados) |
Examples
Exemplo 1:
O exemplo a seguir mostra quais tabelas estão usando mais armazenamento em um conjunto de dados específico.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.SELECT timestamp AS start_time, table_name, total_logical_bytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT WHERE table_schema = "TABLE_SCHEMA" AND table_name = "TABLE_NAME" ORDER BY start_time DESC;
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'SELECT timestamp AS start_time, table_name, total_logical_bytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_PROJECT WHERE table_schema = "TABLE_SCHEMA" AND table_name = "TABLE_NAME" ORDER BY start_time DESC;'
Os resultados terão o seguinte formato:
------------------------+---------------------+----------------------+ | start_time | table_name | total_logical_bytes | +-----------------------+---------------------+----------------------+ | 2022-03-30 17:39:54 | table1 | 322 | | 2022-03-30 17:39:54 | table2 | 1657 | | 2022-03-30 17:39:53 | table1 | 320 | | 2022-03-30 17:39:53 | table2 | 1655 | +-----------------------+---------------------+----------------------+
Exemplo 2:
O exemplo a seguir mostra a soma do armazenamento físico usado por cada projeto na organização em um determinado momento.
Para executar a consulta, faça o seguinte:
Console
Abra a página do BigQuery no console do Cloud.
Insira a consulta SQL padrão a seguir na caixa Editor de consultas.
INFORMATION_SCHEMA
requer sintaxe SQL padrão. O SQL padrão é a sintaxe padrão do console do Cloud.WITH most_recent_records as ( SELECT project_id, table_schema, table_name, MAX(timestamp) as max_timestamp FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION WHERE timestamp <= "TIMESTAMP" GROUP BY project_id, table_schema, table_name ) SELECT i_s.project_id, SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s JOIN most_recent_records ON i_s.project_id=most_recent_records.project_id AND i_s.table_schema=most_recent_records.table_schema AND i_s.table_name=most_recent_records.table_name AND i_s.timestamp = most_recent_records.max_timestamp GROUP BY project_id;
Clique em Executar.
bq
Use o comando bq query
e especifique a sintaxe SQL padrão usando a sinalização
--nouse_legacy_sql
ou --use_legacy_sql=false
. A sintaxe SQL padrão
é obrigatória para consultas INFORMATION_SCHEMA
.
Para executar a consulta, insira:
bq query --nouse_legacy_sql \ 'WITH most_recent_records as ( SELECT project_id, table_schema, table_name, MAX(timestamp) as max_timestamp FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION WHERE timestamp <= "TIMESTAMP" GROUP BY project_id, table_schema, table_name ) SELECT i_s.project_id, SUM(i_s.total_physical_bytes) AS TotalPhysicalBytes FROM `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_TIMELINE_BY_ORGANIZATION as i_s JOIN most_recent_records ON i_s.project_id=most_recent_records.project_id AND i_s.table_schema=most_recent_records.table_schema AND i_s.table_name=most_recent_records.table_name AND i_s.timestamp = most_recent_records.max_timestamp GROUP BY project_id;'
Os resultados vão ter o seguinte formato:
-----------------+------------------------+ | project_id | TotalPhysicalBytes | +----------------+------------------------+ | projecta | 3844 | | projectb | 16022778 | | projectc | 8934009 | +----------------+------------------------+
Listar tabelas em um conjunto de dados
É possível listar tabelas em conjuntos de dados das seguintes maneiras:
- Como usar o console do Cloud
- Como usar o comando
bq
da ferramenta de linha de comandobq ls
. - Chamada do método de API
tables.list
- Como usar bibliotecas de cliente.
Permissões necessárias
Para listar tabelas em um conjunto de dados, é preciso ter pelo menos as permissões bigquery.tables.list
. Os seguintes papéis predefinidos
do IAM incluem as permissões bigquery.tables.list
:
bigquery.user
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataEditor
bigquery.dataOwner
bigquery.admin
Para mais informações sobre papéis e permissões do IAM no BigQuery, consulte Controle de acesso.
Listar tabelas
Para listar as tabelas em um conjunto de dados:
Console
No console do Cloud, no painel de navegação, clique no conjunto de dados para expandi-lo. Isso exibe as tabelas e visualizações no conjunto de dados.
Percorra a lista para ver as tabelas no conjunto de dados. Tabelas e visualizações são identificadas por ícones diferentes.
bq
Emita o comando bq ls
. É possível usar a sinalização --format
para controlar a saída. Se estiver listando tabelas em um projeto diferente do seu projeto padrão, adicione o ID do projeto ao conjunto de dados no seguinte formato:
project_id:dataset
.
Veja a seguir algumas outras sinalizações:
--max_results
ou-n
: um número inteiro que indica o valor máximo de resultados. O valor padrão é50
.
bq ls \ --format=pretty \ --max_results integer \ project_id:dataset
Em que:
- integer é um número inteiro que representa o total de tabelas a serem listadas;
- project_id é o ID do projeto;
- dataset é o nome do conjunto de dados.
Quando você executa o comando, o campo Type
exibe TABLE
ou
VIEW
. Por exemplo:
+-------------------------+-------+----------------------+-------------------+ | tableId | Type | Labels | Time Partitioning | +-------------------------+-------+----------------------+-------------------+ | mytable | TABLE | department:shipping | | | myview | VIEW | | | +-------------------------+-------+----------------------+-------------------+
Exemplos:
Digite o comando a seguir para listar tabelas no conjunto de dados mydataset
no seu projeto padrão.
bq ls --format=pretty mydataset
Digite o comando a seguir para retornar mais do que a saída padrão de 50 tabelas de mydataset
. mydataset
está em seu projeto padrão.
bq ls --format=pretty --max_results 60 mydataset
Digite o comando a seguir para listar tabelas no conjunto de dados mydataset
em myotherproject
.
bq ls --format=pretty myotherproject:mydataset
API
Para listar tabelas usando a API, chame o método tables.list
.
C#
Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em C#.
Go
Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Go.
Java
Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Java.
Node.js
Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.
PHP
Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery PHP.
Python
Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery em Python.
Ruby
Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de Referência da API BigQuery Ruby.
Segurança de tabelas
Para controlar o acesso a tabelas no BigQuery, consulte Introdução aos controles de acesso a tabelas.
Próximas etapas
- Para mais informações sobre conjuntos de dados, consulte Introdução aos conjuntos de dados.
- Para mais informações sobre o gerenciamento de dados da tabela, consulte Como gerenciar dados da tabela.
- Para mais informações sobre como especificar esquemas de tabela, consulte Como especificar um esquema.
- Para mais informações sobre como modificar esquemas de tabelas, consulte esta página.
- Para mais informações sobre como gerenciar tabelas, consulte Como gerenciar tabelas.
- Acesse Introdução ao BigQuery
INFORMATION_SCHEMA
para uma visão geral deINFORMATION_SCHEMA
.
Faça um teste
Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do BigQuery em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
Faça uma avaliação gratuita do BigQuery