技术分享 | MySQL 字段长度限制的计算方法

通过对报错信息的搜索，其判断方式如下：

/* dict0dict.cc:2515 */
/* Check the size limit on leaf pages. */
if (rec_max_size >= page_rec_max) {
    ib::error_or_warn(strict)
        name
        name
        

其中

/* dict0dict.cc:2431 */
page_rec_max = srv_page_size == UNIV_PAGE_SIZE_MAX
              ? REC_MAX_DATA_SIZE - 1
              : page_get_free_space_of_empty(comp) / 2;

/* srv0srv.cc:222 */
ulong srv_page_size = UNIV_PAGE_SIZE_DEF; 

/* 这个是默认值(DEF)，如果my.cnf中配置page_size为32K，那这个值就是32K */

/* univ.i:343 */
# define UNIV_PAGE_SIZE_DEF    (1 

从上面的源码定义中可以看到：

1.srv_page_size 的默认值为

/*************************************************************//**
Calculates free space if a page is emptied.
@return free space */
UNIV_INLINE
ulint
page_get_free_space_of_empty(
/*=========================*/
    ulint   comp)       /*!

如上所示，

/* 下面是函数 dict_index_too_big_for_tree 中关于  rec_max_size 计算部分的内容 */
/* 涉及到的辅助函数，下面也有相关说明 */

rec_max_size = comp /* comp 为 true */
        ? REC_N_NEW_EXTRA_BYTES  /* rem0rec.h:52:#define REC_N_NEW_EXTRA_BYTES    5 */
        : REC_N_OLD_EXTRA_BYTES; /* rem0rec.h:49:#define REC_N_OLD_EXTRA_BYTES    6 */
                 
rec_max_size += UT_BITS_IN_BYTES(new_index->n_nullable);

/*
这个宏的实现如下：

ut0ut.h:222
#define UT_BITS_IN_BYTES(b) (((b) + 7) / 8)

即 (允许为空的字段个数 + 7) / 8
*/

for (i = 0; i n_fields; i++) {
    const dict_field_t* field
        = dict_index_get_nth_field(new_index, i);
    const dict_col_t*   col
        = dict_field_get_col(field);
    ulint           field_max_size;
    ulint           field_ext_max_size;
    
    /* In dtuple_convert_big_rec(), variable-length columns
    that are longer than BTR_EXTERN_LOCAL_STORED_MAX_SIZE
    may be chosen for external storage.
    
    Fixed-length columns, and all columns of secondary
    index records are always stored inline. */
    
    /* Determine the maximum length of the index field.
    The field_ext_max_size should be computed as the worst
    case in rec_get_converted_size_comp() for
    REC_STATUS_ORDINARY records. */
    
    field_max_size = dict_col_get_fixed_size(col, comp);  

    /* 本质上是判断是否定长，并获得定长字段的字节数*/
    
    /*如果是定长，则直接 goto add_field_size 进行求值*/

    if (field_max_size && field->fixed_len != 0) {
        /* dict_index_add_col() should guarantee this */
        ut_ad(!field->prefix_len
              || field->fixed_len == field->prefix_len);
        /* Fixed lengths are not encoded
        in ROW_FORMAT=COMPACT. */
        field_ext_max_size = 0;
        goto add_field_size;
    }
    
    /*如果是变长，则计算最大值，然后求 field_ext_max_size的长度，
    这个是用户存储字段长度的变量
    这个只是默认初始值，后面会根据长度进行溢出页的设置
    */

    field_max_size = dict_col_get_max_size(col);
    field_ext_max_size = field_max_size prefix_len) { 
    /* 建表判断长度时，直接走else即可，这里会在建立二级索引时用到，但是和聚集索引不是一颗B_Tree，因此可以忽略 */
        if (field->prefix_len prefix_len;
        }
    } else if (field_max_size > BTR_EXTERN_LOCAL_STORED_MAX_SIZE 
           && dict_index_is_clust(new_index)) {
         
    /*
    btr0types.h:56
    #define BTR_EXTERN_LOCAL_STORED_MAX_SIZE    \
             (BTR_EXTERN_FIELD_REF_SIZE * 2)
    
    btr0types.h:53
    #define BTR_EXTERN_FIELD_REF_SIZE   FIELD_REF_SIZE
    
    page0size.h:32
    #define FIELD_REF_SIZE 20
             
    所以这段代码的意思为：
    如果变长字段的最大值大于40 （溢出页指针的2倍），则这个字段在页内
    只保留40个字节，且长度变量设置为1，即总共占用41个字节。*/

    /* In the worst case, we have a locally stored
    column of BTR_EXTERN_LOCAL_STORED_MAX_SIZE bytes.
    The length can be stored in one byte.  If the
    column were stored externally, the lengths in
    the clustered index page would be
    BTR_EXTERN_FIELD_REF_SIZE and 2. */

        field_max_size = BTR_EXTERN_LOCAL_STORED_MAX_SIZE;
        field_ext_max_size = 1;
    }
    
    if (comp) {
        /* Add the extra size for ROW_FORMAT=COMPACT.
        For ROW_FORMAT=REDUNDANT, these bytes were
        added to rec_max_size before this loop. */
        rec_max_size += field_ext_max_size;
    }
    add_field_size:
    rec_max_size += field_max_size;
    
    /* Check the size limit on leaf pages. */
    if (rec_max_size >= page_rec_max) {
        ib::error_or_warn(strict)
            name
            name
            mtype, col->prtype, col->len,
                    col->mbminmaxlen, comp));
    /*
     根据实现，可以简单的计算为：
 1. 定长的为显示指定的 字符数*字符宽度
   - 例如 char(10), 在 utf8mb4 里面，字节为 40
 2. 变长的直接返回0
    */
}

/***********************************************************************//**
Returns the size of a fixed size data type, 0 if not a fixed size type.
@return fixed size, or 0 */
UNIV_INLINE
ulint
dtype_get_fixed_size_low(
/*=====================*/
    ulint    mtype,        /*!mtype, col->len));
}

ulint
dtype_get_max_size_low(
/*===================*/
    ulint   mtype,      /*!

3.2 小结

根据上面计算方式的梳理，在

rec_max_size = 5;
/*
  innodb header 中固定的两个值
  DB_TRX_ID: 6 Byte
  DB_ROLL_PTR: 7 Byte
*/
rec_max_size += 6+7;

/* rem0rec.h:70
# define REC_NODE_PTR_SIZE    4 

dict0dict.cc:2536
rec_max_size + REC_NODE_PTR_SIZE >= page_ptr_max 
*/
rec_max_size += 4; 

rec_max_size += (number_null_field + 7) / 8; /*number_null_field表示允许为null的字段数*/

for (int i = 0; i  40 ? 40 : field.length;
    }
       
    rec_max_size += field_max_size + field_ext_max_size;
}

通过上述计算，需要满足

rec_max_size

四、总结

1.必须在 MySQL Server 层和 InnoDB 层同时满足上述条件，才能建表成功；
2.如果出现上述报错情况，大部分是因为 varchar 等设置过大，建议可以将一些字段逐步缩小，或者用 text 进行代替；

终于介绍完啦！小伙伴们，这篇关于《技术分享 | MySQL 字段长度限制的计算方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布数据库相关知识，快来关注吧！