1、整體介紹
對于 select * from table 中的星號，我們再熟悉不過了：它告訴 MySQL 返回表所有字段的內容。
MySQL 服務端收到 select 語句之后，會在 server 層把星號展開為表中的所有字段，然后告訴存儲引擎返回這些字段的內容。
對于存儲引擎來說，它只需要按照 server 層的要求返回指定字段的內容即可，它不知道（也不需要知道）客戶端是要求返回表中所有字段，還是部分字段的內容。
select * 中的星號展開為表中所有字段涉及 2 個階段：
- 詞法 & 語法分析階段：標記 select 字段列表中包含幾個星號。
- 查詢準備階段：把星號展開為表中所有字段。
2、源碼分析
（1）Item_asterisk::itemize()
// sql/item.cc
bool Item_asterisk::itemize(Parse_context *pc, Item **res) {
...
pc->select->with_wild++;
return false;
}
多表連接時，select 字段列表中可能會包含多個星號，詞法 & 語法分析階段，每碰到 select 字段列表中的一個星號，Item_asterisk::itemize() 就會給 pc->select->with_wild 屬性加 1。
pc->select 是 Query_block 對象的指針，定義如下：
// sql/parse_tree_node_base.h
struct Parse_context {
...
Query_block *select; ///< Current Query_block object
...
};
后面 Query_block::prepare() 訪問的 with_wild 屬性就是這里的 pc->select->with_wild。
（2）Query_block::prepare()
// sql/sql_resolver.cc
bool Query_block::prepare(THD *thd, mem_root_deque<Item *> *insert_field_list) {
...
if (with_wild && setup_wild(thd)) return true;
...
}
prepare() 方法中，關于 select * 的邏輯比較簡單，就這一行。
如果 with_wild 大于 0，則調用 setup_wild(thd)，處理 select 字段列表中星號展開為表中所有字段的邏輯。
（3）Query_block::setup_wild()
// sql/sql_resolver.cc
bool Query_block::setup_wild(THD *thd) {
...
// 從 select 字段列表中的第 1 個字段開始處理
// 滿足 2 個條件中的任意一個就結束循環：
// 1. with_wild > 0 為 false，
// 說明已處理完所有星號，結束循環
// 2. it != fields.end() 為 false，
// 說明已經處理了所有字段，結束循環
for (auto it = fields.begin(); with_wild > 0 && it != fields.end(); ++it) {
Item *item = *it;
// item->hidden = true
// 表示 select 字段列表中的這個字段
// 是查詢優化器給【偷偷】加上的
// 肯定不會是星號，直接跳過
if (item->hidden) continue;
Item_field *item_field;
// Item::FIELD_ITEM 說明當前循環的字段
// 是個普通字段，不是函數、子查詢等
// 那它就有可能是星號，需要通過 item_field->is_asterisk()
// 進一步判斷是否是星號
if (item->type() == Item::FIELD_ITEM &&
(item_field = down_cast<Item_field *>(item)) &&
// 如果 item_field 對應的字段是星號
// item_field->is_asterisk() 會返回 true
item_field->is_asterisk()) {
assert(item_field->field == nullptr);
// 只有 create view as ... 中的 select 語句
// any_privileges 為 true
// 其它情況下，它的值為 false
// insert_fields() 方法中會用到
const bool any_privileges = item_field->any_privileges;
// 如果當前 Query_block 對應的是子查詢
// master_query_expression()->item
// 指向主查詢中該子查詢所屬的 where 條件
Item_subselect *subsel = master_query_expression()->item;
...
// 當前 Query_block 是 exists 子查詢
// 并且子查詢中不包含 having 子句
// 則可以把子查詢中的星號替換為常量
if (subsel && subsel->substype() == Item_subselect::EXISTS_SUBS &&
!having_cond()) {
...
*it = new Item_int(NAME_STRING("Not_used"), 1,
MY_INT64_NUM_DECIMAL_DIGITS);
} else {
// 不滿足 if 中的條件
// 則需要調用 insert_fields()
// 把星號展開為表中所有字段
assert(item_field->context == &this->context);
if (insert_fields(thd, this, item_field->db_name,
item_field->table_name, &fields, &it, any_privileges))
return true;
}
// 每處理完 select 字段列表中的一個星號
// with_wild 就減 1
// 減到 0 之后，就說明所有星號都已經處理過了
with_wild--;
}
}
return false;
}
Query_block::setup_wild() 的主體邏輯是迭代 select 字段列表中的每個字段，遇到星號就處理，不是星號就忽略，星號的處理邏輯有 2 種：
第 1 種：滿足 if (subsel && ...) 條件，說明 select 語句是 where 條件中的 exists 子查詢，并且子查詢中不包含 having 子句。這種場景下，select 字段列表中的星號可以被替換為常量，而不需要展開為表的所有字段。
*it = new Item_int(...)? 創建了一個代表常量的字段對象，字段名為 Not_used?，字段值為 1，用于替換 select 字段列表中的星號。
這種場景的示例 SQL 如下：
select st1, i1 from t1 where exists(
select * from t2 where t1.i1 = t2.i1
)
子查詢只需要判斷 t2 表中是否存在滿足 t1.i1 = t2.i1 的記錄，而不需要讀取 t2 表的所有字段，因為讀取了所有字段，也用不上，純屬浪費，所以，星號也就可以被替換成常量了。替換之后的 SQL 相當于這樣：
select st1, i1 from t1 where exists(
select 1 from t2 where t1.i1 = t2.i1
)
實際上，子查詢執行過程中，server 層會要求存儲引擎返回 t2 表的 i1 字段內容，用于判斷 t2 表中是否存在滿足 t1.i1 = t2.i1? 的記錄。這個邏輯是 server 層自主實現的，和 ?select * 中的星號展開為表中所有字段的邏輯不相關，我們知道有這個邏輯就可以，不展開介紹了。
第 2 種：不滿足 if (subsel && ...)? 條件，就需要調用 insert_fields()，把 select 字段列表中的星號展開為表的所有字段。
（4）insert_fields()
// sql/sql_base.cc
bool insert_fields(THD *thd, Query_block *query_block, const char *db_name,
const char *table_name, mem_root_deque<Item *> *fields,
mem_root_deque<Item *>::iterator *it, bool any_privileges) {
...
bool found = false;
Table_ref *tables;
// 按照 select 語句中表的出現順序
// 初始化表的迭代器
Tables_in_user_order_iterator user_it;
user_it.init(query_block, table_name != nullptr);
while (true) {
// 從迭代器中獲取下一個需要處理的表
tables = user_it.get_next();
// tables == nullptr 說明迭代結束，結束循環
if (tables == nullptr) break;
// 表中的字段迭代器
Field_iterator_table_ref field_iterator;
TABLE *const table = tables->table;
assert(tables->is_leaf_for_name_resolution());
// if 進行 2 個條件判斷，任何一個不滿足則跳過當前表：
// 1. table_name 不為 NULL 說明星號前面指定了表名
// 比較星號前面的表名和當前迭代的表名是否相同
// 2. db_name 不為 NULL 說明星號前面指定了數據庫名
// 比較星號前面的數據庫名和當前迭代的表所屬的數據庫名是否相同
if ((table_name &&
my_strcasecmp(table_alias_charset, table_name, tables->alias)) ||
(db_name && strcmp(tables->db, db_name)))
continue;
// 以下 2 種情況都滿足，需要檢查
// 當前連接用戶是否有表中所有字段的 select 權限：
// 1. !any_privileges 為 true
// 說明當前 select 語句
// 不是 create view as ... 中的 select 語句
// 2. 當前連接用戶沒有表的 select 權限，
if (!any_privileges && !(tables->grant.privilege & SELECT_ACL)) {
field_iterator.set(tables);
if (check_grant_all_columns(thd, SELECT_ACL, &field_iterator))
return true;
}
...
// 初始化字段迭代器
field_iterator.set(tables);
// 迭代當前表的每一個字段
for (; !field_iterator.end_of_fields(); field_iterator.next()) {
// 根據字段對象創建 Item
Item *const item = field_iterator.create_item(thd);
if (!item) return true; /* purecov: inspected */
assert(item->fixed);
...
// found 的初始值為 false，
// 表示這是表中第 1 個字段
// 用該字段的 Item 對象替換星號的 Item 對象
if (!found) {
found = true;
**it = item; /* Replace '*' with the first found item. */
} else {
// 表中第 2 個及以后的字段時，
// Item 對象賦值給 it + 1 指向的位置
// 也就是加入了 select 字段列表
/* Add 'item' to the SELECT list, after the current one. */
*it = fields->insert(*it + 1, item);
}
...
}
}
...
insert_fields() 的主要邏輯如下：
按照 select 語句中表的出現順序迭代每個表，每迭代一個表，都會判斷該表名和星號前面的表名（如果有）是否相同，以及該表所屬的數據庫名和星號前面的數據庫名是否相同（如果有）。
如果當前迭代的表名、表所屬的數據庫名和星號前面的表名、數據庫名都相同，接下來會進行訪問權限檢查。
如果當前連接用戶有表的 select 權限，說明它對表中的所有列都有查詢權限，否則，需要調用 check_grant_all_columns(...)，檢查它對表中每一個字段是否有 select 權限。
通過權限檢查之后，就開始迭代表中的每個字段，每迭代一個字段，都根據該字段構造一個 Item 對象，并把 Item 對象加入 select 字段列表。
3、總結
select * 中的星號展開為表中所有字段涉及詞法 & 語法分析階段、查詢準備階段，總結如下：
- 迭代 select 字段列表中的每個字段。
- 碰到星號會判斷是否需要展開為表的所有字段。
- 如果需要展開，則按照 select 語句中表的出現順序迭代每個表。
- 迭代每個表時，檢查當前連接用戶是否有該表或表中所有字段的 select 權限。
- 通過權限檢查之后，把當前迭代的表的字段逐個加入 select 字段列表。
本文轉載自微信公眾號「一樹一溪」，可以通過以下二維碼關注。轉載本文請聯系一樹一溪公眾號。
