E-MapReduce:Conector Kudu

Este tópico aborda os seguintes assuntos sobre o conector Kudu:

• Modifique a configuração do conector Kudu

• Consultar dados

• Mapeamento de tipos de dados

• Sintaxe SQL do Presto suportada

• Crie uma tabela

• Adicionar uma coluna

No console E-MapReduce (EMR), acesse a página Configure do service Trino. Na área Service Configuration, clique na aba kudu.properties.

Exemplos:

1. Crie uma tabela users no schema default.

   CREATE TABLE kudu.default.users (
     user_id int WITH (primary_key = true),
     first_name varchar,
     last_name varchar
   ) WITH (
     partition_by_hash_columns = ARRAY['user_id'],
     partition_by_hash_buckets = 2
   );

   Nota

   Ao criar uma tabela, especifique as informações obrigatórias, como chave primária, formatos de codificação e compressão de colunas, além de partições por hash ou por intervalo.

2. Visualize as informações da tabela.

   DESCRIBE kudu.default.users;

   O comando retorna uma saída semelhante à seguinte:

      Column   |  Type   |                      Extra                      | Comment
   ------------+---------+-------------------------------------------------+---------
    user_id    | integer | primary_key, encoding=auto, compression=default |
    first_name | varchar | nullable, encoding=auto, compression=default    |
    last_name  | varchar | nullable, encoding=auto, compression=default    |
   (3 rows)

3. Insira dados.

   INSERT INTO kudu.default.users VALUES (1, 'Donald', 'Duck'), (2, 'Mickey', 'Mouse');

4. Consulte os dados.

   SELECT * FROM kudu.default.users;

Se você ativar a emulação de schema no arquivo de configuração do conector (etc/catalog/kudu.properties), as tabelas serão mapeadas para schemas com base em uma convenção de nomenclatura.

• Ao definir kudu.schema-emulation.enabled=true e kudu.schema-emulation.prefix=, o mapeamento das tabelas ocorre da seguinte forma:

  Nome da tabela Kudu	Nome da tabela Presto
  orders	kudu.default.orders
  part1.part2	kudu.part1.part2
  x.y.z	kudu.x."y.z"

  Nota

  Como o Kudu não oferece suporte nativo a schemas, o Presto cria uma tabela especial chamada $schemas para gerenciá-los.

• Ao definir kudu.schema-emulation.enabled=true e kudu.schema-emulation.prefix=presto::, o mapeamento das tabelas segue o padrão abaixo:

  Nome da tabela Kudu	Nome da tabela Presto
  orders	kudu.default.orders
  part1.part2	kudu.default."part1.part2"
  x.y.z	kudu.default."x.y.z"
  presto::part1.part2	kudu.part1.part2
  presto::x.y.z	kudu.x."y.z"

  Nota

  Como o Kudu não oferece suporte nativo a schemas, o Presto cria uma tabela especial chamada presto::$schemas para gerenciá-los.

A tabela a seguir apresenta os mapeamentos de tipos de dados entre Presto e Kudu.

Para criar uma tabela, especifique suas colunas, tipos de dados e informações de particionamento. Também é possível definir outros detalhes, como formato de codificação ou compressão das colunas. Veja um exemplo abaixo.

CREATE TABLE user_events (
  user_id int WITH (primary_key = true),
  event_name varchar WITH (primary_key = true),
  message varchar,
  details varchar WITH (nullable = true, encoding = 'plain')
) WITH (
  partition_by_hash_columns = ARRAY['user_id'],
  partition_by_hash_buckets = 5,
  number_of_replicas = 3
);

Ao criar uma tabela, observe os seguintes pontos:

• As colunas de chave primária devem ser listadas primeiro. As colunas de chave de partição devem ser um subconjunto das colunas de chave primária.

• number_of_replicas: Quantidade de réplicas de tablet, que deve ser um número ímpar. Se não especificado, o valor padrão da configuração do Kudu Master será utilizado.

• O Kudu suporta partições por hash e por intervalo. Uma partição por hash distribui linhas em buckets com base em um valor de hash. Já a partição por intervalo distribui linhas conforme uma chave de partição ordenada, exigindo criação explícita dos intervalos específicos. O Kudu também permite particionamento multinível. Toda tabela deve ter pelo menos uma partição por hash ou por intervalo, podendo ter múltiplas partições por hash, mas no máximo uma partição por intervalo.

Além do nome e do tipo de dados, você pode especificar as seguintes propriedades para a coluna.

Veja um exemplo:

CREATE TABLE mytable (
  name varchar WITH (primary_key = true, encoding = 'dictionary', compression = 'snappy'),
  index bigint WITH (nullable = true, encoding = 'runlength', compression = 'lz4'),
  comment varchar WITH (nullable = true, encoding = 'plain', compression = 'default'),
   ...
) WITH (...);

Esta seção descreve como definir partições por hash e por intervalo.

• Partição por hash

  • Definição de um grupo de partições

    Utilize as propriedades de tabela partition_by_hash_columns e partition_by_hash_buckets para especificar as colunas de chave de partição e o número de partições, respectivamente. Todas as colunas de chave de partição devem ser um subconjunto das colunas de chave primária. Confira o exemplo:

    CREATE TABLE mytable (
      col1 varchar WITH (primary_key=true),
      col2 varchar WITH (primary_key=true),
      ...
    ) WITH (
      partition_by_hash_columns = ARRAY['col1', 'col2'],
      partition_by_hash_buckets = 4
    )

    Nota

    Este exemplo define uma partição por hash nas colunas col1 e col2, distribuindo os dados em quatro partições.

  • Definição de dois grupos de partições

    Para definir dois grupos independentes de partições por hash, especifique também as propriedades de tabela partition_by_second_hash_columns e partition_by_second_hash_buckets. Veja o exemplo:

    CREATE TABLE mytable (
      col1 varchar WITH (primary_key=true),
      col2 varchar WITH (primary_key=true),
      ...
    ) WITH (
      partition_by_hash_columns = ARRAY['col1'],
      partition_by_hash_buckets = 2,
      partition_by_second_hash_columns = ARRAY['col2'],
      partition_by_second_hash_buckets = 3
    )

    Nota

    Este exemplo define dois grupos de partições por hash. O primeiro grupo distribui as linhas em duas partições com base na coluna col1. O segundo grupo distribui as linhas em três partições com base na coluna col2. A tabela possui um total de seis partições (2 × 3).

• Partição por intervalo

  Uma tabela Kudu pode ter no máximo uma partição por intervalo, definida pela propriedade de tabela partition_by_range_columns. Durante a criação da tabela, defina os intervalos de partição usando a propriedade range_partitions. Para gerenciar partições por intervalo em uma tabela existente, utilize os procedimentos armazenados kudu.system.add_range_partition e kudu.system.drop_range_partition. Segue um exemplo:

  CREATE TABLE events (
    rack varchar WITH (primary_key=true),
    machine varchar WITH (primary_key=true),
    event_time timestamp WITH (primary_key=true),
    ...
  ) WITH (
    partition_by_hash_columns = ARRAY['rack'],
    partition_by_hash_buckets = 2,
    partition_by_second_hash_columns = ARRAY['machine'],
    partition_by_second_hash_buckets = 3,
    partition_by_range_columns = ARRAY['event_time'],
    range_partitions = '[{"lower": null, "upper": "2018-01-01T00:00:00"},
                         {"lower": "2018-01-01T00:00:00", "upper": null}]'
  )

  Nota

  Este exemplo define uma tabela com dois grupos de partições por hash e uma partição por intervalo na coluna event_time. O intervalo é dividido no carimbo de data/hora 2018-01-01T00:00:00.

• Gerenciamento de partições por intervalo

  Os exemplos a seguir demonstram operações de particionamento:

  • Adicionar uma partição por intervalo

    CALL kudu.system.add_range_partition(<YOUR_SCHEMA_NAME>, <YOUR_TABLE_NAME>, <range_partition_as_json_string>)

  • Remover uma partição por intervalo

    CALL kudu.system.drop_range_partition(<YOUR_SCHEMA_NAME>, <YOUR_TABLE_NAME>, <range_partition_as_json_string>)

  Parâmetro	Descrição
  <YOUR_SCHEMA_NAME>	Schema onde a tabela está localizada.
  <YOUR_TABLE_NAME>	Nome da tabela.
  <range_partition_as_json_string>	Limites superior e inferior da partição por intervalo, especificados como uma string JSON. Use o formato '{"lower": <value>, "upper": <value>}'. Se a partição tiver várias colunas, utilize o formato '{"lower": [<value_col1>,...], "upper": [<value_col1>,...]}'. O formato do valor depende do tipo de dados da coluna. A lista a seguir mapeia os tipos de dados para seus formatos de string JSON necessários: BIGINT: '{"lower": 0, "upper": 1000000}' SMALLINT: '{"lower": 10, "upper": null}' VARCHAR: '{"lower": "A", "upper": "M"}' TIMESTAMP: '{"lower": "2018-02-01T00:00:00.000", "upper": "2018-02-01T12:00:00.000"}' BOOLEAN: '{"lower": false, "upper": true}' VARBINARY: Uma string codificada em Base64. Nota Um valor null indica um limite ilimitado.

  Confira um exemplo:

  CALL kudu.system.add_range_partition('myschema', 'events', '{"lower": "2018-01-01", "upper": "2018-06-01"}')

  Nota

  Este exemplo adiciona uma partição por intervalo à tabela events no schema myschema. O limite inferior da partição é 2018-01-01, que corresponde ao carimbo de data/hora 2018-01-01T00:00:00.000. O limite superior é 2018-06-01.

  Use a instrução SHOW CREATE TABLE para visualizar as partições por intervalo existentes. Essas informações aparecem na propriedade de tabela range_partitions.

Utilize a instrução ALTER TABLE ... ADD COLUMN ... para adicionar uma coluna a uma tabela existente. Também é possível especificar propriedades para a nova coluna. Para detalhes sobre as propriedades de coluna, consulte Criar uma tabela.

ALTER TABLE mytable ADD COLUMN extraInfo varchar WITH (nullable = true, encoding = 'plain')