Movatterモバイル変換

• memory_per_fragment Table: Notes

• memory_per_fragment Table: Examples

• fq_name

  Name of this fragment

• parent_fq_name

  Name of this fragment's parent

• type

  Dictionary object type (Object::Type, in the NDB API) used for this fragment; one ofSystem 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, orSchema transaction.

  You can also obtain this list by executingTABLEndbinfo.dict_obj_types in themysql client.

• table_id

  Table ID for this table

• node_id

  Node ID for this node

• block_instance

  NDB kernel block instance ID; you can use this number to obtain information about specific threads from thethreadblocks table.

• fragment_num

  Fragment ID (number)

• fixed_elem_alloc_bytes

  Number of bytes allocated for fixed-sized elements

• fixed_elem_free_bytes

  Free bytes remaining in pages allocated to fixed-size elements

• fixed_elem_size_bytes

  Length of each fixed-size element in bytes

• fixed_elem_count

  Number of fixed-size elements

• fixed_elem_free_count

  Number of free rows for fixed-size elements

• var_elem_alloc_bytes

  Number of bytes allocated for variable-size elements

• var_elem_free_bytes

  Free bytes remaining in pages allocated to variable-size elements

• var_elem_count

  Number of variable-size elements

• hash_index_alloc_bytes

  Number of bytes allocated to hash indexes

Thememory_per_fragment table contains one row for every table fragment replica and every index fragment replica in the system; this means that, for example, whenNoOfReplicas=2, there are normally two fragment replicas for each fragment. This is true as long as all data nodes are running and connected to the cluster; for a data node that is missing, there are no rows for the fragment replicas that it hosts.

The columns of thememory_per_fragment table can be grouped according to their function or purpose as follows:

Theparent_fq_name andfq_name columns can be used to identify indexes associated with a table. Similar schema object hierarchy information is available in otherndbinfo tables.

Table and index fragment replicas allocateDataMemory in 32KB pages. These memory pages are managed as listed here:

Each row in anNDB table has a fixed-size part, consisting of a row header, and one or more fixed-size columns. The row may also contain one or more variable-size part references, one or more disk part references, or both. Each row also has a primary key hash index entry (corresponding to the hidden primary key that is part of everyNDB table).

From the foregoing we can see that each table fragment and index fragment together allocate the amount ofDataMemory calculated as shown here:

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

Sincefixed_elem_alloc_bytes andvar_elem_alloc_bytes are always multiples of 32768 bytes, we can further determine thatnumber_of_fixed_pages = fixed_elem_alloc_bytes / 32768 andnumber_of_var_pages = var_elem_alloc_bytes / 32768.hash_index_alloc_bytes is always a multiple of 8192 bytes, sonumber_of_hash_pages = hash_index_alloc_bytes / 8192.

A fixed size page has an internal header and a number of fixed-size slots, each of which can contain one row's fixed-size part. The size of a given row's fixed size part is schema-dependent, and is provided by thefixed_elem_size_bytes column; the number of fixed-size slots per page can be determined by calculating the total number of slots and the total number of pages, like this:

fixed_slots = fixed_elem_count + fixed_elem_free_countfixed_pages = fixed_elem_alloc_bytes / 32768slots_per_page = total_slots / total_pages

fixed_elem_count is in effect the row count for a given table fragment, since each row has 1 fixed element,fixed_elem_free_count is the total number of free fixed-size slots across the allocated pages.fixed_elem_free_bytes is equal tofixed_elem_free_count * fixed_elem_size_bytes.

A fragment can have any number of fixed-size pages; when the last row on a fixed-size page is deleted, the page is released to theDataMemory page pool. Fixed-size pages can be fragmented, with more pages allocated than is required by the number of fixed-size slots in use. You can check whether this is the case by comparing the pages required to the pages allocated, which you can calculate like this:

fixed_pages_required = 1 + (fixed_elem_count /slots_per_page)fixed_page_utilization =fixed_pages_required /fixed_pages

A variable-sized page has an internal header and uses the remaining space to store one or more variable-sized row parts; the number of parts stored depends on the schema and the actual data stored. Since not all schemas or rows have a variable-sized part,var_elem_count can be less thanfixed_elem_count. The total free space available on all variable-sized pages in the fragment is shown by thevar_elem_free_bytes column; because this space may be spread over multiple pages, it cannot necessarily be used to store an entry of a particular size. Each variable-sized page is reorganized as needed to fit the changing size of variable-sized row parts as they are inserted, updated, and deleted; if a given row part grows too large for the page it is in, it can be moved to a different page.

Variable-sized page utilisation can be calculated as shown here:

var_page_used_bytes =  var_elem_alloc_bytes - var_elem_free_bytesvar_page_utilisation = var_page_used_bytes / var_elem_alloc_bytesavg_row_var_part_size =var_page_used_bytes / fixed_elem_count

We can obtain the average variable part size per row like this:

avg_row_var_part_size =var_page_used_bytes / fixed_elem_count

Secondary unique indexes are implemented internally as independent tables with the following schema:

These tables are distributed and fragmented as normal. This means that their fragment replicas use fixed, variable, and hash index pages as with any otherNDB table.

Secondary ordered indexes are fragmented and distributed in the same way as the base table. Ordered index fragments are T-tree structures which maintain a balanced tree containing row references in the order implied by the indexed columns. Since the tree contains references rather than actual data, the T-tree storage cost is not dependent on the size or number of indexed columns, but is rather a function of the number of rows. The tree is constructed using fixed-size node structures, each of which may contain a number of row references; the number of nodes required depends on the number of rows in the table, and the tree structure necessary to represent the ordering. In thememory_per_fragment table, we can see that ordered indexes allocate only fixed-size pages, so as usual the relevant columns from this table are as listed here:

If free space in a page is fragmented, the page is defragmented.OPTIMIZE TABLE can be used to defragment a table's variable-sized pages; this moves row variable-sized parts between pages so that some whole pages can be freed for re-use.

For the following examples, we create a simple table with three integer columns, one of which has a primary key, one having a unique index, and one with no indexes, as well as oneVARCHAR column with no indexes, as shown here:

mysql> CREATE DATABASE IF NOT EXISTS test;Query OK, 1 row affected (0.06 sec)mysql> USE test;Database changedmysql> 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)

Following creation of the table, we insert 50,000 rows containing random data; the precise method of generating and inserting these rows makes no practical difference, and we leave the method of accomplishing as an exercise for the user.

Getting general information about fragments and memory usage

This query shows general information about memory usage for each fragment:

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: 0fixed_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: 1fixed_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: 0fixed_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: 1fixed_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: 250754 rows in set (0.12 sec)

Finding a table and its indexes

This query can be used to find a specific table and its indexes:

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)

Finding the memory allocated by schema elements

This query shows the memory allocated by each schema element (in total across all replicas):

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)

Finding the memory allocated for a table and all indexes

The sum of memory allocated for the table and all its indexes (in total across all replicas) can be obtained using the query shown here:

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)

This is an abbreviated version of the previous query which shows only the total memory used by the table:

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)

Finding the memory allocated per row

The following query shows the total memory allocated per row (across all replicas):

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)

Finding the total memory in use per row

To obtain the total memory in use per row (across all replicas), we need the total memory used divided by the row count, which is thefixed_elem_count for the base table like this:

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)

Finding the memory allocated per element

The memory allocated by each schema element (in total across all replicas) can be found using the following query:

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)

Finding the average memory allocated per row, by element

To obtain the average memory allocated per row by each schema element (in total across all replicas), we use a subquery to get the base table fixed element count each time to get an average per row sincefixed_elem_count for the indexes is not necessarily the same as for the base table, as shown here:

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)

Finding the average memory allocated per row

Average memory allocated per row (in total across all replicas):

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)

Finding the average memory allocated per row for a table

To get the average amount of memory allocated per row for the entire table across all replicas, we can use the query shown here:

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)

Finding the memory in use by each schema element

To obtain the memory in use per schema element across all replicas, we need to sum the difference between allocated and free memory for each element, like this:

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)

Finding the average memory in use by each schema element

This query gets the average memory in use per schema element across all replicas:

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)

Finding the average memory in use per row, by element

This query gets the average memory in use per row, by element, across all replicas:

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)

Finding the total average memory in use per row

This query obtains the total average memory in use, per row:

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)