25.6.17.47 The ndbinfo memory_per_fragment Table — MySQL 8.4

25.6.17.47 Таблица ndbinfo memory_per_fragment

Таблица memory_per_fragment предоставляет информацию об использовании памяти отдельными фрагментами. См. примечания в этом разделе, чтобы узнать, как определить, сколько памяти используется таблицами NDB.

Таблица memory_per_fragment содержит следующие столбцы:

fq_name

Имя этого фрагмента
parent_fq_name

Имя родительского фрагмента
type

Тип объекта словаря (, в API NDB) используемый для этого фрагмента; один из System table, User table, Unique hash index, Hash index, Unique ordered index, Ordered index, Hash index trigger, Subscription trigger, Read only constraint, Index trigger, Reorganize trigger, Tablespace, Log file group, Data file, Undo file, Hash map, Foreign key definition, Foreign key parent trigger, Foreign key child trigger или Schema transaction.

Вы также можете получить этот список, выполнив TABLE ndbinfo.dict_obj_types в клиенте mysql.
table_id

Идентификатор таблицы для этой таблицы
node_id

Идентификатор узла для этого узла
block_instance

Идентификатор экземпляра блока ядра NDB; вы можете использовать это число для получения информации о конкретных потоках из таблицы threadblocks.
fragment_num

Идентификатор фрагмента (номер)
fixed_elem_alloc_bytes

Количество байтов, выделенных для элементов фиксированного размера
fixed_elem_free_bytes

Остаток свободных байтов в страницах, выделенных для элементов фиксированного размера
fixed_elem_size_bytes

Длина каждого элемента фиксированного размера в байтах
fixed_elem_count

Количество элементов фиксированного размера
fixed_elem_free_count

Количество свободных строк для элементов фиксированного размера
var_elem_alloc_bytes

Количество байтов, выделенных для элементов переменного размера
var_elem_free_bytes

Остаток свободных байтов в страницах, выделенных для элементов переменного размера
var_elem_count

Количество элементов переменного размера
hash_index_alloc_bytes

Количество байтов, выделенных для индексов хеширования

Таблица memory_per_fragment: Примечания

Таблица memory_per_fragment содержит по одной строке для каждой реплики фрагмента таблицы и каждой реплики фрагмента индекса в системе; это означает, что, например, при NoOfReplicas=2, обычно существует две реплики фрагмента для каждого фрагмента. Это верно, пока все узлы данных работают и подключены к кластеру; для отсутствующего узла данных нет строк для реплик фрагментов, которые он содержит.

Столбцы таблицы memory_per_fragment можно сгруппировать по их функции или назначению следующим образом:

Ключевые столбцы: fq_name, type, table_id, node_id, block_instance и fragment_num
Столбец связи: parent_fq_name
Столбцы с хранением фиксированного размера: fixed_elem_alloc_bytes, fixed_elem_free_bytes, fixed_elem_size_bytes, fixed_elem_count и fixed_elem_free_count
Столбцы с хранением переменного размера: var_elem_alloc_bytes, var_elem_free_bytes и var_elem_count
Столбец индекса хэширования: hash_index_alloc_bytes

Столбцы parent_fq_name и fq_name могут использоваться для идентификации индексов, связанных с таблицей. Аналогичная информация об иерархии объектов схемы доступна в других таблицах ndbinfo.

Реплики фрагментов таблиц и индексов выделяют DataMemory в страницах по 32 КБ. Эти страницы памяти управляются следующим образом:

Страницы фиксированного размера: Они хранят фиксированные части строк, хранящихся в данном фрагменте. Каждая строка имеет фиксированную часть.
Страницы переменного размера: Они хранят части переменного размера для строк во фрагменте. Каждая строка, имеющая одну или несколько частей переменного размера, одну или несколько динамических колонок (или то и другое), имеет часть переменного размера.
Страницы индекса хэширования: Они выделяются как подстраницы размером 8 КБ и хранят структуру индекса хэширования первичного ключа.

Каждая строка в таблице NDB имеет фиксированную часть, состоящую из заголовка строки и одной или нескольких колонок фиксированного размера. Строка также может содержать одну или несколько ссылок на части переменного размера, одну или несколько ссылок на части диска, или то и другое. Каждая строка также имеет запись индекса хэширования первичного ключа (соответствующую скрытому первичного ключу, который является частью каждой таблицы NDB).

Из вышеизложенного следует, что каждый фрагмент таблицы и фрагмент индекса вместе выделяют объём DataMemory, рассчитанный следующим образом:

DataMemory =
  (number_of_fixed_pages + number_of_var_pages) * 32KB
    + number_of_hash_pages * 8KB

Поскольку fixed_elem_alloc_bytes и var_elem_alloc_bytes всегда являются кратными 32768 байтам, мы можем дополнительно определить, что number_of_fixed_pages = fixed_elem_alloc_bytes / 32768 и number_of_var_pages = var_elem_alloc_bytes / 32768. hash_index_alloc_bytes всегда кратно 8192 байтам, поэтому number_of_hash_pages = hash_index_alloc_bytes / 8192.

Страница фиксированного размера имеет внутренний заголовок и количество фиксированных слотов, каждый из которых может содержать фиксированную часть одной строки. Размер фиксированной части данной строки зависит от схемы и предоставляется столбцом fixed_elem_size_bytes; количество фиксированных слотов на странице можно определить, вычислив общее количество слотов и общее количество страниц следующим образом:

fixed_slots = fixed_elem_count + fixed_elem_free_count

fixed_pages = fixed_elem_alloc_bytes / 32768

slots_per_page = total_slots / total_pages

fixed_elem_count фактически является количеством строк для данного фрагмента таблицы, так как каждая строка имеет 1 фиксированный элемент, fixed_elem_free_count — общее количество свободных фиксированных слотов на выделенных страницах. fixed_elem_free_bytes равно fixed_elem_free_count * fixed_elem_size_bytes.

Фрагмент может иметь любое количество страниц фиксированного размера; когда последняя строка на странице фиксированного размера удаляется, страница возвращается в пул страниц DataMemory. Страницы фиксированного размера могут быть фрагментированы, с выделением больше страниц, чем необходимо по количеству используемых слотов фиксированного размера. Вы можете проверить, так ли это, сравнив требуемые страницы с выделенными страницами, которые можно рассчитать следующим образом:

fixed_pages_required = 1 + (fixed_elem_count / slots_per_page)

fixed_page_utilization = fixed_pages_required / fixed_pages

Страница переменного размера имеет внутренний заголовок и использует оставшееся пространство для хранения одной или нескольких частей строк переменного размера; количество хранимых частей зависит от схемы и фактических данных. Поскольку не все схемы или строки имеют часть переменного размера, var_elem_count может быть меньше, чем fixed_elem_count. Общий свободный объем, доступный на всех страницах переменного размера во фрагменте, показан в столбце var_elem_free_bytes; поскольку это пространство может быть распределено по нескольким страницам, его нельзя обязательно использовать для хранения записи определенного размера. Каждая страница переменного размера реорганизуется по мере необходимости, чтобы соответствовать изменяющемуся размеру частей переменного размера строк по мере их вставки, обновления и удаления; если какая-либо часть строки становится слишком большой для страницы, на которой она находится, она может быть перемещена на другую страницу.

Использование страниц переменного размера можно рассчитать следующим образом:

var_page_used_bytes =  var_elem_alloc_bytes - var_elem_free_bytes

var_page_utilisation = var_page_used_bytes / var_elem_alloc_bytes

avg_row_var_part_size = var_page_used_bytes / fixed_elem_count

Мы можем получить средний размер переменной части на строку следующим образом:

avg_row_var_part_size = var_page_used_bytes / fixed_elem_count

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

Первичный ключ: Индексированные столбцы в базовой таблице.
Значения: Столбцы первичного ключа из базовой таблицы.

Эти таблицы распределяются и фрагментируются как обычно. Это означает, что их реплики фрагментов используют страницы фиксированного, переменного и индекса хэширования, как и любая другая таблица NDB.

Вторичные упорядоченные индексы фрагментируются и распределяются так же, как и базовая таблица. Упорядоченные фрагменты индексов являются структурами T-дерева, которые поддерживают сбалансированное дерево, содержащее ссылки на строки в порядке, заданном индексированными столбцами. Поскольку дерево содержит ссылки, а не фактические данные, затраты на хранение T-дерева не зависят от размера или количества индексированных столбцов, а скорее являются функцией количества строк. Дерево строится с использованием структур узлов фиксированного размера, каждая из которых может содержать количество ссылок на строки; необходимое количество узлов зависит от количества строк в таблице и необходимой структуры дерева для представления порядка. В таблице memory_per_fragment мы видим, что упорядоченные индексы выделяют только страницы фиксированного размера, поэтому, как обычно, соответствующие столбцы из этой таблицы приведены здесь:

fixed_elem_alloc_bytes: Это равно 32768 умноженному на количество страниц фиксированного размера.
fixed_elem_count: Количество используемых узлов T-дерева.
fixed_elem_size_bytes: Количество байтов на узел T-дерева.
fixed_elem_free_count: Количество слотов узлов T-дерева, доступных на выделенных страницах.
fixed_elem_free_bytes: Это равно fixed_elem_free_count * fixed_elem_size_bytes.

Если свободное место на странице фрагментировано, страница дефрагментируется. OPTIMIZE TABLE можно использовать для дефрагментации страниц переменного размера таблицы; это перемещает части переменного размера строк между страницами, так что некоторые целые страницы могут быть освобождены для повторного использования.

Таблица memory_per_fragment: Примеры

Для следующих примеров мы создаём простую таблицу с тремя столбцами целого типа, один из которых имеет первичный ключ, один — уникальный индекс, и один без индексов, а также один столбец VARCHAR без индексов, как показано здесь:

mysql> CREATE DATABASE IF NOT EXISTS test;
Query OK, 1 row affected (0.06 sec)

mysql> USE test;
Database changed

mysql> CREATE TABLE t1 (
    ->    c1 BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    ->    c2 INT,
    ->    c3 INT UNIQUE,
    -> )  ENGINE=NDBCLUSTER;
Query OK, 0 rows affected (0.27 sec)

После создания таблицы мы вставляем 50 000 строк, содержащих случайные данные; точный метод генерации и вставки этих строк не имеет практического значения, и мы оставляем этот метод на усмотрение пользователя.

Получение общей информации о фрагментах и использовании памяти

Этот запрос отображает общую информацию об использовании памяти для каждого фрагмента:

mysql> SELECT
    ->   fq_name, node_id, block_instance, fragment_num, fixed_elem_alloc_bytes,
    ->   fixed_elem_free_bytes, fixed_elem_size_bytes, fixed_elem_count,
    ->   fixed_elem_free_count, var_elem_alloc_bytes, var_elem_free_bytes,
    ->   var_elem_count
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = "test/def/t1"\G
*************************** 1. row ***************************
               fq_name: test/def/t1
               node_id: 5
        block_instance: 1
          fragment_num: 0
fixed_elem_alloc_bytes: 1114112
 fixed_elem_free_bytes: 11836
 fixed_elem_size_bytes: 44
      fixed_elem_count: 24925
 fixed_elem_free_count: 269
  var_elem_alloc_bytes: 1245184
   var_elem_free_bytes: 32552
        var_elem_count: 24925
*************************** 2. row ***************************
               fq_name: test/def/t1
               node_id: 5
        block_instance: 1
          fragment_num: 1
fixed_elem_alloc_bytes: 1114112
 fixed_elem_free_bytes: 5236
 fixed_elem_size_bytes: 44
      fixed_elem_count: 25075
 fixed_elem_free_count: 119
  var_elem_alloc_bytes: 1277952
   var_elem_free_bytes: 54232
        var_elem_count: 25075
*************************** 3. row ***************************
               fq_name: test/def/t1
               node_id: 6
        block_instance: 1
          fragment_num: 0
fixed_elem_alloc_bytes: 1114112
 fixed_elem_free_bytes: 11836
 fixed_elem_size_bytes: 44
      fixed_elem_count: 24925
 fixed_elem_free_count: 269
  var_elem_alloc_bytes: 1245184
   var_elem_free_bytes: 32552
        var_elem_count: 24925
*************************** 4. row ***************************
               fq_name: test/def/t1
               node_id: 6
        block_instance: 1
          fragment_num: 1
fixed_elem_alloc_bytes: 1114112
 fixed_elem_free_bytes: 5236
 fixed_elem_size_bytes: 44
      fixed_elem_count: 25075
 fixed_elem_free_count: 119
  var_elem_alloc_bytes: 1277952
   var_elem_free_bytes: 54232
        var_elem_count: 25075
4 rows in set (0.12 sec)

Поиск таблицы и её индексов

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

mysql> SELECT fq_name
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+
| fq_name              |
+----------------------+
| test/def/t1          |
| sys/def/13/PRIMARY   |
| sys/def/13/c3        |
| sys/def/13/c3$unique |
+----------------------+
4 rows in set (0.13 sec)

mysql> SELECT COUNT(*) FROM t1;
+----------+
| COUNT(*) |
+----------+
|    50000 |
+----------+
1 row in set (0.00 sec)

Поиск памяти, выделенной элементами схемы

Этот запрос отображает память, выделенную каждым элементом схемы (в сумме по всем репликам):

mysql> SELECT
    ->   fq_name AS Name,
    ->   SUM(fixed_elem_alloc_bytes) AS Fixed,
    ->   SUM(var_elem_alloc_bytes) AS Var,
    ->   SUM(hash_index_alloc_bytes) AS Hash,
    ->   SUM(fixed_elem_alloc_bytes+var_elem_alloc_bytes+hash_index_alloc_bytes) AS Total
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+---------+---------+---------+----------+
| Name                 | Fixed   | Var     | Hash    | Total    |
+----------------------+---------+---------+---------+----------+
| test/def/t1          | 4456448 | 5046272 | 1425408 | 10928128 |
| sys/def/13/PRIMARY   | 1966080 |       0 |       0 |  1966080 |
| sys/def/13/c3        | 1441792 |       0 |       0 |  1441792 |
| sys/def/13/c3$unique | 3276800 |       0 | 1425408 |  4702208 |
+----------------------+---------+---------+---------+----------+
4 rows in set (0.11 sec)

Поиск памяти, выделенной для таблицы и всех индексов

Сумму памяти, выделенной для таблицы и всех её индексов (в сумме по всем репликам), можно получить, используя следующий запрос:

mysql> SELECT
    ->   SUM(fixed_elem_alloc_bytes) AS Fixed,
    ->   SUM(var_elem_alloc_bytes) AS Var,
    ->   SUM(hash_index_alloc_bytes) AS Hash,
    ->   SUM(fixed_elem_alloc_bytes+var_elem_alloc_bytes+hash_index_alloc_bytes) AS Total
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+----------+---------+---------+----------+
| Fixed    | Var     | Hash    | Total    |
+----------+---------+---------+----------+
| 11141120 | 5046272 | 2850816 | 19038208 |
+----------+---------+---------+----------+
1 row in set (0.12 sec)

Это сокращённая версия предыдущего запроса, которая показывает только общую память, используемую таблицей:

mysql> SELECT
    ->   SUM(fixed_elem_alloc_bytes+var_elem_alloc_bytes+hash_index_alloc_bytes) AS Total
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+----------+
| Total    |
+----------+
| 19038208 |
+----------+
1 row in set (0.12 sec)

Поиск памяти, выделенной на строку

Следующий запрос отображает общую память, выделенную на строку (по всем репликам):

mysql> SELECT
    ->   SUM(fixed_elem_alloc_bytes+var_elem_alloc_bytes+hash_index_alloc_bytes)
    ->   /
    ->   SUM(fixed_elem_count) AS Total_alloc_per_row
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1';
+---------------------+
| Total_alloc_per_row |
+---------------------+
|            109.2813 |
+---------------------+
1 row in set (0.12 sec)

Поиск общего использования памяти на строку

Чтобы получить общее использование памяти на строку (по всем репликам), нам нужно разделить общее использование памяти на количество строк, что является fixed_elem_count для основной таблицы следующим образом:

mysql> SELECT
    ->   SUM(
    ->     (fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->     + (var_elem_alloc_bytes - var_elem_free_bytes)
    ->     + hash_index_alloc_bytes
    ->   )
    ->   /
    ->   SUM(fixed_elem_count)
    ->   AS total_in_use_per_row
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1';
+----------------------+
| total_in_use_per_row |
+----------------------+
|             107.2042 |
+----------------------+
1 row in set (0.12 sec)

Поиск памяти, выделенной на элемент

Память, выделенную каждому элементу схемы (в сумме по всем репликам), можно найти, используя следующий запрос:

mysql> SELECT
    ->   fq_name AS Name,
    ->   SUM(fixed_elem_alloc_bytes) AS Fixed,
    ->   SUM(var_elem_alloc_bytes) AS Var,
    ->   SUM(hash_index_alloc_bytes) AS Hash,
    ->   SUM(fixed_elem_alloc_bytes + var_elem_alloc_bytes + hash_index_alloc_bytes)
    ->     AS Total_alloc
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+---------+---------+---------+-------------+
| Name                 | Fixed   | Var     | Hash    | Total_alloc |
+----------------------+---------+---------+---------+-------------+
| test/def/t1          | 4456448 | 5046272 | 1425408 |    10928128 |
| sys/def/13/PRIMARY   | 1966080 |       0 |       0 |     1966080 |
| sys/def/13/c3        | 1441792 |       0 |       0 |     1441792 |
| sys/def/13/c3$unique | 3276800 |       0 | 1425408 |     4702208 |
+----------------------+---------+---------+---------+-------------+
4 rows in set (0.11 sec)

Поиск средней памяти, выделенной на строку, по элементам

Чтобы получить среднее значение памяти, выделенной на строку каждым элементом схемы (в сумме по всем репликам), мы используем подзапрос для получения фиксированного количества элементов основной таблицы каждый раз, чтобы получить среднее значение на строку, так как fixed_elem_count для индексов необязательно совпадает с основной таблицей, как показано здесь:

mysql> SELECT
    ->   fq_name AS Name,
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Table_rows,
    ->
    ->   SUM(fixed_elem_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Avg_fixed_alloc,
    ->
    ->   SUM(var_elem_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') as Avg_var_alloc,
    ->
    ->   SUM(hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') as Avg_hash_alloc,
    ->
    ->   SUM(fixed_elem_alloc_bytes+var_elem_alloc_bytes+hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') as Avg_total_alloc
    ->
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' or parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+------------+-----------------+---------------+----------------+-----------------+
| Name                 | Table_rows | Avg_fixed_alloc | Avg_var_alloc | Avg_hash_alloc | Avg_total_alloc |
+----------------------+------------+-----------------+---------------+----------------+-----------------+
| test/def/t1          |     100000 |         44.5645 |       50.4627 |        14.2541 |        109.2813 |
| sys/def/13/PRIMARY   |     100000 |         19.6608 |        0.0000 |         0.0000 |         19.6608 |
| sys/def/13/c3        |     100000 |         14.4179 |        0.0000 |         0.0000 |         14.4179 |
| sys/def/13/c3$unique |     100000 |         32.7680 |        0.0000 |        14.2541 |         47.0221 |
+----------------------+------------+-----------------+---------------+----------------+-----------------+
4 rows in set (0.70 sec)

Поиск средней памяти, выделенной на строку

Среднее значение памяти, выделенной на строку (в сумме по всем репликам):

mysql> SELECT
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Table_rows,
    ->
    ->   SUM(fixed_elem_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Avg_fixed_alloc,
    ->
    ->   SUM(var_elem_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Avg_var_alloc,
    ->
    ->   SUM(hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Avg_hash_alloc,
    ->
    ->   SUM(fixed_elem_alloc_bytes + var_elem_alloc_bytes + hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS Avg_total_alloc
    ->
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+------------+-----------------+---------------+----------------+-----------------+
| Table_rows | Avg_fixed_alloc | Avg_var_alloc | Avg_hash_alloc | Avg_total_alloc |
+------------+-----------------+---------------+----------------+-----------------+
|     100000 |        111.4112 |       50.4627 |        28.5082 |        190.3821 |
+------------+-----------------+---------------+----------------+-----------------+
1 row in set (0.71 sec)

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

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

mysql> SELECT
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS table_rows,
    ->
    ->   SUM(fixed_elem_alloc_bytes + var_elem_alloc_bytes + hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_total_alloc
    ->
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+------------+-----------------+
| table_rows | avg_total_alloc |
+------------+-----------------+
|     100000 |        190.3821 |
+------------+-----------------+
1 row in set (0.33 sec)

Поиск памяти, используемой каждым элементом схемы

Чтобы получить память, используемую каждым элементом схемы по всем репликам, нам нужно суммировать разницу между выделенной и свободной памятью для каждого элемента, как показано здесь:

mysql> SELECT
    ->   fq_name AS Name,
    ->   SUM(fixed_elem_alloc_bytes - fixed_elem_free_bytes) AS fixed_inuse,
    ->   SUM(var_elem_alloc_bytes-var_elem_free_bytes) AS var_inuse,
    ->   SUM(hash_index_alloc_bytes) AS hash_memory,
    ->   SUM(  (fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->       + (var_elem_alloc_bytes - var_elem_free_bytes)
    ->       + hash_index_alloc_bytes) AS total_alloc
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+-------------+-----------+---------+-------------+
| fq_name              | fixed_inuse | var_inuse | hash    | total_alloc |
+----------------------+-------------+-----------+---------+-------------+
| test/def/t1          |     4422304 |   4872704 | 1425408 |    10720416 |
| sys/def/13/PRIMARY   |     1950848 |         0 |       0 |     1950848 |
| sys/def/13/c3        |     1428736 |         0 |       0 |     1428736 |
| sys/def/13/c3$unique |     3212800 |         0 | 1425408 |     4638208 |
+----------------------+-------------+-----------+---------+-------------+
4 rows in set (0.13 sec)

Поиск средней памяти, используемой каждым элементом схемы

Этот запрос получает среднее значение используемой памяти на каждый элемент схемы по всем репликам:

mysql> SELECT
    ->   fq_name AS Name,
    ->
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS table_rows,
    ->
    ->   SUM(fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_fixed_inuse,
    ->
    ->   SUM(var_elem_alloc_bytes - var_elem_free_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_var_inuse,
    ->
    ->   SUM(hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_hash,
    ->
    ->   SUM(
    ->       (fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->     + (var_elem_alloc_bytes - var_elem_free_bytes) + hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_total_inuse
    ->
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1'
    -> GROUP BY fq_name;
+----------------------+------------+-----------------+---------------+----------+-----------------+
| Name                 | table_rows | avg_fixed_inuse | avg_var_inuse | avg_hash | avg_total_inuse |
+----------------------+------------+-----------------+---------------+----------+-----------------+
| test/def/t1          |     100000 |         44.2230 |       48.7270 |  14.2541 |        107.2042 |
| sys/def/13/PRIMARY   |     100000 |         19.5085 |        0.0000 |   0.0000 |         19.5085 |
| sys/def/13/c3        |     100000 |         14.2874 |        0.0000 |   0.0000 |         14.2874 |
| sys/def/13/c3$unique |     100000 |         32.1280 |        0.0000 |  14.2541 |         46.3821 |
+----------------------+------------+-----------------+---------------+----------+-----------------+
4 rows in set (0.72 sec)

Поиск средней памяти, используемой на строку, по элементам

Этот запрос получает среднее значение памяти, используемой на строку, по элементам, по всем репликам:

mysql> SELECT
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS table_rows,
    ->
    ->   SUM(fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_fixed_inuse,
    ->
    ->   SUM(var_elem_alloc_bytes - var_elem_free_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_var_inuse,
    ->
    ->   SUM(hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_hash,
    ->
    ->   SUM(
    ->     (fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->     + (var_elem_alloc_bytes - var_elem_free_bytes)
    ->     + hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT SUM(fixed_elem_count)
    ->     FROM ndbinfo.memory_per_fragment
    ->     WHERE fq_name='test/def/t1') AS avg_total_inuse
    ->
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+------------+-----------------+---------------+----------+-----------------+
| table_rows | avg_fixed_inuse | avg_var_inuse | avg_hash | avg_total_inuse |
+------------+-----------------+---------------+----------+-----------------+
|     100000 |        110.1469 |       48.7270 |  28.5082 |        187.3821 |
+------------+-----------------+---------------+----------+-----------------+
1 row in set (0.68 sec)

Поиск общей средней памяти, используемой на строку

Этот запрос получает общее среднее значение используемой памяти на строку:

mysql> SELECT
    ->   SUM(
    ->     (fixed_elem_alloc_bytes - fixed_elem_free_bytes)
    ->     + (var_elem_alloc_bytes - var_elem_free_bytes)
    ->     + hash_index_alloc_bytes)
    ->   /
    ->   ( SELECT
    ->       SUM(fixed_elem_count)
    ->       FROM ndbinfo.memory_per_fragment
    ->       WHERE fq_name='test/def/t1') AS avg_total_in_use
    -> FROM ndbinfo.memory_per_fragment
    -> WHERE fq_name = 'test/def/t1' OR parent_fq_name='test/def/t1';
+------------------+
| avg_total_in_use |
+------------------+
|         187.3821 |
+------------------+
1 row in set (0.24 sec)