Criar tabelas do Amazon S3 BigLake

Console

1. Acessar a página do BigQuery.

   Acessar o BigQuery

2. No painel Explorador, selecione o projeto em que você quer criar o conjunto de dados.
3. Expanda a opção more_vert Ver ações e clique em Criar conjunto de dados.
4. Na página Criar conjunto de dados, especifique os seguintes detalhes:
1. Em ID do conjunto de dados, insira um nome exclusivo para o conjunto de dados.
2. Em Local dos dados, escolha uma região compatível.
3. Para excluir tabelas automaticamente, marque a caixa de seleção Ativar expiração da tabela e defina a idade máxima da tabela padrão em dias. Os dados no Amazon S3 não são excluídos quando a tabela expira.
4. Se você quiser usar a ordenação padrão, expanda a seção Opções avançadas e selecione Ativar a ordenação padrão.
5. Clique em Criar conjunto de dados.

SQL

Use a instrução DDL CREATE SCHEMA. O exemplo a seguir cria um conjunto de dados na região aws-us-east-1:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

   CREATE SCHEMA mydataset
   OPTIONS (
     location = 'aws-us-east-1');
   

3. Clique em play_circle Executar.

Para mais informações sobre como executar consultas, acesse Executar uma consulta interativa.

bq

Em um ambiente de linha de comando, crie um conjunto de dados usando o comando bq mk:

bq --location=LOCATION mk \
    --dataset \
PROJECT_ID:DATASET_NAME

O parâmetro --project_id substitui o projeto padrão.

Substitua:

• LOCATION: o local do conjunto de dados

  Para informações sobre regiões com suporte, consulte Locais. Depois de criar um conjunto de dados, não será possível alterar o local dele. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.

• PROJECT_ID: ID do projeto

• DATASET_NAME: o nome da imagem que você quer criar.

  Para criar um conjunto de dados em um projeto diferente do projeto padrão, adicione a ID do projeto ao nome do conjunto de dados no seguinte formato: PROJECT_ID:DATASET_NAME.

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetInfo;

// Sample to create a aws dataset
public class CreateDatasetAws {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Note: As of now location only supports aws-us-east-1
    String location = "aws-us-east-1";
    createDatasetAws(projectId, datasetName, location);
  }

  public static void createDatasetAws(String projectId, String datasetName, String location) {
    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();

      DatasetInfo datasetInfo =
          DatasetInfo.newBuilder(projectId, datasetName).setLocation(location).build();

      Dataset dataset = bigquery.create(datasetInfo);
      System.out.println(
          "Aws dataset created successfully :" + dataset.getDatasetId().getDataset());
    } catch (BigQueryException e) {
      System.out.println("Aws dataset was not created. \n" + e.toString());
    }
  }
}

Console

1. Acessar a página do BigQuery.

   Ir para o BigQuery

2. No painel Explorer, expanda seu projeto e selecione um conjunto de dados.

3. Na seção Informações do conjunto de dados, clique em add_box Criar tabela.

4. Na página Criar tabela, na seção Origem, faça o seguinte:

   1. Em Criar tabela de, selecione Amazon S3.
   2. Em Selecionar caminho S3, insira um URI que aponta para os dados do Amazon S3 no formato s3://BUCKET_NAME/PATH. Substitua BUCKET_NAME pelo nome do bucket do Amazon S3. A região do bucket precisa ser a mesma do conjunto de dados. Substitua PATH pelo caminho em que você quer gravar o arquivo exportado. Ele pode conter um caractere curinga *.
   3. Em Formato do arquivo, selecione o formato de dados em S3. Os formatos aceitos são AVRO, CSV, DELTA_LAKE, ICEBERG, JSONL, ORC e PARQUET.

5. Na seção Destino, especifique os seguintes detalhes:

   1. Em Conjunto de dados, escolha o conjunto de dados adequado.
   2. No campo Tabela, insira o nome da tabela.
   3. Verifique se o Tipo de tabela está definido como Tabela externa.
   4. Em ID da conexão, escolha o ID apropriado no menu suspenso. Para informações sobre conexões, consulte Conectar ao Amazon S3.

6. Se você tiver um arquivo de origem, na seção Esquema, ative a detecção automática de esquema ou especifique manualmente um esquema. Se você não tiver um arquivo de origem, especifique um esquema manualmente.

   • Para ativar a detecção automática de esquema, selecione a opção Detectar automaticamente.

   • Para especificar um esquema manualmente, deixe a opção Detectar automaticamente desmarcada. Ative Editar como texto e insira o esquema da tabela como uma matriz JSON.

7. Selecione Criar tabela.

SQL

Para criar uma tabela do BigLake, use a instrução CREATE EXTERNAL TABLE com a cláusula WITH CONNECTION:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

   CREATE EXTERNAL TABLE DATASET_NAME.TABLE_NAME
     WITH CONNECTION `AWS_LOCATION.CONNECTION_NAME`
     OPTIONS (
       format = "DATA_FORMAT",
       uris = ["S3_URI"],
       max_staleness = STALENESS_INTERVAL,
       metadata_cache_mode = 'CACHE_MODE');
   

   Substitua:

   • DATASET_NAME: o nome do conjunto de dados que você criou.
   • TABLE_NAME: o nome que você quer dar a esta tabela.
   • AWS_LOCATION: um local da AWS no Google Cloud (por exemplo, "aws-us-east-1").
   • CONNECTION_NAME: o nome da conexão que você criou.
   • DATA_FORMAT: qualquer um dos formatos federados do BigQuery compatíveis, como AVRO, CSV, DELTA_LAKE, ICEBERG ou PARQUET (pré-lançamento)
   • S3_URI: um URI que aponta para os dados do S3 (por exemplo, s3://bucket/path).
   • STALENESS_INTERVAL: especifica se os metadados em cache são usados pelas operações na tabela do BigLake e quando eles precisam ser atualizados para que a operação possa usá-los. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

     Para desativar o armazenamento em cache de metadados, especifique 0. Esse é o padrão.

     Para ativar o armazenamento em cache de metadados, especifique um valor de literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de inatividade de 4 horas. Com esse valor, as operações na tabela usarão metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados armazenados em cache forem mais antigos que isso, a operação vai recuperar metadados do Amazon S3.

   • CACHE_MODE: especifica se o cache de metadados é atualizado de forma automática ou manual. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

     Defina como AUTOMATIC para que o cache de metadados seja atualizado em um intervalo definido pelo sistema, geralmente entre 30 e 60 minutos.

     Defina como MANUAL se quiser atualizar o cache de metadados com uma programação que você determinar. Nesse caso, chame o procedimento do sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE para atualizar o cache.

     Defina CACHE_MODE se STALENESS_INTERVAL estiver definido como um valor maior que 0.

3. Clique em play_circle Executar.

Para mais informações sobre como executar consultas, acesse Executar uma consulta interativa.

Exemplo:

CREATE EXTERNAL TABLE awsdataset.awstable
  WITH CONNECTION `aws-us-east-1.s3-read-connection`
  OPTIONS (
    format="CSV",
    uris=["s3://s3-bucket/path/file.csv"],
    max_staleness = INTERVAL 1 DAY,
    metadata_cache_mode = 'AUTOMATIC'
);

bq

Crie um arquivo de definição da tabela:

bq mkdef  \
--source_format=DATA_FORMAT \
--connection_id=AWS_LOCATION.CONNECTION_NAME \
--metadata_cache_mode=CACHE_MODE \
S3_URI > table_def

Substitua:

• DATA_FORMAT: qualquer um dos formatos federados do BigQuery compatíveis, como AVRO, CSV, DELTA_LAKE, ICEBERG ou PARQUET.
• S3_URI: um URI que aponta para os dados do S3 (por exemplo, s3://bucket/path).
• AWS_LOCATION: um local da AWS no Google Cloud (por exemplo, aws-us-east-1).

• CONNECTION_NAME: o nome da conexão que você criou.

• CACHE_MODE: especifica se o cache de metadados é atualizado de forma automática ou manual. Você só precisa incluir essa flag se também planeja usar a flag --max_staleness no comando bq mk subsequente para ativar o armazenamento em cache de metadados. Para mais considerações sobre o armazenamento de metadados em cache, consulte Armazenamento de metadados em cache para fins de desempenho.

  Defina como AUTOMATIC para que o cache de metadados seja atualizado em um intervalo definido pelo sistema, geralmente entre 30 e 60 minutos.

  Defina como MANUAL se quiser atualizar o cache de metadados com uma programação que você determinar. Nesse caso, chame o procedimento do sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE para atualizar o cache. Defina CACHE_MODE se STALENESS_INTERVAL estiver definido como um valor maior que 0.

Em seguida, crie a tabela do BigLake:

bq mk --max_staleness=STALENESS_INTERVAL --external_table_definition=table_def DATASET_NAME.TABLE_NAME

Substitua:

• STALENESS_INTERVAL: especifica se os metadados em cache são usados pelas operações na tabela do BigLake e quando eles precisam ser atualizados para que a operação possa usá-los. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

  Para desativar o armazenamento em cache de metadados, especifique 0. Esse é o padrão.

  Para ativar o armazenamento em cache de metadados, especifique um valor de literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de inatividade de quatro horas. Com esse valor, as operações na tabela usarão metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados armazenados em cache forem mais antigos que isso, a operação vai recuperar metadados do Amazon S3.

• DATASET_NAME: o nome do conjunto de dados que você criou.

• TABLE_NAME: o nome que você quer dar a esta tabela.

Por exemplo, o comando a seguir cria uma tabela externa, awsdataset.awstable, que pode consultar os dados da Amazon S3 armazenados no caminho s3://s3-bucket/path/file.csv e tem uma conexão de leitura no local aws-us-east-1:

bq mkdef  \
--autodetect \
--source_format=CSV \
--connection_id=aws-us-east-1.s3-read-connection \
--metadata_cache_mode=AUTOMATIC \
s3://s3-bucket/path/file.csv > table_def

bq mk --max_staleness=INTERVAL "1" HOUR \
--external_table_definition=table_def awsdataset.awstable

API

Chame o método de API tables.insert e crie um ExternalDataConfiguration no recurso Table que você transmite.

Especifique a property schema ou defina a property autodetect como true para ativar a detecção automática de esquema para fontes de dados compatíveis.

Especifique a propriedade connectionId para identificar a conexão a ser usada para se conectar ao Amazon S3.

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CsvOptions;
import com.google.cloud.bigquery.ExternalTableDefinition;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create an external aws table
public class CreateExternalTableAws {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String connectionId = "MY_CONNECTION_ID";
    String sourceUri = "s3://your-bucket-name/";
    CsvOptions options = CsvOptions.newBuilder().setSkipLeadingRows(1).build();
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    ExternalTableDefinition externalTableDefinition =
        ExternalTableDefinition.newBuilder(sourceUri, options)
            .setConnectionId(connectionId)
            .setSchema(schema)
            .build();
    createExternalTableAws(projectId, datasetName, tableName, externalTableDefinition);
  }

  public static void createExternalTableAws(
      String projectId,
      String datasetName,
      String tableName,
      ExternalTableDefinition externalTableDefinition) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, externalTableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Aws external table created successfully");

      // Clean up
      bigquery.delete(TableId.of(projectId, datasetName, tableName));
    } catch (BigQueryException e) {
      System.out.println("Aws external was not created." + e.toString());
    }
  }
}

Console

1. Acessar a página do BigQuery.

   Ir para o BigQuery

2. No painel Explorer, expanda o projeto e selecione um conjunto de dados.

3. Clique em more_vert Acessar ações e depois em Criar tabela. O painel Criar tabela será aberto.

4. Na seção Origem, especifique os seguintes campos:

   1. Em Criar tabela de, selecione Amazon S3.

   2. Forneça o caminho para a pasta usando caracteres curinga. Por exemplo, s3://mybucket/*.

      A pasta precisa estar no mesmo local que o conjunto de dados que contém a tabela que você quer criar, anexar ou substituir.

   3. Na lista Formato de arquivo, selecione o tipo de arquivo.

   4. Marque a caixa de seleção Particionamento de dados de origem e especifique os seguintes detalhes:

      1. Em Selecionar prefixo do URI de origem, insira o prefixo de URI. Por exemplo, s3://mybucket/my_files.
      2. Opcional: para exigir um filtro de partição em todas as consultas desta tabela, marque a caixa de seleção Exigir filtro de partição. A exigência de um filtro de partição pode reduzir custos e melhorar o desempenho. Para mais informações, consulte Como exigir filtros de predicado em chaves de partição em consultas.

      3. Na seção Modo de inferência de partição, selecione uma das seguintes opções:

         • Inferir automaticamente os tipos: defina o modo de detecção do esquema de partição como AUTO.
         • Todas as colunas são strings: defina o modo de detecção de esquema de partição como STRINGS.
         • Forneça meu próprio: defina o modo de detecção de esquema de partição como CUSTOM e insira manualmente as informações do esquema para as chaves de partição. Para mais informações, consulte Fornecer um esquema de chave de partição personalizado.

5. Na seção Destino, especifique os seguintes detalhes:

   1. Em Projeto, selecione o projeto em que você quer criar a tabela.
   2. Em Conjunto de dados, selecione o conjunto de dados em que você quer criar a tabela.
   3. Em Tabela, insira o nome da tabela que você quer criar.
   4. Em Tipo de tabela, verifique se Tabela externa está selecionado.
   5. Em ID da conexão, selecione a conexão que você criou anteriormente.

6. Na seção Esquema, é possível ativar a detecção automática de esquema ou especificar manualmente um esquema se você tiver um arquivo de origem. Se você não tiver um arquivo de origem, especifique um esquema manualmente.

   • Para ativar a detecção automática de esquema, selecione a opção Detectar automaticamente.

   • Para especificar um esquema manualmente, deixe a opção Detectar automaticamente desmarcada. Ative Editar como texto e insira o esquema da tabela como uma matriz JSON.

7. Para ignorar linhas com valores de colunas extras que não correspondem ao esquema, expanda a seção Opções avançadas e selecione Valores desconhecidos.

8. Selecione Criar tabela.

SQL

Use a instrução DDL CREATE EXTERNAL TABLE:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

   CREATE EXTERNAL TABLE `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME`
   WITH PARTITION COLUMNS
   (
     PARTITION_COLUMN PARTITION_COLUMN_TYPE,
   )
   WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID`
   OPTIONS (
     hive_partition_uri_prefix = "HIVE_PARTITION_URI_PREFIX",
     uris=['FILE_PATH'],
     format ="TABLE_FORMAT"
     max_staleness = STALENESS_INTERVAL,
     metadata_cache_mode = 'CACHE_MODE'
   );
   

   Substitua:

   • PROJECT_ID: o nome do projeto em que você quer criar a tabela, por exemplo, myproject
   • DATASET: o nome do conjunto de dados do BigQuery em que você quer criar a tabela (por exemplo, mydataset)
   • EXTERNAL_TABLE_NAME: o nome da tabela que você quer criar, por exemplo, mytable
   • PARTITION_COLUMN: o nome da coluna de particionamento.
   • PARTITION_COLUMN_TYPE: o tipo da coluna de particionamento
   • REGION: a região que contém a conexão, por exemplo, us.
   • CONNECTION_ID: o nome da conexão. Por exemplo, myconnection
   • HIVE_PARTITION_URI_PREFIX: prefixo do URI de particionamento do Hive, por exemplo, s3://mybucket/
   • FILE_PATH: caminho para a fonte de dados da tabela externa que você quer criar, por exemplo, s3://mybucket/*.parquet
   • TABLE_FORMAT: o formato da tabela que você quer criar, por exemplo, PARQUET
   • STALENESS_INTERVAL: especifica se os metadados em cache são usados pelas operações na tabela do BigLake e quando eles precisam ser atualizados para que a operação possa usá-los. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

     Para desativar o armazenamento em cache de metadados, especifique 0. Esse é o padrão.

     Para ativar o armazenamento em cache de metadados, especifique um valor de literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de inatividade de 4 horas. Com esse valor, as operações na tabela usarão metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados armazenados em cache forem mais antigos que isso, a operação vai recuperar metadados do Amazon S3.

   • CACHE_MODE: especifica se o cache de metadados é atualizado de forma automática ou manual. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

     Defina como AUTOMATIC para que o cache de metadados seja atualizado em um intervalo definido pelo sistema, geralmente entre 30 e 60 minutos.

     Defina como MANUAL se quiser atualizar o cache de metadados com uma programação que você determinar. Nesse caso, chame o procedimento do sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE para atualizar o cache.

     Defina CACHE_MODE se STALENESS_INTERVAL estiver definido como um valor maior que 0.

3. Clique em play_circle Executar.

Para mais informações sobre como executar consultas, acesse Executar uma consulta interativa.

Exemplos

O exemplo a seguir cria uma tabela do BigLake com base em dados particionados no Amazon S3. O esquema é detectado automaticamente.

CREATE EXTERNAL TABLE `my_dataset.my_table`
WITH PARTITION COLUMNS
(
  sku STRING,
)
WITH CONNECTION `us.my-connection`
OPTIONS(
  hive_partition_uri_prefix = "s3://mybucket/products",
  uris = ['s3://mybucket/products/*']
  max_staleness = INTERVAL 1 DAY,
  metadata_cache_mode = 'AUTOMATIC'
);

bq

Primeiro, use o comando bq mkdef para criar um arquivo de definição de tabela:

bq mkdef \
--source_format=SOURCE_FORMAT \
--connection_id=REGION.CONNECTION_ID \
--hive_partitioning_mode=PARTITIONING_MODE \
--hive_partitioning_source_uri_prefix=URI_SHARED_PREFIX \
--require_hive_partition_filter=BOOLEAN \
--metadata_cache_mode=CACHE_MODE \
 URIS > DEFINITION_FILE

Substitua:

• SOURCE_FORMAT: o formato da fonte de dados externa. Por exemplo, CSV.
• REGION: a região que contém a conexão, por exemplo, us.
• CONNECTION_ID: o nome da conexão. Por exemplo, myconnection.
• PARTITIONING_MODE: o modo de particionamento do Hive. Use um dos seguintes valores:
  • AUTO: detecta automaticamente os nomes e tipos de chaves.
  • STRINGS: converte automaticamente os nomes das chaves em strings.
  • CUSTOM: codifique o esquema da chave no prefixo do URI de origem.
• URI_SHARED_PREFIX: o prefixo de URI de origem.

• BOOLEAN: especifica se um filtro de predicado é necessário no momento da consulta. Essa flag é opcional. O valor padrão é false.

• CACHE_MODE: especifica se o cache de metadados é atualizado de forma automática ou manual. Você só precisa incluir essa flag se também planeja usar a flag --max_staleness no comando bq mk subsequente para ativar o armazenamento em cache de metadados. Para mais considerações sobre o armazenamento de metadados em cache, consulte Armazenamento de metadados em cache para fins de desempenho.

  Defina como AUTOMATIC para que o cache de metadados seja atualizado em um intervalo definido pelo sistema, geralmente entre 30 e 60 minutos.

  Defina como MANUAL se quiser atualizar o cache de metadados com uma programação que você determinar. Nesse caso, chame o procedimento do sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE para atualizar o cache. Defina CACHE_MODE se STALENESS_INTERVAL estiver definido como um valor maior que 0.

• URIS: o caminho para a pasta do Amazon S3, usando o formato de caractere curinga.

• DEFINITION_FILE: o caminho para o arquivo de definição de tabelas na máquina local.

Se PARTITIONING_MODE for CUSTOM, inclua o esquema da chave de partição no prefixo do URI de origem, usando este formato:

--hive_partitioning_source_uri_prefix=URI_SHARED_PREFIX/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Depois de criar o arquivo de definição de tabela, use o comando bq mk para criar a tabela do BigLake:

bq mk --max_staleness=STALENESS_INTERVAL \
--external_table_definition=DEFINITION_FILE \
DATASET_NAME.TABLE_NAME \
SCHEMA

Substitua:

• STALENESS_INTERVAL: especifica se os metadados em cache são usados pelas operações na tabela do BigLake e quando eles precisam ser atualizados para que a operação possa usá-los. Para mais informações sobre considerações de armazenamento em cache de metadados, consulte Armazenamento em cache de metadados para desempenho.

  Para desativar o armazenamento em cache de metadados, especifique 0. Esse é o padrão.

  Para ativar o armazenamento em cache de metadados, especifique um valor de literal de intervalo entre 30 minutos e 7 dias. Por exemplo, especifique INTERVAL 4 HOUR para um intervalo de inatividade de quatro horas. Com esse valor, as operações na tabela usarão metadados em cache se tiverem sido atualizados nas últimas 4 horas. Se os metadados armazenados em cache forem mais antigos que isso, a operação vai recuperar metadados do Amazon S3.

• DEFINITION_FILE: o caminho para o arquivo de definição da tabela.

• DATASET_NAME: o nome do conjunto de dados onde está a tabela

• TABLE_NAME: o nome da tabela que você está criando;

• SCHEMA especifica um caminho para um arquivo de esquema JSON ou especifica o esquema no formato field:data_type,field:data_type,.... Para usar a detecção automática de esquema, omita esse argumento.

Exemplos

Confira no exemplo a seguir como usar o modo de particionamento do Hive AUTO para dados do Amazon S3:

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=AUTO \
  --hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
  --metadata_cache_mode=AUTOMATIC \
  s3://mybucket/* > mytable_def

bq mk --max_staleness=INTERVAL "1" HOUR \
  --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

Confira no exemplo a seguir como usar o modo de particionamento do Hive STRING para dados do Amazon S3:

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=STRING \
  --hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
  --metadata_cache_mode=AUTOMATIC \
  s3://mybucket/myTable/* > mytable_def

bq mk --max_staleness=INTERVAL "1" HOUR \
  --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

API

Para definir o particionamento do Hive usando a API do BigQuery, inclua o objeto hivePartitioningOptions no objeto ExternalDataConfiguration ao criar o arquivo de definição de tabela. Para criar uma tabela do BigLake, especifique também um valor para o campo connectionId.

Se você definir o campo hivePartitioningOptions.mode como CUSTOM, será necessário codificar o esquema da chave de partição no campo hivePartitioningOptions.sourceUriPrefix da seguinte maneira: s3://BUCKET/PATH_TO_TABLE/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Para aplicar o uso de um filtro de predicado no momento da consulta, defina o campo hivePartitioningOptions.requirePartitionFilter como true.

Console

1. Acessar a página do BigQuery.

   Ir para o BigQuery

2. Se a guia Editor não estiver visível, clique em add_boxCriar nova consulta.

3. Clique em Mais > Configurações de consulta. A caixa de diálogo Configurações de consulta é aberta.

4. Na caixa de diálogo Configurações de consulta, em Outras configurações > Local dos dados, selecione a opção Região do BigQuery que é colocalizada com a região do BigQuery Omni. Por exemplo, se a região do BigQuery Omni for aws-us-east-1, especifique us-east4.

5. Selecione os campos restantes e clique em Salvar.

bq

Use a flag --location para definir o local de processamento do job como a região do BigQuery que é colocalizada com a região do BigQuery Omni. Por exemplo, se a região do BigQuery Omni for aws-us-east-1, especifique us-east4.

Exemplo

bq query --use_legacy_sql=false --location=us-east4 \
"SELECT * FROM region-aws-us-east-1.INFORMATION_SCHEMA.JOBS limit 10;"

bq query --use_legacy_sql=false --location=asia-northeast3 \
"SELECT * FROM region-aws-ap-northeast-2.INFORMATION_SCHEMA.JOBS limit 10;"

API

Se você estiver executando jobs de maneira programática, defina o argumento do local como a região do BigQuery que é colocalizada com a região BigQuery Omni. Por exemplo, se a região do BigQuery Omni for aws-us-east-1, especifique us-east4.

CLI da AWS

Execute o comando a seguir para aplicar uma política de bucket S3 que inclui uma condição usando o atributo aws:SourceVpc:

  aws s3api put-bucket-policy \
    --bucket=BUCKET_NAME \
    --policy "{
      \"Version\": \"2012-10-17\",
      \"Id\": \"RestrictBucketReads\",
      \"Statement\": [
          {
              \"Sid\": \"AccessOnlyToOmniVPC\",
              \"Principal\": \"*\",
              \"Action\": [\"s3:ListBucket\", \"s3:GetObject\"],
              \"Effect\": \"Allow\",
              \"Resource\": [\"arn:aws:s3:::BUCKET_NAME\",
                             \"arn:aws:s3:::BUCKET_NAME/*\"],
              \"Condition\": {
                  \"StringEquals\": {
                    \"aws:SourceVpc\": \"VPC_ID\"
                  }
              }
          }
      ]
    }"

Substitua:

• BUCKET_NAME: o bucket do Amazon S3 que você quer que o BigQuery acesse.
• VPC_ID: o ID da VPC Omni do BigQuery da região do BigQuery Omni alocada com o bucket Amazon S3. Você encontra essas informações na tabela desta página.

Terraform

Adicione o seguinte ao seu arquivo de configuração do Terraform:

  resource "aws_s3_bucket" "example" {
    bucket = "BUCKET_NAME"
  }

  resource "aws_s3_bucket_policy" "example" {
    bucket = aws_s3_bucket.example.id
    policy = jsonencode({
      Version = "2012-10-17"
      Id      = "RestrictBucketReads"
      Statement = [
          {
              Sid       = "AccessOnlyToOmniVPC"
              Effect    = "Allow"
              Principal = "*"
              Action    = ["s3:GetObject", "s3:ListBucket"]
              Resource  = [
                  aws_s3_bucket.example.arn,
                  "${aws_s3_bucket.example.arn}/*"
                  ]
              Condition = {
                  StringEquals = {
                      "aws:SourceVpc": "VPC_ID"
                  }
              }
          },
      ]
    })
  }

Substitua:

• BUCKET_NAME: o bucket do Amazon S3 que você quer que o BigQuery acesse.
• VPC_ID: o ID da VPC Omni do BigQuery da região do BigQuery Omni alocada com o bucket Amazon S3.