MySQL :: MySQL 9.0 參考手冊 :: 25.6.17.47 ndbinfo memory_per_fragment 表格

版本 9.0

8.4 目前
8.0
5.7

8.0 日文

MySQL 9.0 參考手冊 / ... / ndbinfo memory_per_fragment 表格

25.6.17.47 ndbinfo memory_per_fragment 表格

memory_per_fragment 表格提供關於個別片段記憶體使用情況的資訊。請參閱本節稍後的注意事項，以了解如何使用它來找出 NDB 表格使用了多少記憶體。

memory_per_fragment 表格包含以下欄位

fq_name
此片段的名稱
parent_fq_name
此片段的父片段名稱
type
用於此片段的字典物件類型（在 NDB API 中的Object::Type）；可以是 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 的其中一種。
您也可以在 mysql 用戶端中執行 TABLE ndbinfo.dict_obj_types 來取得此清單。
table_id
此表格的表格 ID
node_id
此節點的節點 ID
block_instance
NDB 核心區塊實例 ID；您可以使用此數字從 threadblocks 表格取得關於特定執行緒的資訊。
fragment_num
片段 ID（數字）
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 表格中取得。

表格和索引片段複本以 32KB 頁面配置 DataMemory。這些記憶體頁面的管理方式如下

固定大小的頁面：這些頁面儲存指定片段中儲存的列的固定大小部分。每個列都有一個固定大小部分。
可變大小的頁面：這些頁面儲存片段中列的可變大小部分。每個具有一或多個可變大小的動態欄位（或兩者）的列都有一個可變大小的部分。
雜湊索引頁面：這些頁面配置為 8 KB 子頁面，並儲存主索引鍵雜湊索引結構。

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)