Открыть страницу поиска
Привет, Я DocuDroid!
Открыть страницу ИИ Помощника
Оценка ИИ поиска
Спасибо за оценку нашего ИИ поиска!
Мы будем признательны, если вы поделитесь своими впечатлениями, чтобы мы могли улучшить наш ИИ поиск для вас и других читателей.
GitHub

Использование коннекторов PXF Hive для чтения данных из таблиц Hive в Greengage DB

Антон Монаков

Apache Hive — инфраструктура для распределенного хранилища данных. Hive облегчает управление большими наборами данных, поддерживая несколько форматов, включая TextFile — значения, разделенные запятыми (CSV), RCFile, ORC и Parquet.

В этой статье описывается настройка и использование коннектора PXF Hive для чтения данных из таблиц Hive с использованием внешних таблиц, а также приводятся практические примеры.

ПРИМЕЧАНИЕ

При обращении к Hive 3 коннектор PXF Hive поддерживает использование профилей hive[:*], описанных ниже, только для доступа к внешним таблицам Hive 3. Использование профилей hive[:*] для обращения к управляемым таблицам Hive 3 (CRUD и с транзакциями insert-only, а также временным таблицам) не поддерживается. Для доступа к управляемым таблицам Hive 3 используйте коннектор PXF JDBC.

Форматы данных Hive

Для доступа к данным различных форматов в таблицах Hive коннектор PXF Hive предоставляет профили hive, hive:text, hive:rc и hive:orc.

Формат файла Профиль Описание

TextFile

hive, hive:text

Неструктурированные файлы со значениями, разделенными запятыми, символами табуляции или пробелами, а также в нотации JSON. См. пример в разделе Использование профиля hive:text

RCFile

hive, hive:rc

Колоночные данные с бинарными парами ключ/значение, высокая степень сжатия строк. См. пример в разделе Использование профиля hive:rc

ORC

hive, hive:orc

Оптимизированный колоночный формат данных с секциями stripe, footer и postscript; обеспечивает сокращение размера файла.

Профиль hive:orc:

  • Считывает по одной строке данных.

  • Поддерживает проекцию столбцов.

  • Поддерживает сложные типы данных (массив, ассоциативный массив, структура и объединение). PXF сериализует эти типы в текст.

Если при создании внешней таблицы указан параметр VECTORIZE=true, включается векторизованное выполнение запросов Hive. В этом случае профиль hive:orc:

  • Считывает до 1024 строк данных одновременно.

  • Поддерживает проекцию столбцов.

  • Не поддерживает составные типы данных и тип данных timestamp.

См. примеры в разделах Использование профиля hive:orc и Чтение составных типов данных

Parquet

hive

Сжатый формат данных с колоночным хранением. См. пример в разделе Доступ к Hive-таблицам формата Parquet

Avro

hive

Фреймворк сериализации данных с двоичным форматом данных. См. пример в разделе Доступ к Hive-таблицам формата Avro

SequenceFile

hive

Неструктурированный файл со значениями, состоящими из бинарных пар ключ/значение. См. пример в разделе Доступ к Hive-таблицам формата SequenceFile

Любой поддерживаемый формат файла

hive

Оптимальный профиль hive[:*] выбирается автоматически в зависимости от типа файла. Этот профиль можно использовать, когда исходная таблица Hive состоит из нескольких партиций, хранящихся в файлах различных форматов. См. пример в разделе Доступ к разнородным партиционированным данным
ПРИМЕЧАНИЕ

При использовании профилей hive, hive:rc или hive:orc PXF использует проекцию столбцов для увеличения производительности запроса.

Сопоставление типов данных

Коннектор PXF Hive поддерживает примитивные и составные типы данных. Составные типы данных — массивы, структуры, ассоциативные массивы и объединения — сопоставляются текстовому типу. Для извлечения подкомпонентов составного типа данных вы можете использовать как средства БД (пользовательские функции (UDF)), так и программный код на стороне клиента.

Для примитивных типов данных используется следующее сопоставление.

Тип данных Hive Тип данных Greengage DB

boolean

BOOL

int

INT4

smallint

INT2

tinyint

INT2

bigint

INT8

float

FLOAT4

double

FLOAT8

string

TEXT

binary

BYTEA

timestamp (1)

TIMESTAMP

  1. Профиль hive:orc не поддерживает тип данных timestamp при использовании векторизованного выполнения запроса (VECTORIZE=true).

Сканирование партиций

Коннектор PXF Hive поддерживает сканирование партиций и структуру каталогов партиций. Сканирование партиций позволяет исключить из запроса выбранные файлы HDFS, составляющие таблицу Hive, и уменьшить объем сетевого трафика и нагрузку на систему ввода-вывода. Для использования сканирования партиций выполните запрос к внешней таблице с использованием условия WHERE, которое ссылается на столбец партиционирования таблицы Hive. См. примеры в разделах Доступ к разнородным партиционированным данным и Доступ к однородным партиционированным данным.

В PXF поддерживается сканирование партиций Hive для строковых и целочисленных типов:

  • Реляционные операторы =, <, <=, >, >= и <> поддерживаются для строковых типов.

  • Реляционные операторы = и <> поддерживаются для целочисленных типов. Для использования сканирования партиций с целочисленными типами Hive, необходимо обновить конфигурацию Hive, как описано в разделе Конфигурирование коннектора PXF Hive.

  • Логические операторы AND и OR поддерживаются при использовании реляционных операторов, перечисленных выше.

  • Строковый оператор LIKE не поддерживается.

Для использования сканирования партиций требуется, чтобы имена столбцов партиционирования Hive и PXF совпадали. В противном случае сканирование партиций игнорируется и фильтрация выполняется на стороне Greengage DB.

ПРИМЕЧАНИЕ

Коннектор PXF Hive производит фильтрацию только по столбцам партиционирования, но не каким-либо иным атрибутам таблицы. Фильтрация включена по умолчанию и поддерживается только для типов данных и операторов, перечисленных выше. Более подробную информацию о фильтрации можно получить в разделе Pushdown фильтров документации PXF.

Если в Hive включено динамическое партиционирование, данные партиционированной таблицы могут храниться в партиции по умолчанию. Hive создает партицию по умолчанию, когда значение столбца партиционирования не совпадает с определенным типом столбца (например, когда для любого столбца партиционирования используется NULL).

В таких случаях результаты запросов из Hive и PXF могут отличаться. В Hive любой запрос, включающий фильтр по столбцу партиционирования, исключает данные, хранящиеся в партиции по умолчанию. PXF, как и Hive, представляет столбцы партиционирования таблицы как столбцы, добавляемые в конец таблицы. Но в PXF любое значение столбца в партиции по умолчанию переводится в NULL. Это означает, что запрос Greengage DB, включающий фильтр IS NULL по столбцу партиционирования, может возвращать результаты, отличные от результатов Hive. См. пример в разделе Доступ к партиции Hive по умолчанию.

Создание внешней таблицы с использованием протокола PXF

Таблицы Hive могут храниться в одном или нескольких файлах, каждый из которых имеет уникальную структуру или схему, поэтому имена столбцов в таблице Greengage DB должны совпадать с именами столбцов таблицы Hive. Прямое сопоставление по имени столбцов позволяет:

  • Создавать внешние таблицы со столбцами в ином порядке, чем в таблице Hive.

  • Создавать внешние таблицы, содержащие только часть столбцов таблицы Hive.

  • Читать данные таблицы Hive из файлов с другим количеством столбцов.

Чтобы создать внешнюю таблицу Greengage DB для чтения данных из таблицы Hive, используется следующий синтаксис:

CREATE EXTERNAL TABLE <table_name>
    ( <column_name> <data_type> [, ...] | LIKE <other_table> )

    LOCATION ('pxf://<hive_db_name>.<hive_table_name>?PROFILE=<profile_name>[&<custom_option>=<value>[...]]')
    FORMAT 'CUSTOM|TEXT' (FORMATTER='pxfwritable_import' | delimiter='<delim>');
Ключевое слово Значение

<table_name>

Имя создаваемой таблицы

<column_name>

Имя создаваемого столбца

<data_type>

Тип данных создаваемого столбца

LIKE <other_table>

Указывает таблицу, из которой внешняя таблица копирует все имена столбцов, типы данных и политику распределения

<hive_db_name>

Имя базы данных Hive. Если значение не указано, используется база данных Hive по умолчанию default

<hive_table_name>

Имя таблицы Hive

PROFILE=<profile_name>

Для чтения данных из таблицы Hive используется один из следующих профилей: hive, hive:text, hive:rc или hive:orc

<custom_option>

Одна из опций, описанных ниже, указываемая в строке LOCATION

SERVER=<server_name>

Имя конфигурации сервера, который используется для доступа к данным. Если значение не указано, используется сервер PXF по умолчанию

PPD=<boolean>

Включает pushdown предикатов для всех запросов к этой таблице. Применяется только к профилям hive, hive:orc и hive:rc и переопределяет настройку pxf.ppd.hive конфигурации сервера

VECTORIZE=<boolean>

Для профиля hive:orc указывает, используется ли режим векторизованного выполнения запросов при доступе к файлам ORC. По умолчанию значение равно false, режим векторизованного выполнения не используется

FORMAT (профили hive и hive:orc)

Для чтения данных из таблицы HBase используется кастомный формат со встроенной кастомной функцией форматирования для операций чтения (pxfwritable_import)

FORMAT (профили hive:text и hive:rc)

Для чтения данных из таблицы HBase используется формат TEXT, а в качестве разделителя полей (delimiter) указывается один ASCII-символ. Вы можете использовать спецпоследовательности, начинающиеся с E'', например delimiter=E'\t'

Примеры

Эти примеры демонстрируют, как настроить и использовать коннектор PXF Hive для чтения данных из Hive в Greengage DB с использованием внешних таблиц.

Предварительные требования

Для выполнения практических примеров подключитесь к мастер-хосту Greengage DB как gpadmin с помощью psql, как описано в статье Подключение к Greengage DB с использованием psql. Затем создайте тестовую базу данных customers и подключитесь к ней:

DROP DATABASE IF EXISTS customers;
CREATE DATABASE customers;
\c customers

Чтобы создать внешнюю таблицу с использованием протокола PXF, предварительно зарегистрируйте в БД расширение PXF, как описано в разделе Регистрация PXF в БД документации PXF:

CREATE EXTENSION pxf;

Конфигурирование коннектора PXF Hive

Для того чтобы подключиться к HDFS с помощью PXF, необходимо создать конфигурацию сервера, как описано в статье Настройка коннекторов PXF Hadoop документации PXF, а затем синхронизировать конфигурацию между хостами кластера Greengage DB:

  1. Подключитесь к мастер-хосту Greengage DB как gpadmin.

  2. Перейдите в каталог $PXF_BASE/servers и создайте каталог конфигурации сервера Hadoop с именем hadoop:

    $ mkdir $PXF_BASE/servers/hadoop
$ cd $PXF_BASE/servers/hadoop

  3. Скопируйте файлы конфигурации core-site.xml, hdfs-site.xml, mapred-site.xml и yarn-site.xml с хоста NameNode кластера Hadoop на текущий хост:

    $ scp hdfsuser@namenode:/etc/hadoop/conf/core-site.xml .
$ scp hdfsuser@namenode:/etc/hadoop/conf/hdfs-site.xml .
$ scp hdfsuser@namenode:/etc/hadoop/conf/mapred-site.xml .
$ scp hdfsuser@namenode:/etc/hadoop/conf/yarn-site.xml .

  4. Если вы планируете использовать pushdown предикатов с целочисленными типами Hive, убедитесь, что в конфигурации Hive hive-site.xml создан параметр конфигурации hive.metastore.integral.jdo.pushdown и ему присвоено значение true. Затем скопируйте файл hive-site.xml с хоста NameNode кластера Hadoop на текущий хост:

    $ scp hdfsuser@namenode:/etc/hbase/conf/hive-site.xml .

  5. Синхронизируйте конфигурацию между хостами кластера Greengage DB:

    $ pxf cluster sync

Создание тестового набора данных

  1. В каталоге /tmp на хосте HiveServer создайте текстовый файл customers.txt, содержимое которого — значения, разделенные запятыми:

    John Doe,24,152.12
Jane Smith,66,456.72
Bob Brown,12,51.19
Rob Stuart,42,34.81

  2. На хосте HiveClient запустите командную строку Hive:

    $ hive

  3. Создайте таблицу Hive customers для хранения тестового набора данных. Выражение FIELDS TERMINATED BY устанавливает запятую (,) в качестве разделителя полей внутри записи данных (строки). Выражение STORED AS TEXTFILE указывает, что таблица создается в формате TEXTFILE (по умолчанию):

    CREATE TABLE customers (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
    STORED AS TEXTFILE;

  4. Загрузите файл customers.txt в созданную таблицу customers:

    LOAD DATA LOCAL INPATH '/tmp/customers.txt'
INTO TABLE customers;

  5. Опционально, выполните запрос к таблице customers, чтобы убедиться, что данные загружены:

    SELECT * FROM customers;

    Вывод должен выглядеть следующим образом:

    +-----------------+-------------------+------------------+
| customers.name  | customers.orders  | customers.sales  |
+-----------------+-------------------+------------------+
| John Doe        | 24                | 152.12           |
| Jane Smith      | 66                | 456.72           |
| Bob Brown       | 12                | 51.19            |
| Rob Stuart      | 42                | 34.81            |
+-----------------+-------------------+------------------+
4 rows selected (0.079 seconds)

  6. С помощью команды DESCRIBE EXTENDED можно просмотреть местоположение таблицы в HDFS:

    DESCRIBE EXTENDED customers;

    В выводе команды местоположение таблицы в HDFS указано в поле location:

    ...
location:hdfs://hadoop/apps/hive/warehouse/customers
...

Использование профиля hive

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_hive (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers?PROFILE=hive&SERVER=hadoop')
    FORMAT 'custom' (FORMATTER='pxfwritable_import');

  2. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_hive;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Использование профиля hive:text

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers. В выражении LOCATION укажите PXF-профиль hive:text и конфигурацию сервера. В выражении FORMAT укажите TEXT в качестве формата данных и установите символ запятой (,) в качестве разделителя (delimiter):

    CREATE EXTERNAL TABLE customers_text (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers?PROFILE=hive:text&SERVER=hadoop')
    FORMAT 'TEXT' (delimiter=E',');

  2. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_text;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Использование профиля hive:rc

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, хранящуюся в формате RCFile:

    CREATE TABLE customers_rc (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
    STORED AS RCFILE;

  3. Скопируйте данные из таблицы customers в таблицу customers_rc, чтобы сохранить их в формате RCFile:

    INSERT INTO TABLE customers_rc SELECT * FROM customers;

  4. Опционально, выполните запрос к Hive-таблице customers_rc, чтобы убедиться, что данные загружены:

    SELECT * FROM customers_rc;

    Вывод должен выглядеть следующим образом:

    +--------------------+----------------------+---------------------+
| customers_rc.name  | customers_rc.orders  | customers_rc.sales  |
+--------------------+----------------------+---------------------+
| John Doe           | 24                   | 152.12              |
| Jane Smith         | 66                   | 456.72              |
| Bob Brown          | 12                   | 51.19               |
| Rob Stuart         | 42                   | 34.81               |
+--------------------+----------------------+---------------------+
4 rows selected (0.1 seconds)

  5. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_rc. В выражении LOCATION укажите PXF-профиль hive:rc и конфигурацию сервера. В выражении FORMAT укажите TEXT в качестве формата данных и установите символ запятой (,) в качестве разделителя (delimiter):

    CREATE EXTERNAL TABLE customers_rc (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers_rc?PROFILE=hive:rc&SERVER=hadoop')
    FORMAT 'TEXT' (delimiter=E',');

  6. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_rc;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Использование профиля hive:orc

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, хранящуюся в формате ORC:

    CREATE TABLE customers_orc (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    STORED AS ORC;

  3. Скопируйте данные из таблицы customers в таблицу customers_orc, чтобы сохранить их в формате ORC:

    INSERT INTO TABLE customers_orc SELECT * FROM customers;

  4. Опционально, выполните запрос к Hive-таблице customers_orc, чтобы убедиться, что данные загружены:

    SELECT * FROM customers_orc;

    Вывод должен выглядеть следующим образом:

    +---------------------+-----------------------+----------------------+
| customers_orc.name  | customers_orc.orders  | customers_orc.sales  |
+---------------------+-----------------------+----------------------+
| John Doe            | 24                    | 152.12               |
| Jane Smith          | 66                    | 456.72               |
| Bob Brown           | 12                    | 51.19                |
| Rob Stuart          | 42                    | 34.81                |
+---------------------+-----------------------+----------------------+
4 rows selected (0.095 seconds)

  5. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_orc. В выражении LOCATION укажите PXF-профиль hive:orc и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_orc (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers_orc?PROFILE=hive:orc&SERVER=hadoop')
    FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');

  6. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_orc;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Доступ к Hive-таблицам формата Parquet

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, хранящуюся в формате Parquet:

    CREATE TABLE customers_parquet (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    STORED AS PARQUET;

  3. Скопируйте данные из таблицы customers в таблицу customers_parquet, чтобы сохранить их в формате Parquet:

    INSERT INTO TABLE customers_parquet SELECT * FROM customers;

  4. Опционально, выполните запрос к Hive-таблице customers_parquet, чтобы проверить данные:

    SELECT * FROM customers_parquet;

    Вывод должен выглядеть следующим образом:

    +-------------------------+---------------------------+--------------------------+
| customers_parquet.name  | customers_parquet.orders  | customers_parquet.sales  |
+-------------------------+---------------------------+--------------------------+
| John Doe                | 24                        | 152.12                   |
| Jane Smith              | 66                        | 456.72                   |
| Bob Brown               | 12                        | 51.19                    |
| Rob Stuart              | 42                        | 34.81                    |
+-------------------------+---------------------------+--------------------------+
4 rows selected (0.1 seconds)

  5. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_parquet. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_parquet (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers_parquet?PROFILE=hive&SERVER=hadoop')
    FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');

  6. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_parquet;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Доступ к Hive-таблицам формата Avro

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, хранящуюся в формате Avro:

    CREATE TABLE customers_avro (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    STORED AS AVRO;

  3. Скопируйте данные из таблицы customers в таблицу customers_avro, чтобы сохранить их в формате Avro:

    INSERT INTO TABLE customers_avro SELECT * FROM customers;

  4. Опционально, выполните запрос к Hive-таблице customers_avro, чтобы проверить данные:

    SELECT * FROM customers_avro;

    Вывод должен выглядеть следующим образом:

    +----------------------+------------------------+-----------------------+
| customers_avro.name  | customers_avro.orders  | customers_avro.sales  |
+----------------------+------------------------+-----------------------+
| John Doe             | 24                     | 152.12                |
| Jane Smith           | 66                     | 456.72                |
| Bob Brown            | 12                     | 51.19                 |
| Rob Stuart           | 42                     | 34.81                 |
+----------------------+------------------------+-----------------------+
4 rows selected (0.198 seconds)

  5. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_avro. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_avro (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers_avro?PROFILE=hive&SERVER=hadoop')
    FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');

  6. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_avro;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Доступ к Hive-таблицам формата SequenceFile

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, хранящуюся в формате SequenceFile:

    CREATE TABLE customers_seqfile (
    name STRING,
    orders INT, 
    sales DOUBLE
    )
    
    STORED AS SEQUENCEFILE;

  3. Скопируйте данные из таблицы customers в таблицу customers_seqfile, чтобы сохранить их в формате SequenceFile:

    INSERT INTO TABLE customers_seqfile SELECT * FROM customers;

  4. Опционально, выполните запрос к Hive-таблице customers_seqfile, чтобы проверить данные:

    SELECT * FROM customers_seqfile;

    Вывод должен выглядеть следующим образом:

    +-------------------------+---------------------------+--------------------------+
| customers_seqfile.name  | customers_seqfile.orders  | customers_seqfile.sales  |
+-------------------------+---------------------------+--------------------------+
| John Doe                | 24                        | 152.12                   |
| Jane Smith              | 66                        | 456.72                   |
| Bob Brown               | 12                        | 51.19                    |
| Rob Stuart              | 42                        | 34.81                    |
+-------------------------+---------------------------+--------------------------+
4 rows selected (0.086 seconds)

  5. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_orc. В выражении LOCATION укажите PXF-профиль hive:orc и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_seqfile (
    name TEXT,
    orders INT, 
    sales FLOAT
    )

    LOCATION ('pxf://default.customers_seqfile?PROFILE=hive&SERVER=hadoop')
    FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');

  6. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_seqfile;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales
------------+--------+--------
 John Doe   |     24 | 152.12
 Jane Smith |     66 | 456.72
 Bob Brown  |     12 |  51.19
 Rob Stuart |     42 |  34.81
(4 rows)

Чтение составных типов данных

  1. В каталоге /tmp на хосте HiveServer создайте текстовый файл customers_complex.txt. При определении массива в таблице Hive требуется указать символ-разделитель для каждого из его компонентов, а также для каждого ключа в ассоциативном массиве. Файл customers_complex.txt использует запятую (,) для разделения значений полей, знак процента (%) для разделения компонентов коллекции, а двоеточие (:) для отделения ключей ассоциативного массива:

    John Doe,1%2%3,tier:gold%subscription:active%referrals:6
Jane Smith,4%5%6,tier:silver%subscription:active
Bob Brown,7%8%9,tier:bronze%subscription:inactive%referrals:4
Rob Stuart,0%1%2,tier:gold%subscription:active%referrals:2

  2. На хосте HiveClient запустите командную строку Hive:

    $ hive

  3. Создайте таблицу Hive customers_c для хранения тестового набора данных. Выражение STORED AS TEXTFILE указывает, что таблица создается в формате TEXTFILE (по умолчанию). Выражение FIELDS TERMINATED BY устанавливает запятую (,) в качестве разделителя полей внутри записи данных (строки). Выражение COLLECTION ITEMS TERMINATED BY устанавливает знак процента (%) в качестве разделителя компонентов коллекции. Выражение MAP KEYS TERMINATED BY устанавливает двоеточие (:) для отделения ключей ассоциативного массива:

    CREATE TABLE customers_c (
    name STRING,
    metrics ARRAY<int>, 
    status MAP<string, string>
    )
    
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
    COLLECTION ITEMS TERMINATED BY '%'
    MAP KEYS TERMINATED BY ':'
    STORED AS TEXTFILE;

  4. Загрузите файл customers_complex.txt в созданную таблицу customers_c:

    LOAD DATA LOCAL INPATH '/tmp/customers_complex.txt'
INTO TABLE customers_c;

  5. Создайте таблицу Hive, хранящуюся в формате ORC:

    CREATE TABLE customers_c_orc (
    name STRING,
    metrics ARRAY<int>, 
    status MAP<string, string>
    )
    
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
    COLLECTION ITEMS TERMINATED BY '%'
    MAP KEYS TERMINATED BY ':'
    STORED AS ORC;

  6. Скопируйте данные из таблицы customers_c в таблицу customers_c_orc, чтобы сохранить их в формате ORC:

    INSERT INTO TABLE customers_c_orc SELECT * FROM customers_c;

  7. Опционально, выполните запрос к Hive-таблице customers_c_orc, чтобы убедиться, что данные загружены:

    SELECT * FROM customers_c_orc;

    Вывод должен выглядеть следующим образом:

    +-----------------------+--------------------------+-------------------------------------------------------------+
| customers_c_orc.name  | customers_c_orc.metrics  |                   customers_c_orc.status                    |
+-----------------------+--------------------------+-------------------------------------------------------------+
| John Doe              | [1,2,3]                  | {"tier":"gold","subscription":"active","referrals":"6"}     |
| Jane Smith            | [4,5,6]                  | {"tier":"silver","subscription":"active"}                   |
| Bob Brown             | [7,8,9]                  | {"tier":"bronze","subscription":"inactive","referrals":"4"} |
| Rob Stuart            | [0,1,2]                  | {"tier":"gold","subscription":"active","referrals":"2"}     |
+-----------------------+--------------------------+-------------------------------------------------------------+
4 rows selected (0.082 seconds)

  8. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_c_orc. В выражении LOCATION укажите PXF-профиль hive:orc и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_c_orc (
    name TEXT,
    metrics TEXT, 
    status TEXT
    )

    LOCATION ('pxf://default.customers_c_orc?PROFILE=hive:orc&SERVER=hadoop')
    FORMAT 'CUSTOM' (FORMATTER='pxfwritable_import');

  9. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_c_orc;

    В выводе поля metrics и status сериализованы как текстовые строки:

        name    | metrics |                           status
------------+---------+-------------------------------------------------------------
 John Doe   | [1,2,3] | {"tier":"gold","subscription":"active","referrals":"6"}
 Jane Smith | [4,5,6] | {"tier":"silver","subscription":"active"}
 Bob Brown  | [7,8,9] | {"tier":"bronze","subscription":"inactive","referrals":"4"}
 Rob Stuart | [0,1,2] | {"tier":"gold","subscription":"active","referrals":"2"}
(4 rows)

Доступ к однородным партиционированным данным

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive с двумя столбцами партиционирования, state и city:

    CREATE TABLE customers_part (
    name STRING,
    sales DOUBLE
    )

    PARTITIONED BY (state string, city string)
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';

  3. Загрузите тестовые данные в созданную таблицу, партиционировав ее по полям state и city:

    INSERT INTO TABLE customers_part
    PARTITION(state = 'California', city = 'Fresno')
    VALUES ('John Doe', 150.00);

INSERT INTO TABLE customers_part
    PARTITION(state = 'California', city = 'Sacramento')
    VALUES ('Jane Smith', 175.50);

INSERT INTO TABLE customers_part
    PARTITION(state = 'Nevada', city = 'Reno')
    VALUES ('Bob Brown', 200.75);

INSERT INTO TABLE customers_part
    PARTITION(state = 'Nevada', city = 'Las Vegas')
    VALUES ('Rob Stuart', 180.20);

  4. Выполните запрос к таблице customers_part:

    SELECT * FROM customers_part;

    В выводе столбцы партиционирования добавлены в конце каждой записи:

    +----------------------+-----------------------+-----------------------+----------------------+
| customers_part.name  | customers_part.sales  | customers_part.state  | customers_part.city  |
+----------------------+-----------------------+-----------------------+----------------------+
| John Doe             | 150.0                 | California            | Fresno               |
| Jane Smith           | 175.5                 | California            | Sacramento           |
| Rob Stuart           | 180.2                 | Nevada                | Las Vegas            |
| Bob Brown            | 200.75                | Nevada                | Reno                 |
+----------------------+-----------------------+-----------------------+----------------------+
4 rows selected (0.127 seconds)

  5. Просмотрите структуру каталогов Hive-таблицы customers_part в HDFS:

    $ hdfs dfs -ls -C -R /apps/hive/warehouse/customers_part

    Вывод должен выглядеть следующим образом:

    /apps/hive/warehouse/customers_part/state=California
/apps/hive/warehouse/customers_part/state=California/city=Fresno
/apps/hive/warehouse/customers_part/state=California/city=Fresno/000000_0
/apps/hive/warehouse/customers_part/state=California/city=Sacramento
/apps/hive/warehouse/customers_part/state=California/city=Sacramento/000000_0
/apps/hive/warehouse/customers_part/state=Nevada
/apps/hive/warehouse/customers_part/state=Nevada/city=Las Vegas
/apps/hive/warehouse/customers_part/state=Nevada/city=Las Vegas/000000_0
/apps/hive/warehouse/customers_part/state=Nevada/city=Reno
/apps/hive/warehouse/customers_part/state=Nevada/city=Reno/000000_0

  6. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_part. Чтобы использовать pushdown предикатов, определите столбцы state и city, соответствующие столбцам партиционирования Hive-таблицы. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_part (
    name TEXT,
    sales FLOAT,
    state TEXT, 
    city TEXT
    )

    LOCATION ('pxf://default.customers_part?PROFILE=hive&SERVER=hadoop')
    FORMAT 'custom' (FORMATTER='pxfwritable_import');

  7. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_part;

    Вывод должен выглядеть следующим образом:

        name    | sales  |   state    |    city
------------+--------+------------+------------
 Jane Smith |  175.5 | California | Sacramento
 Rob Stuart |  180.2 | Nevada     | Las Vegas
 John Doe   |    150 | California | Fresno
 Bob Brown  | 200.75 | Nevada     | Reno
(4 rows)

  8. Выполните запрос к созданной внешней таблице customers_part, возвращающий записи, где значение state равно Nevada, а значение sales больше 170. Фильтр на sales не передается в Hive, поскольку столбец не является столбцом партиционирования. Фильтрация выполняется на стороне Greengage DB после того, как все данные партиции Nevada переданы для обработки:

    SELECT * FROM customers_part where state = 'Nevada' and sales > 170;

    Вывод должен выглядеть следующим образом:

        name    | sales  | state  |   city
------------+--------+--------+-----------
 Rob Stuart |  180.2 | Nevada | Las Vegas
 Bob Brown  | 200.75 | Nevada | Reno
(2 rows)

  9. Выполните запрос к созданной внешней таблице customers_part, возвращающий записи, где значение state равно California. Фильтр на state передается в Hive, поскольку столбец является столбцом партиционирования. Фильтрация выполняется на стороне Hive до того, как все данные партиции California переданы для обработки:

    SELECT * FROM customers_part where state = 'California';

    Вывод должен выглядеть следующим образом:

        name    | sales |   state    |    city
------------+-------+------------+------------
 John Doe   |   150 | California | Fresno
 Jane Smith | 175.5 | California | Sacramento
(2 rows)

Доступ к разнородным партиционированным данным

Перед началом убедитесь, что вы создали тестовый набор данных, как описано в разделе Создание тестового набора данных, а также его копию в формате RCfile, как описано в разделе Использование профиля hive:rc.

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive, ссылающуюся на файлы данных Hive-таблиц customers и customers_rc. Таблица партиционирована по строковому полю year:

    CREATE EXTERNAL TABLE customers_part_m (
    name STRING,
    orders INT,
    sales DOUBLE
    )
    
    PARTITIONED BY (year string)
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';

  3. Выполните команду DESCRIBE EXTENDED на таблицах customers и customers_rc, чтобы увидеть расположение файлов данных в HDFS для каждой таблицы:

    DESCRIBE EXTENDED customers;
DESCRIBE EXTENDED customers_rc;

    В выводе команды местоположение таблиц в HDFS указано в поле location:

    ...
location:hdfs://hadoop/apps/hive/warehouse/customers
location:hdfs://hadoop/apps/hive/warehouse/customers_rc
...

  4. В таблице customers_part_m создайте партиции, ссылающиеся на местоположения файлов данных таблиц customers и customers_rc:

    ALTER TABLE customers_part_m ADD PARTITION (year = '2025') LOCATION 'hdfs://hadoop/apps/hive/warehouse/customers';
ALTER TABLE customers_part_m ADD PARTITION (year = '2026') LOCATION 'hdfs://hadoop/apps/hive/warehouse/customers_rc';

  5. Тип хранения таблицы customers не указан, поэтому по умолчанию используется TEXTFILE. Для таблицы customers_rc явно укажите формат файла, используемого партицией:

    ALTER TABLE customers_part_m PARTITION (year='2026') SET FILEFORMAT RCFILE;

  6. Просмотрите созданные партиции:

    SHOW PARTITIONS customers_part_m;

    Вывод должен выглядеть следующим образом:

    +------------+
| partition  |
+------------+
| year=2025  |
| year=2026  |
+------------+
2 rows selected

  7. Выполните запрос к созданной Hive-таблице:

    SELECT * FROM customers_part_m;

    Вывод должен выглядеть следующим образом:

    +------------------------+--------------------------+-------------------------+------------------------+
| customers_part_m.name  | customers_part_m.orders  | customers_part_m.sales  | customers_part_m.year  |
+------------------------+--------------------------+-------------------------+------------------------+
| John Doe               | 24                       | 152.12                  | 2025                   |
| Jane Smith             | 66                       | 456.72                  | 2025                   |
| Bob Brown              | 12                       | 51.19                   | 2025                   |
| Rob Stuart             | 42                       | 34.81                   | 2025                   |
| John Doe               | 24                       | 152.12                  | 2026                   |
| Jane Smith             | 66                       | 456.72                  | 2026                   |
| Bob Brown              | 12                       | 51.19                   | 2026                   |
| Rob Stuart             | 42                       | 34.81                   | 2026                   |
+------------------------+--------------------------+-------------------------+------------------------+
8 rows selected (0.135 seconds)

  8. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_part_m. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_part_m (
    name TEXT,
    orders INT,
    sales FLOAT,
    year TEXT
    )

    LOCATION ('pxf://default.customers_part_m?PROFILE=hive&SERVER=hadoop')
    FORMAT 'custom' (FORMATTER='pxfwritable_import');

  9. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_part_m;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales  | year
------------+--------+--------+------
 John Doe   |     24 | 152.12 | 2026
 Jane Smith |     66 | 456.72 | 2026
 Bob Brown  |     12 |  51.19 | 2026
 Rob Stuart |     42 |  34.81 | 2026
 John Doe   |     24 | 152.12 | 2025
 Jane Smith |     66 | 456.72 | 2025
 Bob Brown  |     12 |  51.19 | 2025
 Rob Stuart |     42 |  34.81 | 2025
(8 rows)

  10. Выполните запрос к внешней таблице, возвращающий сумму значений в столбце sales и значением year, равным 2025:

    SELECT sum(sales) FROM customers_part_m where year = '2025';

    Вывод должен выглядеть следующим образом:

      sum
--------
 694.84
(1 row)

Доступ к партиции Hive по умолчанию

  1. На хосте HiveClient запустите командную строку Hive:

    $ hive

  2. Создайте таблицу Hive с именем customers_part_d, партиционированной по строковому полю year:

    CREATE TABLE customers_part_d (
    name STRING,
    orders INT, 
    sales DOUBLE
    )

    PARTITIONED BY (year string)
    ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';

  3. Загрузите тестовые данные в созданную таблицу. Обратите внимание, что в третьей строке опущено выражение PARTITION и не указано значение столбца партиционирования year:

    INSERT INTO TABLE customers_part_d
    PARTITION(year = 2025)
    VALUES ('John Doe', 30, 150.00);

INSERT INTO TABLE customers_part_d
    PARTITION(year = 2025)
    VALUES ('Jane Smith', 28, 175.50);

INSERT INTO TABLE customers_part_d
    VALUES ('Bob Brown', 42, 200.75, NULL);

INSERT INTO TABLE customers_part_d
    PARTITION(year = 2025)
    VALUES ('Rob Stuart', 35, 180.20);

  4. Выполните запрос к таблице customers_part_d:

    SELECT * FROM customers_part_d;

    Вывод должен выглядеть следующим образом. Обратите внимание, что в столбце партиционирования year для значения NULL возвращается __HIVE_DEFAULT_PARTITION__:

    +------------------------+--------------------------+-------------------------+-----------------------------+
| customers_part_d.name  | customers_part_d.orders  | customers_part_d.sales  |    customers_part_d.year    |
+------------------------+--------------------------+-------------------------+-----------------------------+
| John Doe               | 30                       | 150.0                   | 2025                        |
| Jane Smith             | 28                       | 175.5                   | 2025                        |
| Rob Stuart             | 35                       | 180.2                   | 2025                        |
| Bob Brown              | 42                       | 200.75                  | __HIVE_DEFAULT_PARTITION__  |
+------------------------+--------------------------+-------------------------+-----------------------------+
4 rows selected (0.112 seconds)

  5. Выполните запрос к таблице customers_part_d, фильтрующий данные по столбцу партиционирования year:

    SELECT * FROM customers_part_d WHERE year IS NULL;

    В выводе не должно быть строк, так как данные, хранящиеся в партиции по умолчанию, исключены:

    +------------------------+--------------------------+-------------------------+------------------------+
| customers_part_d.name  | customers_part_d.orders  | customers_part_d.sales  | customers_part_d.year  |
+------------------------+--------------------------+-------------------------+------------------------+
+------------------------+--------------------------+-------------------------+------------------------+
No rows selected (0.165 seconds)

  6. На мастер-хосте Greengage DB создайте внешнюю таблицу, ссылающуюся на Hive-таблицу customers_part_d. В выражении LOCATION укажите PXF-профиль hive и конфигурацию сервера. В выражении FORMAT укажите pxfwritable_import — встроенную кастомную функцию форматирования для операций чтения:

    CREATE EXTERNAL TABLE customers_part_d (
    name TEXT,
    orders INT, 
    sales FLOAT,
    year TEXT 
    )

    LOCATION ('pxf://default.customers_part_d?PROFILE=hive&SERVER=hadoop')
    FORMAT 'custom' (FORMATTER='pxfwritable_import');

  7. Выполните запрос к созданной внешней таблице:

    SELECT * FROM customers_part_d;

    Вывод должен выглядеть следующим образом:

        name    | orders | sales  | year
------------+--------+--------+------
 Jane Smith |     28 |  175.5 | 2025
 Bob Brown  |     42 | 200.75 |
 Rob Stuart |     35 |  180.2 | 2025
 John Doe   |     30 |    150 | 2025
(4 rows)

  8. Выполните запрос к созданной таблице, фильтрующий данные по столбцу партиционирования year:

    SELECT * FROM customers_part_d WHERE year IS NULL;

    Так как все значения партиции по умолчанию переводятся в фактические значения NULL, запрос возвращает одну строку:

       name    | orders | sales  | year
-----------+--------+--------+------
 Bob Brown |     42 | 200.75 |
(1 row)
Предыдущая
HBase
Следующая
Текст