E-MapReduce:Conector de Kudu

El conector de Kudu abarca los siguientes temas:

• Modify the Kudu connector configuration

• Query data

• Data type mappings

• Supported Presto SQL syntax

• Create a table

• Add a column

En la consola de E-MapReduce (EMR), vaya a la página Configure del servicio Trino. En el área Service Configuration, haga clic en la pestaña kudu.properties.

Ejemplos:

1. Cree una tabla users en el esquema 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

   Al crear una tabla, debe especificar información obligatoria, como la clave principal, los formatos de codificación y compresión de columnas, y las particiones por hash o por rango.

2. Consulte la información de la tabla.

   DESCRIBE kudu.default.users;

   El comando devuelve un resultado similar al siguiente:

      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. Inserte datos.

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

4. Consulte los datos.

   SELECT * FROM kudu.default.users;

Si habilita la emulación de esquemas en el archivo de configuración del conector (etc/catalog/kudu.properties), las tablas se asignan a esquemas según una convención de nomenclatura.

• Si establece kudu.schema-emulation.enabled=true y kudu.schema-emulation.prefix=, las tablas se asignan de la siguiente manera:

  Nombre de tabla en Kudu	Nombre de tabla en Presto
  orders	kudu.default.orders
  part1.part2	kudu.part1.part2
  x.y.z	kudu.x."y.z"

  Nota

  Dado que Kudu no admite esquemas de forma nativa, Presto crea una tabla especial llamada $schemas para gestionarlos.

• Si establece kudu.schema-emulation.enabled=true y kudu.schema-emulation.prefix=presto::, las tablas se asignan de la siguiente manera:

  Nombre de tabla en Kudu	Nombre de tabla en 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

  Dado que Kudu no admite esquemas de forma nativa, Presto crea una tabla especial llamada presto::$schemas para gestionarlos.

La siguiente tabla muestra el mapeo de tipos de datos entre Presto y Kudu.

Para crear una tabla, especifique sus columnas, tipos de datos e información de particionamiento. También puede definir otros detalles, como el formato de codificación o compresión de las columnas. A continuación se muestra un ejemplo.

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

Al crear una tabla, tenga en cuenta lo siguiente:

• Las columnas de clave principal deben aparecer primero. Las columnas de clave de partición deben ser un subconjunto de las columnas de clave principal.

• number_of_replicas: Número de réplicas de tablet, que debe ser un número impar. Si no se especifica, se utiliza el valor predeterminado de la configuración de Kudu Master.

• Kudu admite particiones por hash y por rango. Una partición por hash distribuye las filas en cubetas según un valor hash. Una partición por rango distribuye las filas según una clave de partición ordenada, y sus rangos específicos deben crearse explícitamente. Kudu admite particionamiento multinivel. Una tabla debe tener al menos una partición por hash o por rango. Puede tener varias particiones por hash, pero como máximo una partición por rango.

Además del nombre y el tipo de datos, puede especificar las siguientes propiedades de columna.

A continuación se muestra un ejemplo:

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 sección describe cómo definir particiones por hash y por rango.

• Partición por hash

  • Definición de un grupo de particiones

    Utilice las propiedades de tabla partition_by_hash_columns y partition_by_hash_buckets para especificar las columnas de clave de partición y el número de particiones, respectivamente. Todas las columnas de clave de partición deben ser un subconjunto de las columnas de clave principal. A continuación se muestra un ejemplo:

    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 ejemplo define una partición por hash en las columnas col1 y col2, y distribuye los datos en cuatro particiones.

  • Definición de dos grupos de particiones

    Para definir dos grupos independientes de particiones por hash, también debe especificar las propiedades de tabla partition_by_second_hash_columns y partition_by_second_hash_buckets. A continuación se muestra un ejemplo:

    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 ejemplo define dos grupos de particiones por hash. El primer grupo distribuye las filas en dos particiones según la columna col1. El segundo grupo distribuye las filas en tres particiones según la columna col2. La tabla tiene un total de seis particiones (2 × 3).

• Partición por rango

  Una tabla de Kudu puede tener como máximo una partición por rango, la cual se define mediante la propiedad de tabla partition_by_range_columns. Al crear la tabla, puede definir los rangos de partición mediante la propiedad de tabla range_partitions. Para gestionar particiones por rango en una tabla existente, utilice los procedimientos almacenados kudu.system.add_range_partition y kudu.system.drop_range_partition. A continuación se muestra un ejemplo:

  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 ejemplo define una tabla con dos grupos de particiones por hash y una partición por rango en la columna event_time. El rango se divide en la marca de tiempo 2018-01-01T00:00:00.

• Gestión de particiones por rango

  Los siguientes ejemplos muestran operaciones de particionamiento:

  • Agregar una partición por rango

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

  • Eliminar una partición por rango

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

  Parámetro	Descripción
  <YOUR_SCHEMA_NAME>	Esquema donde se encuentra la tabla.
  <YOUR_TABLE_NAME>	Nombre de la tabla.
  <range_partition_as_json_string>	Límites superior e inferior de la partición por rango, especificados como una cadena JSON. Utilice el formato '{"lower": <value>, "upper": <value>}'. Si la partición tiene varias columnas, utilice el formato '{"lower": [<value_col1>,...], "upper": [<value_col1>,...]}'. El formato del valor depende del tipo de datos de la columna. La siguiente lista muestra el mapeo de tipos de datos a sus formatos de cadena JSON requeridos: 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: Una cadena codificada en Base64. Nota Un valor null indica un límite no acotado.

  A continuación se muestra un ejemplo:

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

  Nota

  Este ejemplo agrega una partición por rango a la tabla events en el esquema myschema. El límite inferior de la partición es 2018-01-01, que corresponde a la marca de tiempo 2018-01-01T00:00:00.000. El límite superior es 2018-06-01.

  Utilice la sentencia SHOW CREATE TABLE para consultar las particiones por rango existentes. Esta información aparece en la propiedad de tabla range_partitions.

Utilice la sentencia ALTER TABLE ... ADD COLUMN ... para agregar una columna a una tabla existente. También puede especificar propiedades para la nueva columna. Para obtener detalles sobre las propiedades de columna, consulte Create a table.

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