MySQL :: MySQL 8.4 參考手冊 :: 25.6.17.47 ndbinfo memory_per_fragment 資料表

版本 8.4

9.0
8.0
5.7

8.0 日文

MySQL 8.4 參考手冊 / ... / 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）；為 系統表格、使用者表格、唯一雜湊索引、雜湊索引、唯一排序索引、排序索引、雜湊索引觸發器、訂閱觸發器、唯讀約束、索引觸發器、重新組織觸發器、表格空間、日誌檔案群組、資料檔案、復原檔案、雜湊映射、外部索引鍵定義、外部索引鍵父觸發器、外部索引鍵子觸發器或 結構描述交易 其中之一。
您也可以在 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)