广东技术师范大学-林钡镕-认领成功

一、连接层：从TCP握手到权限校验

1. 连接池初始化（`sql/net_serv.cc`）

服务启动时会调用Connection_pool::init()，这里不只是创建连接，还要初始化内存池和锁机制：

// sql/net_serv.cc
bool Connection_pool::init(uint max_conn) {
  max_connections_ = max_conn;
  // 初始化空闲连接链表（预分配内存，避免动态扩容开销）
  free_connections_.reserve(max_conn);
  // 初始化互斥锁（多线程取连接需同步）
  mysql_mutex_init(key_connection_pool_mutex, &mutex_, MY_MUTEX_INIT_FAST);
  
  // 预创建1/2最大连接数的空闲THD（线程上下文）
  for (uint i = 0; i < max_conn / 2; i++) {
    THD *thd = create_thd();
    if (!thd) return false; // 内存分配失败
    // 标记为空闲状态，加入链表
    thd->set_state(THD::STATE_FREE);
    free_connections_.push_back(thd);
  }
  return true;
}

关键细节：THD结构体里藏了很多核心字段，比如security_ctx（存用户名/主机/权限）、lex（存SQL解析结果）、net（存网络连接信息），后续所有环节都要用到这个上下文！

2. 身份认证（`sql/auth/auth.cc`）

客户端连接后，handle_one_connection()会调用mysql_server_auth()，这里要具体查mysql.user表并比对密码哈希：

// sql/auth/auth.cc
int mysql_server_auth(THD *thd) {
  Security_context *sctx = thd->security_ctx;
  const char *user = sctx->user();
  const char *host = sctx->host();
  const char *passwd = sctx->password(); // 客户端传过来的密码（已加密）

  // 1. 打开mysql.user表（通过存储引擎接口）
  TABLE_LIST tl;
  TABLE *user_table = open_table(
    &tl, "mysql", "user", // 库名+表名
    NULL, 0, // 别名+选项
    O_RDONLY, // 只读模式
    thd,
    NULL
  );
  if (!user_table) return 1; // 表不存在（异常）

  // 2. 查找用户行（WHERE user='xxx' AND host='xxx'）
  KEY *user_host_key = user_table->key_info[0]; // user+host的联合索引
  uchar key_buf[user_host_key->key_len];
  // 构建索引键（拼接user和host的字符串）
  pack_key(user_host_key, key_buf, user, strlen(user), host, strlen(host));
  // 索引查找
  if (user_table->file->ha_index_read(user_table->record[0], key_buf, HA_READ_KEY_EXACT) != 0) {
    send_error(thd, ER_ACCESS_DENIED_ERROR); // 无此用户
    return 1;
  }

  // 3. 比对密码哈希（mysql.user表存的是sha256哈希）
  Field *passwd_field = user_table->field[2]; // password字段
  const char *stored_passwd = passwd_field->val_str(&tmp_str)->ptr();
  if (my_crypt_compare(stored_passwd, passwd) != 0) { // 哈希比对
    send_error(thd, ER_ACCESS_DENIED_ERROR); // 密码错误
    return 1;
  }

  // 4. 加载用户权限（存到THD::security_ctx）
  sctx->load_privileges(user_table);
  return 0;
}

小提示：passwd是客户端用mysql_native_password算法加密后的结果，服务端拿mysql.user里的哈希直接比，避免明文传输

二、解析层：从Token到AST

1. 词法分析（`sql/lex.yy.c`，Flex生成）

yylex()会逐字符扫描SQL，把字符串拆成带类型的Token，比如关键字、标识符、常量：

// sql/lex.yy.c（Flex生成的核心逻辑）
int yylex(YYSTYPE *yylval, THD *thd) {
  Lexer_state *lex = &thd->lex;
  while (1) {
    lex->ptr = lex->current_pos; // 当前扫描位置
    switch (*lex->ptr) {
      // 匹配数字常量（比如1、100）
      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9': {
        char *end;
        // 解析数字（支持int/long/decimal）
        longlong num = my_strtoll10(lex->ptr, &end, 10);
        // 构造常量Token，类型设为INT_CONST
        yylval->type = INT_CONST;
        yylval->value.int_val = num;
        lex->current_pos = end; // 更新扫描位置
        return INT_CONST_TOKEN;
      }

      // 匹配关键字（比如SELECT）
      case 'S': case 's': {
        if (lex->ptr[1] == 'E' || lex->ptr[1] == 'e') {
          if (lex->ptr[2] == 'L' || lex->ptr[2] == 'l') {
            if (lex->ptr[3] == 'E' || lex->ptr[3] == 'e') {
              if (lex->ptr[4] == 'C' || lex->ptr[4] == 'c') {
                if (lex->ptr[5] == 'T' || lex->ptr[5] == 't') {
                  // 确认是SELECT关键字，跳过6个字符
                  lex->current_pos = lex->ptr + 6;
                  yylval->type = KEYWORD;
                  yylval->value.keyword = SELECT;
                  return SELECT_TOKEN;
                }
              }
            }
          }
        }
        // 不是SELECT，按标识符处理
        goto parse_identifier;
      }

    parse_identifier:
      // 解析标识符（比如表名t、列名id）
      char *ident_start = lex->ptr;
      while (isalnum(*lex->ptr) || *lex->ptr == '_') lex->ptr++; // 匹配字母/数字/下划线
      yylval->type = IDENTIFIER;
      yylval->value.str_val = strndup(ident_start, lex->ptr - ident_start);
      lex->current_pos = lex->ptr;
      return IDENTIFIER_TOKEN;
    }
  }
}

细节：Flex会根据.l文件（比如sql/lex.l）的规则生成这段代码，关键字匹配是“前缀逐字符校验”，避免和标识符混淆（比如select123会被当成标识符）。

2. 语法分析（`sql/sql_yacc.yy.c`，Bison生成）

yyparse()会按SQL语法规则（比如select_statement: SELECT select_items FROM table_ref WHERE where_clause）把Token拼成AST，以SELECT * FROM t WHERE id=1为例：

// sql/sql_yacc.yy.c（Bison生成的核心逻辑）
int yyparse(THD *thd) {
  YYSTYPE yylval;
  int token;
  // 初始化AST根节点（SelectStmt）
  SelectStmt *stmt = new (thd->mem_root) SelectStmt(); // 用THD的内存池分配，避免内存泄漏
  thd->lex->current_stmt = stmt;

  // 第一步：匹配SELECT关键字
  token = yylex(&yylval, thd);
  if (token != SELECT_TOKEN) {
    yyerror(thd, "expected SELECT keyword");
    return 1;
  }

  // 第二步：解析查询列（*）
  token = yylex(&yylval, thd);
  if (token == ASTERISK_TOKEN) { // 匹配到*
    // 创建ColumnRef节点，表示“所有列”
    ColumnRef *col = new (thd->mem_root) ColumnRef();
    col->table_name = NULL; // 不指定表，默认当前表
    col->column_name = "*";
    stmt->columns.push_back(col); // 加入SelectStmt的columns列表
  } else {
    yyerror(thd, "expected * or column name");
    return 1;
  }

  // 第三步：匹配FROM关键字+表名t
  token = yylex(&yylval, thd);
  if (token != FROM_TOKEN) { ... }
  token = yylex(&yylval, thd);
  if (token == IDENTIFIER_TOKEN) {
    TableRef *table = new (thd->mem_root) TableRef();
    table->table_name = yylval.value.str_val;
    table->alias = NULL;
    stmt->table_list.push_back(table); // 加入SelectStmt的table_list
  }

  // 第四步：解析WHERE条件（id=1）
  token = yylex(&yylval, thd);
  if (token == WHERE_TOKEN) {
    // 解析条件左侧（id，标识符）
    token = yylex(&yylval, thd);
    ColumnRef *left_col = new (thd->mem_root) ColumnRef();
    left_col->column_name = yylval.value.str_val;

    // 解析运算符（=）
    token = yylex(&yylval, thd);
    BinaryExpr *where_expr = new (thd->mem_root) BinaryExpr();
    where_expr->op = EQ_OP; // 等于运算符

    // 解析条件右侧（1，整数常量）
    token = yylex(&yylval, thd);
    Constant *right_const = new (thd->mem_root) Constant();
    right_const->type = INT_CONST;
    right_const->value.int_val = yylval.value.int_val;

    // 组装BinaryExpr（id = 1）
    where_expr->left = left_col;
    where_expr->right = right_const;
    stmt->where_clause = where_expr; // 绑定到SelectStmt
  }

  return 0; // 语法分析成功
}

关键数据结构：SelectStmt的定义在sql/sql_ast.h，里面的columns是List<ColumnRef>（查询列列表）、table_list是List<TableRef>（表列表）、where_clause是Expr*（条件表达式，这里是BinaryExpr）。

三、优化层：成本计算与执行计划生成

1. 逻辑优化（`sql/sql_optimizer.cc`）

以“谓词下推”和“常量折叠”为例，看optimize_logical_plan()怎么改AST：

// sql/sql_optimizer.cc
void optimize_logical_plan(THD *thd, SelectStmt *stmt) {
  // 1. 谓词下推：把WHERE条件推到表扫描节点
  push_predicate_to_table(stmt->where_clause, stmt->table_list.front());

  // 2. 常量折叠：把表达式里的常量计算提前
  fold_constants_in_expr(stmt->where_clause);
}

// 谓词下推实现：判断条件是否属于目标表，是则绑定到TableRef
void push_predicate_to_table(Expr *expr, TableRef *table) {
  if (!expr || !table) return;

  // 如果是BinaryExpr（比如id=1）
  if (BinaryExpr *bin_expr = dynamic_cast<BinaryExpr*>(expr)) {
    // 检查左操作数是否是当前表的列
    if (ColumnRef *left_col = dynamic_cast<ColumnRef*>(bin_expr->left)) {
      if (left_col->table_name == NULL || strcmp(left_col->table_name, table->table_name) == 0) {
        // 绑定到TableRef的predicate字段，后续扫描时直接用
        table->predicate = expr;
        return;
      }
    }
  }
}

// 常量折叠实现：计算常量表达式（比如1+2→3）
void fold_constants_in_expr(Expr *expr) {
  if (BinaryExpr *bin_expr = dynamic_cast<BinaryExpr*>(expr)) {
    // 递归处理左右子表达式
    fold_constants_in_expr(bin_expr->left);
    fold_constants_in_expr(bin_expr->right);

    // 如果左右都是常量，直接计算结果
    if (Constant *left_const = dynamic_cast<Constant*>(bin_expr->left)) {
      if (Constant *right_const = dynamic_cast<Constant*>(bin_expr->right)) {
        Constant *new_const = new (expr->mem_root) Constant();
        new_const->type = left_const->type;

        // 根据运算符计算
        switch (bin_expr->op) {
          case EQ_OP: new_const->value.bool_val = (left_const->value.int_val == right_const->value.int_val); break;
          case ADD_OP: new_const->value.int_val = left_const->value.int_val + right_const->value.int_val; break;
          // 其他运算符（-、*、<等）
        }

        // 用新常量替换原来的BinaryExpr
        *expr = *new_const;
      }
    }
  }
}

例子：如果SQL是SELECT * FROM t WHERE id=1+2，折叠后where_clause会变成id=3，避免执行时每次都算1+2。

2. 物理优化（`sql/sql_optimizer.cc`）

optimize_physical_plan()会查统计信息算成本，选最优执行方式，核心是“成本公式”和“索引选择”：

// sql/sql_optimizer.cc
PlanNode *optimize_physical_plan(THD *thd, SelectStmt *stmt) {
  TableRef *table = stmt->table_list.front();
  TABLE *mysql_table = table->table; // 对应mysql的表结构
  Table_stats *stats = mysql_table->stats; // 表统计信息

  // 1. 计算全表扫描成本
  double full_scan_cost = 0.0;
  // 全表扫描成本 = 数据页数 * IO成本系数（默认1.0） + 行数 * CPU成本系数（默认0.1）
  full_scan_cost = stats->data_pages * 1.0 + stats->row_count * 0.1;

  // 2. 检查是否有可用索引，计算索引扫描成本
  PlanNode *best_plan = NULL;
  double min_cost = full_scan_cost;
  // 遍历表的所有索引
  for (uint i = 0; i < mysql_table->s->keys; i++) {
    KEY *idx = mysql_table->key_info[i];
    // 检查索引是否包含WHERE条件的列（比如id列的索引）
    if (!is_index_covering_predicate(idx, table->predicate)) {
      continue; // 索引不包含条件列，跳过
    }

    // 计算索引扫描成本
    double index_scan_cost = 0.0;
    // 索引页数量 = 索引总行数 * 索引选择性（比如idx_id的选择性是0.01，10000行→100个索引页）
    uint index_pages = stats->row_count * idx->selectivity;
    // 回表行数 = 匹配条件的行数（比如id=1→1行）
    uint fetch_rows = (uint)(stats->row_count * get_predicate_selectivity(table->predicate));

    // 索引扫描成本 = 索引页IO成本 + 回表IO成本 + CPU成本
    index_scan_cost = index_pages * 0.8 // 索引页IO成本（比数据页低，默认0.8）
                    + fetch_rows * 1.0   // 回表IO成本（每次回表读一个数据页）
                    + fetch_rows * 0.1;  // CPU成本（处理每行数据）

    // 如果索引扫描成本更低，更新最优计划
    if (index_scan_cost < min_cost) {
      min_cost = index_scan_cost;
      // 创建索引扫描计划节点
      if (!best_plan) best_plan = new (thd->mem_root) PlanNode();
      best_plan->type = PLAN_INDEX_SCAN;
      best_plan->index_name = idx->name;
      best_plan->table_name = table->table_name;
      best_plan->predicate = table->predicate;
    }
  }

  // 3. 如果没有更好的索引，选全表扫描
  if (!best_plan) {
    best_plan = new (thd->mem_root) PlanNode();
    best_plan->type = PLAN_FULL_SCAN;
    best_plan->table_name = table->table_name;
    best_plan->predicate = table->predicate;
  }

  return best_plan;
}

统计信息细节：stats->data_pages是表的数据页数（从InnoDB的INFORMATION_SCHEMA.INNODB_TABLES获取），idx->selectivity是索引选择性（1/不同值数量，值越大选择性越好）。

四、执行层：调用存储引擎接口的代码链路

以索引扫描为例，execute_index_scan()会一步步调用handler接口（存储引擎抽象层），核心是“索引键构建→索引查找→回表→投影”：

// sql/sql_executor.cc
bool execute_index_scan(THD *thd, PlanNode *plan) {
  // 1. 获取表和存储引擎句柄（handler是抽象类，这里实际是ha_innodb）
  TABLE *table = find_table(thd, plan->table_name);
  handler *h = table->file; // handler实例，指向ha_innodb对象

  // 2. 构建索引键（比如id=1，按索引列类型打包）
  uchar *index_key = build_index_key(plan->predicate, plan->index_name, table);
  uint key_len = get_index_key_len(plan->index_name, table); // 索引键长度（比如int占4字节）

  // 3. 初始化存储引擎的扫描状态
  if (h->ha_index_init(plan->index_name, true) != 0) { // true表示只读
    send_error(thd, "failed to init index scan");
    return true;
  }

  // 4. 索引查找：精确匹配id=1的行（HA_READ_KEY_EXACT表示精确查找）
  int err = h->ha_index_read(
    h->record[0], // 存储引擎返回的行数据缓冲区（InnoDB的rec_t）
    index_key,    // 索引键
    key_len,      // 键长度
    HA_READ_KEY_EXACT // 查找模式
  );
  if (err != 0) { // 没找到匹配行
    h->ha_index_end();
    return false;
  }

  // 5. 遍历匹配的行（如果有多个结果，比如id>1）
  while (true) {
    // 5.1 检查是否满足WHERE条件（虽然索引已经过滤，但防止边界情况）
    if (!eval_predicate(plan->predicate, h->record[0], table)) {
      goto next_row;
    }

    // 5.2 投影：只保留需要的列（*表示所有列）
    RowData *row = project_row(plan->output_columns, h->record[0], table);
    // 5.3 加入结果集
    thd->result_set->add_row(row);

  next_row:
    // 5.4 读取下一行（HA_READ_NEXT表示按索引顺序读下一个）
    err = h->ha_index_next(h->record[0]);
    if (err == HA_ERR_END_OF_FILE) break; // 没有更多行
    if (err != 0) {
      send_error(thd, "failed to read next row");
      break;
    }
  }

  // 6. 结束扫描，释放资源
  h->ha_index_end();
  return false;
}

// 投影函数：从h->record[0]中提取需要的列
RowData *project_row(List<ColumnRef> &output_cols, uchar *record, TABLE *table) {
  RowData *row = new (table->mem_root) RowData();
  for (ColumnRef *col : output_cols) {
    // 找到列在record中的偏移量（InnoDB的字段偏移存在dict_col_t里）
    Field *field = find_field_in_table(table, col->column_name);
    uint col_offset = field->offset; // 字段在record中的偏移
    // 提取字段值（根据字段类型处理，比如int、varchar）
    void *col_val = (void*)(record + col_offset);
    row->add_column(col_val, field->type);
  }
  return row;
}

关键接口：handler类的ha_index_init()/ha_index_read()/ha_index_next()/ha_index_end()是索引扫描的核心接口，每个存储引擎（InnoDB/MyISAM）都要实现这些虚函数，这就是MySQL的“存储引擎插件化”设计！

五、存储层：InnoDB内核的代码实现（以索引查找为例）

1. 缓冲池查找（`storage/innobase/buf/buf0buf.cc`）

buf_get_page()是InnoDB读取数据页的入口，优先从内存缓冲池拿，没有再读磁盘：

// storage/innobase/buf/buf0buf.cc
buf_page_t *buf_get_page(buf_pool_t *buf_pool, const page_id_t &page_id) {
  buf_page_t *page = NULL;
  mysql_mutex_lock(&buf_pool->mutex); // 缓冲池是全局资源，加锁

  // 1. 哈希表查找：通过page_id（表空间ID+页号）定位缓冲页
  // buf_pool->hash_table是哈希表，每个桶存buf_page_t的链表
  hash_node_t *hash_node = hash_table_lookup(
    buf_pool->hash_table,
    (const uchar*)&page_id,
    sizeof(page_id_t)
  );
  if (hash_node != NULL) {
    page = reinterpret_cast<buf_page_t*>(hash_node);
    // 更新LRU链表：把页面移到LRU头部（标记为热点）
    buf_lru_move_to_head(buf_pool, page);
    mysql_mutex_unlock(&buf_pool->mutex);
    return page;
  }

  // 2. 缓冲池没有该页，需要从磁盘读取
  // 2.1 分配空闲缓冲页（LRU尾部淘汰冷页）
  page = buf_lru_get_free_block(buf_pool);
  if (!page) {
    mysql_mutex_unlock(&buf_pool->mutex);
    return NULL; // 缓冲池满且无法淘汰（异常）
  }

  // 2.2 从磁盘读页到缓冲页的frame（内存地址）
  mysql_mutex_unlock(&buf_pool->mutex); // 读磁盘是IO操作，释放锁
  fil_io_t io;
  io.type = IO_READ;
  io.space = page_id.space; // 表空间ID
  io.page_no = page_id.page_no; // 页号
  io.buf = page->frame; // 目标内存地址（缓冲页的frame字段）
  io.len = UNIV_PAGE_SIZE; // 页大小（默认16KB）
  fil_io(&io); // 调用文件系统接口读页

  // 2.3 把新页加入哈希表和LRU链表
  mysql_mutex_lock(&buf_pool->mutex);
  hash_table_insert(
    buf_pool->hash_table,
    (const uchar*)&page_id,
    sizeof(page_id_t),
    reinterpret_cast<hash_node_t*>(page)
  );
  buf_lru_add_to_head(buf_pool, page); // 新读的页算热点，加LRU头部
  mysql_mutex_unlock(&buf_pool->mutex);

  return page;
}

数据结构：buf_page_t是缓冲页的描述符，里面的frame是16KB的内存缓冲区（存数据页内容），lru_prev/lru_next是LRU链表的指针，hash_prev/hash_next是哈希表的指针。

2. 索引查找与MVCC（`storage/innobase/row/row0sel.cc`）

row_search_mvcc()是InnoDB行查找的核心，负责B+树定位、回表、版本判断：

// storage/innobase/row/row0sel.cc
dberr_t row_search_mvcc(
  uchar *buf,                // 输出：最终的行数据
  const dict_index_t *index, // 目标索引（比如idx_id）
  const uchar *key,          // 索引键（id=1）
  ulint key_len,             // 键长度
  enum lock_mode lock_mode,  // 锁模式（比如LOCK_S/LOCK_X）
  trx_t *trx                 // 当前事务
) {
  buf_page_t *index_page = NULL;
  btr_pcur_t pcur; // B+树游标，用于定位叶子节点
  rec_t *rec = NULL; // 找到的索引记录

  // 1. 定位索引页（通过缓冲池）
  page_id_t index_page_id = {index->space->id, index->root_page_no}; // 索引根页ID
  index_page = buf_get_page(buf_pool, index_page_id);
  if (!index_page) return DB_ERROR;

  // 2. B+树查找：从根页遍历到叶子节点，找到匹配的索引记录
  btr_pcur_open(
    index,          // 索引
    key,            // 索引键
    key_len,        // 键长度
    BTR_SEARCH_EXACT, // 精确查找
    &pcur           // 游标（输出）
  );
  // 从游标获取叶子节点的记录（rec_t是InnoDB的行记录结构）
  rec = btr_pcur_get_rec(&pcur);
  if (!rec) {
    btr_pcur_close(&pcur);
    return DB_RECORD_NOT_FOUND;
  }

  // 3. 回表：如果是二级索引，需要通过主键找聚簇索引页
  if (!dict_index_is_clustered(index)) { // 二级索引（非聚簇索引）
    // 3.1 从二级索引记录中提取主键（rec_t的固定位置存主键）
    uchar *primary_key = rec_get_primary_key(rec, index);
    // 3.2 获取聚簇索引（主键索引）
    const dict_index_t *clust_index = dict_table_get_clust_index(index->table);
    // 3.3 查找聚簇索引页（缓冲池）
    page_id_t clust_page_id = btr_get_page_id(clust_index, primary_key);
    buf_page_t *clust_page = buf_get_page(buf_pool, clust_page_id);
    if (!clust_page) {
      btr_pcur_close(&pcur);
      return DB_ERROR;
    }
    // 3.4 在聚簇索引页中找到完整行记录
    rec = btr_search_clust_rec(clust_page, primary_key);
  }

  // 4. MVCC版本判断：检查当前事务是否能看到这条记录
  if (!row_visible(rec, trx)) {
    btr_pcur_close(&pcur);
    return DB_RECORD_NOT_FOUND; // 记录不可见（比如被未提交事务修改）
  }

  // 5. 加锁（如果是写操作，比如UPDATE/DELETE）
  if (lock_mode != LOCK_NONE) {
    lock_t *lock = lock_acquire(
      index->table, // 表
      rec,          // 记录
      lock_mode     // 锁模式（比如LOCK_X）
    );
    if (!lock) {
      btr_pcur_close(&pcur);
      return DB_LOCK_WAIT; // 锁等待（需要等其他事务释放锁）
    }
  }

  // 6. 把记录复制到输出缓冲区（buf）
  rec_copy(buf, rec, index->table->clust_index);

  // 7. 释放资源
  btr_pcur_close(&pcur);
  return DB_SUCCESS;
}

// MVCC版本判断：核心逻辑
bool row_visible(const rec_t *rec, trx_t *trx) {
  trx_id_t rec_trx_id = rec_get_trx_id(rec); // 记录的事务ID（谁修改的）
  ReadView *rv = trx->read_view; // 当前事务的读视图

  // 规则1：如果记录的事务ID < 读视图的最小活跃事务ID→可见（事务已提交）
  if (rec_trx_id < rv->up_limit_id) {
    return true;
  }

  // 规则2：如果记录的事务ID == 当前事务ID→可见（自己修改的）
  if (rec_trx_id == trx->id) {
    return true;
  }

  // 规则3：如果记录的事务ID在活跃事务列表中→不可见（事务未提交）
  if (ut_is_in_array(rec_trx_id, rv->trx_ids, rv->n_trx_ids)) {
    return false;
  }

  // 规则4：其他情况→可见（事务已提交，且不在活跃列表中）
  return true;
}

关键结构：rec_t是InnoDB的行记录，里面的trx_id字段存最后修改该记录的事务ID，roll_ptr字段存undo log指针（用于回滚）；ReadView是读视图，存up_limit_id（最小活跃事务ID）、low_limit_id（下一个事务ID）、trx_ids（活跃事务ID列表），这是MVCC的核心！

🙏🙏如果有哪里理解错了，或者有更细节的代码想补充，欢迎大家评论！

一、连接层：从TCP握手到权限校验

1. 连接池初始化（sql/net_serv.cc）

2. 身份认证（sql/auth/auth.cc）

二、解析层：从Token到AST

1. 词法分析（sql/lex.yy.c，Flex生成）

2. 语法分析（sql/sql_yacc.yy.c，Bison生成）

文档编写：从代码层面详解一个sql执行的主要流程 #13

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions