21.6.15.27 The ndbinfo memory_per_fragment Table — MySQL 5.7

21.6.15.27 Таблица 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.

Вы также можете получить этот список, выполнив команду 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

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

END_OF_DOCUMENT_MARKER

Таблица 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)