MySQL 写入记录到连接缓冲区代码分析

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1241 行
 4uint len= pack_length;
 5
 6// 1250 ~ 1265 行
 7if (blobs)
 8{
 9  CACHE_FIELD **copy_ptr= blob_ptr;
10  CACHE_FIELD **copy_ptr_end= copy_ptr+blobs;
11  for ( ; copy_ptr < copy_ptr_end; copy_ptr++)
12  {
13    Field_blob *blob_field= (Field_blob *) (*copy_ptr)->field;
14    if (!blob_field->is_null())
15    {
16      uint blob_len= blob_field->get_length();
17      (*copy_ptr)->blob_length= blob_len;
18      // blob 字段内容的长度加到 len
19      len+= blob_len;
20      // 把 blob_field->ptr 中保存的指向 blob 字段内容的首地址赋值给 (*copy_ptr)->str
21      blob_field->get_ptr(&(*copy_ptr)->str);
22    }
23  }
24}

1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
2
3// 1277 行
4bool last_record= (len+pack_length_with_blob_ptrs) > rem_space();

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1284 ~ 1289 行
 4uchar *rec_len_ptr= NULL;
 5if (with_length)
 6{
 7  // 把写入记录长度的址址记下来
 8  rec_len_ptr= cp;
 9  // 然后指针移动到记录长度最后一个字节之后的位置
10  cp+= size_of_rec_len;
11}

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1295 ~ 1299 行
 4if (prev_cache)
 5{
 6  // 获取要存储前一个缓冲区中的记录的 Offset，需要多少字节
 7  cp+= prev_cache->get_size_of_rec_offset();
 8  // link 是关联的前一个缓冲区中的记录的首地址，在 store_rec_ref() 中会转换成 Offset
 9  // 然后把 Offset 存储到当前记录中存储 Offet 的内存空间中
10  // 上面 cp 加上了 size_of_rec_offset 的值，那么 cp 指针就指向了存储 Offset 的内存空间的末尾处了
11  // 因为在 store_rec_ref() 中有相应的处理，能够保证把 Offset 存放到正确的位置上
12  prev_cache->store_rec_ref(cp, link);
13}

1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
2
3// 1301 行
4// curr_rec_pos 是 JOIN_CACHE 对象的属性
5curr_rec_pos= cp;

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1304 ~ 1314 行
 4CACHE_FIELD *copy= field_descr;
 5if (with_match_flag)
 6  *copy[0].str= 0;
 7
 8/* First put into the cache the values of all flag fields */
 9CACHE_FIELD *copy_end= field_descr+flag_fields;
10for ( ; copy < copy_end; copy++)
11{
12  memcpy(cp, copy->str, copy->length);
13  cp+= copy->length;
14} 

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1320 ~ 1327 行
 4Field *field= copy->field;
 5if (field && field->maybe_null() && field->is_null())
 6{
 7  /* Do not copy a field if its value is null */
 8  if (copy->referenced_field_no)
 9    copy->offset= 0;
10  continue;              
11}

1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
2
3// 1329 ~ 1330 行
4if (copy->referenced_field_no)
5  copy->offset= cp-curr_rec_pos;

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1322 ~ 1351 行
 4if (copy->type == CACHE_BLOB)
 5{
 6  Field_blob *blob_field= (Field_blob *) copy->field;
 7  if (last_record)
 8  {
 9    last_rec_blob_data_is_in_rec_buff= 1;
10    /* Put down the length of the blob and the pointer to the data */
11    // copy->length 是 blob 字段内容的长度占用的字节数
12    // sizeof(char *) 是 blob 字段内容指针占用的字段数
13    // 对于连接缓冲区中的最后一条记录，只拷贝 blob 字段内容的长度、内容的首地址到连接缓冲区
14    blob_field->get_image(cp, copy->length+sizeof(char*),
15                                blob_field->charset());
16    cp+= copy->length+sizeof(char*);
17  }
18  else
19  {
20    /* First put down the length of the blob and then copy the data */
21    // 如果记录不是连接缓冲区的最后一条记录
22    // 先把 blob 字段内容的长度拷贝到连接缓冲区
23    blob_field->get_image(cp, copy->length,
24              blob_field->charset());
25    // 再从 copy->str 中拷贝 blob 字段内容到连接缓冲区
26    // blob_field->ptr 中保存着 blob 字段内容的长度、内容的首地址
27    // copy->str 中保存着 blob 内容的首地址          
28    memcpy(cp+copy->length, copy->str, copy->blob_length);
29    cp+= copy->length+copy->blob_length;
30  }
31}

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1354 ~ 1387 行
 4switch (copy->type) {
 5case CACHE_VARSTR1:
 6  /* Copy the significant part of the short varstring field */ 
 7  // copy->str[0] 是字段内容的长度，1 表示存储字段内容的长度占用 1 字节
 8  // len = 字段内容长度 + 存储字段内容长度占用的字节数
 9  len= (uint) copy->str[0] + 1;
10  // 拷贝字段内容长度、字段内容到连接缓冲区
11  memcpy(cp, copy->str, len);
12  cp+= len;
13  break;
14case CACHE_VARSTR2:
15  // copy->str[0] 是字段内容的长度，2 表示存储字段内容的长度占用 2 字节
16  // len = 字段内容长度 + 存储字段内容长度占用的字节数
17  /* Copy the significant part of the long varstring field */
18  len= uint2korr(copy->str) + 2;
19  // 拷贝字段内容长度、字段内容到连接缓冲区
20  memcpy(cp, copy->str, len);
21  cp+= len;
22  break;
23case CACHE_STRIPPED:
24{
25  /* 
26    Put down the field value stripping all trailing spaces off.
27    After this insert the length of the written sequence of bytes.
28  */ 
29  uchar *str, *end;
30  // 指针从内容尾部往前移动，计算出尾部空格的数量
31  // 不从内容头部往后移动，是基于这样的假设的：
32  // 使用 CHAR、BINARY 字段时，内容尾部补充空格的数量是小于内容数量的
33  // 这样从尾部往前移动，可以用更少的循环次数计算出尾部数量的空格
34  for (str= copy->str, end= str+copy->length;
35       end > str && end[-1] == ' ';
36       end--) ;
37  len=(uint) (end-str);
38  // 把实现内容长度写入连接缓冲区
39  int2store(cp, len);
40  memcpy(cp+2, str, len);
41  cp+= len+2;
42  break;
43}
44default:      
45  /* Copy the entire image of the field from the record buffer */
46  memcpy(cp, copy->str, copy->length);
47  cp+= copy->length;
48}

 1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
 2
 3// 1392 ~ 1405 行
 4if (referenced_fields)
 5{
 6  uint cnt= 0;
 7  for (copy= field_descr+flag_fields; copy < copy_end ; copy++)
 8  {
 9    if (copy->referenced_field_no)
10    {
11      store_fld_offset(cp+size_of_fld_ofs*(copy->referenced_field_no-1),
12                       copy->offset);
13      cnt++;
14    }
15  }
16  cp+= size_of_fld_ofs*cnt;
17}

1// sql/sql_join_buffer.cc JOIN_CACHE::write_record_data()
2
3// 1407 ~ 1411 行
4if (rec_len_ptr)
5  store_rec_length(rec_len_ptr, (ulong) (cp-rec_len_ptr-size_of_rec_len));
6last_rec_pos= curr_rec_pos; 
7end_pos= pos= cp;
8*is_full= last_record;

 1// sql/sql_join_buffer.cc JOIN_CACHE::set_constants()
 2
 3// 410 ~ 450 行
 4// 以下代码中删掉了源码中的注释
 5void JOIN_CACHE::set_constants()
 6{ 
 7  with_length= is_key_access() || with_match_flag;
 8  uint len= length + fields*sizeof(uint)+blobs*sizeof(uchar *) +
 9            (prev_cache ? prev_cache->get_size_of_rec_offset() : 0) +
10            sizeof(ulong) + aux_buffer_min_size();
11  buff_size= max<size_t>(join->thd->variables.join_buff_size, 2*len);
12  size_of_rec_ofs= offset_size(buff_size);
13  size_of_rec_len= blobs ? size_of_rec_ofs : offset_size(len); 
14  size_of_fld_ofs= size_of_rec_len;
15  pack_length= (with_length ? size_of_rec_len : 0) +
16               (prev_cache ? prev_cache->get_size_of_rec_offset() : 0) + 
17               length;
18  pack_length_with_blob_ptrs= pack_length + blobs*sizeof(uchar *);
19
20  check_only_first_match= calc_check_only_first_match(qep_tab);
21}