AccessPath *path;

// Normally blank. If not blank, a heading for this iterator

// saying what kind of role it has to the parent if it is not

// obvious. E.g., FilterIterator can print iterators that are

// children because they come out of subselect conditions.

std::string description = "";

// If this child is the root of a new JOIN, it is contained here.

JOIN *join = nullptr;

// If it's convenient to assign json fields for this child while creating this

// structure, then a json object can be allocated and set here.

Json_object *obj = nullptr;

Args &&...ctor_args) {

return obj->add_alias(

alias, create_dom_ptr<T, Args...>(std::forward<Args>(ctor_args)...));

Args &&...ctor_args) {

return array->append_alias(

create_dom_ptr<T, Args...>(std::forward<Args>(ctor_args)...));

string *str, const char *json_index_access_type, const char *prefix,

TABLE *table, const KEY *key, const char *index_access_type,

const string lookup_condition, const string *ranges_text,

std::unique_ptr<Json_array> range_arr, bool reverse, Item *pushed_idx_cond,

Json_object *obj) {

string idx_cond_str = pushed_idx_cond ? ItemToString(pushed_idx_cond) : "";

string covering_index =

string(table->key_read ? "Covering index " : "Index ");

bool error = false;

if (prefix) covering_index[0] = tolower(covering_index[0]);

*str += (prefix ? string(prefix) + " " : "") + covering_index +

index_access_type + // lookup/scan/search

" on " + table->alias + " using " + key->name +

(!lookup_condition.empty() ? " (" + lookup_condition + ")" : "") +

(ranges_text != nullptr ? " over " + *ranges_text : "") +

(reverse ? " (reverse)" : "") +

(pushed_idx_cond ? ", with index condition: " + idx_cond_str : "");

*str += table->file->explain_extra();

error |= AddMemberToObject<Json_string>(obj, "access_type", "index");

error |= AddMemberToObject<Json_string>(obj, "index_access_type",

json_index_access_type);

error |= AddMemberToObject<Json_boolean>(obj, "covering", table->key_read);

error |= AddMemberToObject<Json_string>(obj, "table_name", table->alias);

error |= AddMemberToObject<Json_string>(obj, "index_name", key->name);

if (!lookup_condition.empty())

error |= AddMemberToObject<Json_string>(obj, "lookup_condition",

lookup_condition);

if (range_arr) error |= obj->add_alias("ranges", std::move(range_arr));

if (reverse) error |= AddMemberToObject<Json_boolean>(obj, "reverse", true);

if (pushed_idx_cond)

error |= AddMemberToObject<Json_string>(obj, "pushed_index_condition",

idx_cond_str);

if (!table->file->explain_extra().empty())

error |= AddMemberToObject<Json_string>(obj, "message",

table->file->explain_extra());

return error;

switch (join_type) {

case JoinType::INNER:

return "inner join";

case JoinType::OUTER:

return "left join";

case JoinType::ANTI:

return "antijoin";

case JoinType::SEMI:

return "semijoin";

default:

assert(false);

return "<error>";

}

string *explain_json_value) {

switch (join_type) {

case RelationalExpression::INNER_JOIN:

case RelationalExpression::STRAIGHT_INNER_JOIN:

if (explain_json_value)

*explain_json_value = JoinTypeToString(JoinType::INNER);

return "Inner hash join";

case RelationalExpression::LEFT_JOIN:

if (explain_json_value)

*explain_json_value = JoinTypeToString(JoinType::OUTER);

return "Left hash join";

case RelationalExpression::ANTIJOIN:

if (explain_json_value)

*explain_json_value = JoinTypeToString(JoinType::ANTI);

return "Hash antijoin";

case RelationalExpression::SEMIJOIN:

if (explain_json_value)

*explain_json_value = JoinTypeToString(JoinType::SEMI);

return "Hash semijoin";

default:

assert(false);

return "<error>";

}

vector<ExplainChild> *children) {

return WalkItem(

item_arg, enum_walk::POSTFIX, [children, source_text](Item *item) {

if (item->type() != Item::SUBSELECT_ITEM) {

return false;

}

Item_subselect *subselect = down_cast<Item_subselect *>(item);

Query_block *query_block = subselect->unit->first_query_block();

char description[256];

if (query_block->is_dependent()) {

snprintf(description, sizeof(description),

"Select #%d (subquery in %s; dependent)",

query_block->select_number, source_text);

} else if (!query_block->is_cacheable()) {

snprintf(description, sizeof(description),

"Select #%d (subquery in %s; uncacheable)",

query_block->select_number, source_text);

} else {

snprintf(description, sizeof(description),

"Select #%d (subquery in %s; run only once)",

query_block->select_number, source_text);

}

subselect->unit->finalize(current_thd);

AccessPath *path;

if (subselect->unit->root_access_path() != nullptr) {

path = subselect->unit->root_access_path();

} else {

path = subselect->unit->item->root_access_path();

}

Json_object *child_obj = new (std::nothrow) Json_object();

if (child_obj == nullptr) return true;

// Populate the subquery-specific json fields.

bool error = false;

error |= AddMemberToObject<Json_boolean>(child_obj, "subquery", true);

error |= AddMemberToObject<Json_string>(child_obj, "subquery_location",

source_text);

if (query_block->is_dependent())

error |=

AddMemberToObject<Json_boolean>(child_obj, "dependent", true);

if (query_block->is_cacheable())

error |=

AddMemberToObject<Json_boolean>(child_obj, "cacheable", true);

children->push_back({path, description, query_block->join, child_obj});

return error != 0;

});

vector<ExplainChild> *children) {

if (join == nullptr) {

return false;

}

// Look for any Items in the projection list itself.

for (Item *item : *join->get_current_fields()) {

if (GetAccessPathsFromItem(item, "projection", children)) return true;

}

// Look for any Items that were materialized into fields during execution.

for (uint table_idx = join->primary_tables; table_idx < join->tables;

++table_idx) {

QEP_TAB *qep_tab = &join->qep_tab[table_idx];

if (qep_tab != nullptr && qep_tab->tmp_table_param != nullptr) {

for (Func_ptr &func : *qep_tab->tmp_table_param->items_to_copy) {

if (GetAccessPathsFromItem(func.func(), "projection", children))

return true;

}

}

}

return false;

const AccessPath *path, JOIN *join, std::unique_ptr<Json_object> ret_obj,

vector<ExplainChild> *children, bool explain_analyze) {

Json_object *obj = ret_obj.get();

bool error = false;

MaterializePathParameters *param = path->materialize().param;

/*

const bool explain_cte_now = param->cte != nullptr && [&]() {

if (explain_analyze) {

/*

if (path->iterator == nullptr ||

path->iterator->GetProfiler()->GetNumInitCalls() == 0) {

// If the CTE was never materialized, print it at the first reference.

return param->table == param->cte->tmp_tables[0]->table &&

std::none_of(param->cte->tmp_tables.cbegin(),

param->cte->tmp_tables.cend(),

[](const Table_ref *tab) {

return tab->table->materialized;

});

} else {

// The CTE was materialized here, print it now with cost data.

return true;

}

} else {

// If we do not want cost data, print the plan at the first reference.

return param->table == param->cte->tmp_tables[0]->table;

}

}();

const bool is_set_operation = param->query_blocks.size() > 1;

string str;

const bool doing_dedup = MaterializeIsDoingDeduplication(param->table);

if (param->cte != nullptr) {

error |= AddMemberToObject<Json_boolean>(obj, "cte", true);

if (param->cte->recursive) {

error |= AddMemberToObject<Json_boolean>(obj, "recursive", true);

str = "Materialize recursive CTE " + to_string(param->cte->name);

} else {

if (is_set_operation) {

str = "Materialize union CTE " + to_string(param->cte->name);

error |= AddMemberToObject<Json_boolean>(obj, "union", true);

} else {

str = "Materialize CTE " + to_string(param->cte->name);

}

if (param->cte->tmp_tables.size() > 1) {

str += " if needed";

if (!explain_cte_now) {

// See children().

str += " (query plan printed elsewhere)";

}

}

}

} else if (is_set_operation) {

if (param->table->is_union_or_table()) {

if (doing_dedup) {

str = "Union materialize";

} else {

str = "Union all materialize";

}

error |= AddMemberToObject<Json_boolean>(obj, "union", true);

} else {

if (param->table->is_except()) {

if (param->table->is_distinct()) {

str = "Except materialize";

} else {

str = "Except all materialize";

}

error |= AddMemberToObject<Json_boolean>(obj, "except", true);

} else {

if (param->table->is_distinct()) {

str = "Intersect materialize";

} else {

str = "Intersect all materialize";

}

error |= AddMemberToObject<Json_boolean>(obj, "intersect", true);

}

}

} else if (param->rematerialize) {

error |= AddMemberToObject<Json_boolean>(obj, "temp_table", true);

str = "Temporary table";

} else {

str = "Materialize";

}

const bool union_dedup = param->table->is_union_or_table() && doing_dedup;

if (union_dedup ||

(!param->table->is_union_or_table() && param->table->is_distinct())) {

error |= AddMemberToObject<Json_boolean>(obj, "deduplication", true);

str += " with deduplication";

} // else: do not print deduplication for intersect, except

if (param->invalidators != nullptr) {

std::unique_ptr<Json_array> cache_invalidators(new (std::nothrow)

Json_array());

if (cache_invalidators == nullptr) return nullptr;

bool first = true;

str += " (invalidate on row from ";

for (const AccessPath *invalidator : *param->invalidators) {

if (!first) {

str += "; ";

}

first = false;

str += invalidator->cache_invalidator().name;

error |= AddElementToArray<Json_string>(

cache_invalidators, invalidator->cache_invalidator().name);

}

str += ")";

error |=

obj->add_alias("cache_invalidators", std::move(cache_invalidators));

}

error |= AddMemberToObject<Json_string>(obj, "operation", str);

/* Move the Materialize to the bottom of its table path, and return a new

ret_obj = AssignParentPath(path->materialize().table_path, path,

std::move(ret_obj), join);

// Children.

// If a CTE is referenced multiple times, only bother printing its query plan

// once, instead of repeating it over and over again.

//

// TODO(sgunders): Consider printing CTE query plans on the top level of the

// query block instead?

if (param->cte != nullptr && !explain_cte_now) {

return (error ? nullptr : std::move(ret_obj));

}

char heading[256] = "";

if (param->limit_rows != HA_POS_ERROR) {

// We call this “Limit table size” as opposed to “Limit”, to be able

// to distinguish between the two in EXPLAIN when debugging.

if (MaterializeIsDoingDeduplication(param->table)) {

snprintf(heading, sizeof(heading), "Limit table size: %llu unique row(s)",

param->limit_rows);

} else {

snprintf(heading, sizeof(heading), "Limit table size: %llu row(s)",

param->limit_rows);

}

}

// We don't list the table iterator as an explicit child; we mark it in

// our description instead. (Anything else would look confusingly much

// like a join.)

for (const MaterializePathParameters::QueryBlock &query_block :

param->query_blocks) {

string this_heading = heading;

if (query_block.disable_deduplication_by_hash_field) {

if (this_heading.empty()) {

this_heading = "Disable deduplication";

} else {

this_heading += ", disable deduplication";

}

}

if (!param->table->is_union_or_table() &&

(param->table->is_except() && param->table->is_distinct()) &&

query_block.m_operand_idx > 0 &&

(query_block.m_operand_idx < query_block.m_first_distinct)) {

if (this_heading.empty()) {

this_heading = "Disable deduplication";

} else {

this_heading += ", disable deduplication";

}

}

if (query_block.is_recursive_reference) {

if (this_heading.empty()) {

this_heading = "Repeat until convergence";

} else {

this_heading += ", repeat until convergence";

}

}

children->push_back(

{query_block.subquery_path, this_heading, query_block.join});

}

return (error ? nullptr : std::move(ret_obj));

AccessPath *table_path, const AccessPath *materialized_path,

std::unique_ptr<Json_object> materialized_obj, JOIN *join) {

// We don't want to include the SELECT subquery list in the parent path;

// Let them get printed in the actual root node. So is_root_of_join=false.

std::unique_ptr<Json_object> table_obj = ExplainAccessPath(

table_path, materialized_path, join, /*is_root_of_join=*/false);

if (table_obj == nullptr) return nullptr;

/* Get the bottommost object from the new object tree. */

Json_object *bottom_obj = table_obj.get();

while (bottom_obj->get("inputs") != nullptr) {

Json_dom *children = bottom_obj->get("inputs");

assert(children->json_type() == enum_json_type::J_ARRAY);

Json_array *children_array = down_cast<Json_array *>(children);

bottom_obj = down_cast<Json_object *>((*children_array)[0]);

}

/* Place the input object as a child of the bottom-most object */

std::unique_ptr<Json_array> children(new (std::nothrow) Json_array());

if (children == nullptr ||

children->append_alias(std::move(materialized_obj)))

return nullptr;

if (bottom_obj->add_alias("inputs", std::move(children))) return nullptr;

return table_obj;

const AccessPath *path,

JOIN *join [[maybe_unused]],

string *description) {

TABLE *table = path->index_skip_scan().table;

KEY *key_info = table->key_info + path->index_skip_scan().index;

string ranges;

IndexSkipScanParameters *param = path->index_skip_scan().param;

// Print out any equality ranges.

bool first = true;

std::unique_ptr<Json_array> range_arr(new (std::nothrow) Json_array());

if (range_arr == nullptr) return true;

for (unsigned key_part_idx = 0; key_part_idx < param->eq_prefix_key_parts;

++key_part_idx) {

if (!first) {

ranges += ", ";

}

first = false;

string range = param->index_info->key_part[key_part_idx].field->field_name;

string range_short_text;

Bounds_checked_array<unsigned char *> prefixes =

param->eq_prefixes[key_part_idx].eq_key_prefixes;

if (prefixes.size() == 1) {

range += " = ";

String out;

print_key_value(&out, &param->index_info->key_part[key_part_idx],

prefixes[0]);

range += to_string(out);

} else {

range += " IN (";

for (unsigned i = 0; i < prefixes.size(); ++i) {

if (i == 2 && prefixes.size() > 3) {

range_short_text =

range + StringPrintf(", (%zu more))", prefixes.size() - 2);

}

if (i != 0) {

range += ", ";

}

String out;

print_key_value(&out, &param->index_info->key_part[key_part_idx],

prefixes[i]);

range += to_string(out);

}

range += ")";

}

if (AddElementToArray<Json_string>(range_arr, range)) return true;

// For IN clause above, we have made range_short_text; so use that if it's

// available, rather than the full string stored in 'range'.

ranges += (range_short_text.empty() ? range : range_short_text);

}

// Then the ranges.

if (!first) {

ranges += ", ";

}

String out;

append_range(&out, param->range_key_part, param->min_range_key,

param->max_range_key, param->range_cond_flag);

ranges += to_string(out);

if (AddElementToArray<Json_string>(range_arr, to_string(out))) return true;

// NOTE: Currently, index skip scan is always covering, but there's no

// good reason why we cannot fix this limitation in the future.

return SetIndexInfoInObject(

description, "index_skip_scan", nullptr, table, key_info, "skip scan",

/*lookup condition*/ "", &ranges, std::move(range_arr), /*reverse*/ false,

/*push_condition*/ nullptr, obj);

const AccessPath *path,

JOIN *join [[maybe_unused]],

string *description) {

TABLE *table = path->group_index_skip_scan().table;

KEY *key_info = table->key_info + path->group_index_skip_scan().index;

GroupIndexSkipScanParameters *param = path->group_index_skip_scan().param;

string ranges;

bool error = false;

std::unique_ptr<Json_array> range_arr(new (std::nothrow) Json_array());

if (range_arr == nullptr) return true;

// Print out prefix ranges, if any.

if (!param->prefix_ranges.empty()) {

error |= PrintRanges(param->prefix_ranges.data(),

param->prefix_ranges.size(), key_info->key_part,

/*single_part_only=*/false, range_arr, &ranges);

}

// Print out the ranges on the MIN/MAX keypart, if we have them.

// (We don't print infix ranges, because they seem to be in an unusual

// format.)

if (!param->min_max_ranges.empty()) {

if (!param->prefix_ranges.empty()) {

ranges += ", ";

}

error |= PrintRanges(param->min_max_ranges.data(),

param->min_max_ranges.size(), param->min_max_arg_part,

/*single_part_only=*/true, range_arr, &ranges);

}

// NOTE: Currently, group index skip scan is always covering, but there's no

// good reason why we cannot fix this limitation in the future.

error |= SetIndexInfoInObject(

description, "group_index_skip_scan", nullptr, table, key_info,

(param->min_max_arg_part ? "skip scan for grouping"

: "skip scan for deduplication"),

/*lookup condition*/ "", (!ranges.empty() ? &ranges : nullptr),

std::move(range_arr),

/*reverse*/ false, /*push_condition*/ nullptr, obj);

return error;

vector<ExplainChild> *children) {

/*

Item *pushed_cond = const_cast<Item *>(table->file->pushed_cond);

if (pushed_cond != nullptr) {

if (GetAccessPathsFromItem(pushed_cond, "pushed condition", children))

return true;

}

return false;

const KEY_PART_INFO *key_part, bool single_part_only,

const std::unique_ptr<Json_array> &range_array,

string *ranges_out) {

string range, shortened_range;

for (unsigned range_idx = 0; range_idx < num_ranges; ++range_idx) {

if (range_idx == 2 && num_ranges > 3) {

char str[256];

snprintf(str, sizeof(str), " OR (%u more)", num_ranges - 2);

// Save the shortened version for TREE format.

shortened_range = range + str;

}

if (range_idx > 0) range += " OR ";

String str;

if (single_part_only) {

// key_part is the part we are printing on,

// and we have to ignore min_keypart_map / max_keypart_map,

// so we cannot use append_range_to_string().

append_range(&str, key_part, ranges[range_idx]->min_key,

ranges[range_idx]->max_key, ranges[range_idx]->flag);

} else {

// NOTE: key_part is the first keypart in the key.

append_range_to_string(ranges[range_idx], key_part, &str);

}

range += "(" + to_string(str) + ")";

}

if (AddElementToArray<Json_string>(range_array, range)) return true;

*ranges_out = (shortened_range.empty() ? range : shortened_range);

return false;

const vector<ExplainChild> &children,

JOIN *parent_join, bool parent_is_root_of_join,

string alias) {

if (children.empty()) return false;

std::unique_ptr<Json_array> children_json(new (std::nothrow) Json_array());

if (children_json == nullptr) return true;

for (const ExplainChild &child : children) {

JOIN *subjoin = child.join != nullptr ? child.join : parent_join;

bool child_is_root_of_join =

subjoin != parent_join || parent_is_root_of_join;

std::unique_ptr<Json_object> child_obj = ExplainAccessPath(

child.path, nullptr, subjoin, child_is_root_of_join, child.obj);

if (child_obj == nullptr) return true;

if (!child.description.empty()) {

if (AddMemberToObject<Json_string>(child_obj.get(), "heading",

child.description))

return true;

}

if (children_json->append_alias(std::move(child_obj))) return true;

}

return obj->add_alias(alias, std::move(children_json));

const AccessPath *path, THD::Query_plan const *query_plan, JOIN *join,

bool is_root_of_join) {

string dml_desc;

std::unique_ptr<Json_object> obj = nullptr;

/* Create a Json object for the SELECT path */

if (path != nullptr) {

obj = ExplainAccessPath(path, nullptr, join, is_root_of_join);

if (obj == nullptr) return nullptr;

}

if (query_plan != nullptr) {

switch (query_plan->get_command()) {

case SQLCOM_INSERT_SELECT:

case SQLCOM_INSERT:

dml_desc = string("Insert into ") +

query_plan->get_lex()->insert_table_leaf->table->alias;

break;

case SQLCOM_REPLACE_SELECT:

case SQLCOM_REPLACE:

dml_desc = string("Replace into ") +

query_plan->get_lex()->insert_table_leaf->table->alias;

break;

default:

// SELECTs have no top-level node.

break;

}

}

/* If there is a DML node, add it on top of the SELECT plan */

if (!dml_desc.empty()) {

std::unique_ptr<Json_object> dml_obj(new (std::nothrow) Json_object());

if (dml_obj == nullptr) return nullptr;

if (AddMemberToObject<Json_string>(dml_obj.get(), "operation", dml_desc))

return nullptr;

/* There might not be a select plan. E.g. INSERT ... VALUES() */

if (obj != nullptr) {

std::unique_ptr<Json_array> children(new (std::nothrow) Json_array());

if (children == nullptr || children->append_alias(std::move(obj)))

return nullptr;

if (dml_obj->add_alias("inputs", std::move(children))) return nullptr;

}

obj = std::move(dml_obj);

}

return obj;

const AccessPath *materialized_path, Json_object *obj,

bool explain_analyze) {

const AccessPath *const table_path = path->type == AccessPath::MATERIALIZE

? path->materialize().table_path

: nullptr;

double cost;

/*

if (materialized_path == nullptr) {

if (table_path == nullptr) {

cost = std::max(0.0, path->cost);

} else {

assert(path->materialize().subquery_cost >= 0.0);

cost = path->materialize().subquery_cost +

kMaterializeOneRowCost * path->num_output_rows();

}

} else {

assert(materialized_path->cost >= 0.0);

cost = materialized_path->cost;

}

bool error = false;

if (path->num_output_rows() >= 0.0) {

// Calculate first row cost

double init_cost;

if (materialized_path == nullptr) {

if (table_path == nullptr) {

init_cost = path->init_cost;

} else {

init_cost = cost;

}

} else {

init_cost = materialized_path->init_cost;

}

if (init_cost >= 0.0) {

double first_row_cost;

if (path->num_output_rows() <= 1.0) {

first_row_cost = cost;

} else {

first_row_cost =

init_cost + (cost - init_cost) / path->num_output_rows();

}

error |= AddMemberToObject<Json_double>(obj, "estimated_first_row_cost",

first_row_cost);

}

error |= AddMemberToObject<Json_double>(obj, "estimated_total_cost", cost);

error |= AddMemberToObject<Json_double>(obj, "estimated_rows",

path->num_output_rows());

} /* if (path->num_output_rows() >= 0.0) */

/* Add analyze figures */

if (explain_analyze) {

int num_init_calls = 0;

if (path->iterator != nullptr) {

const IteratorProfiler *const profiler = path->iterator->GetProfiler();

if ((num_init_calls = profiler->GetNumInitCalls()) != 0) {

error |= AddMemberToObject<Json_double>(

obj, "actual_first_row_ms",

profiler->GetFirstRowMs() / profiler->GetNumInitCalls());

error |= AddMemberToObject<Json_double>(

obj, "actual_last_row_ms",

profiler->GetLastRowMs() / profiler->GetNumInitCalls());

error |= AddMemberToObject<Json_double>(

obj, "actual_rows",

static_cast<double>(profiler->GetNumRows()) / num_init_calls);

error |=

AddMemberToObject<Json_int>(obj, "actual_loops", num_init_calls);

}

}

if (num_init_calls == 0) {

error |= AddMemberToObject<Json_null>(obj, "actual_first_row_ms");

error |= AddMemberToObject<Json_null>(obj, "actual_last_row_ms");

error |= AddMemberToObject<Json_null>(obj, "actual_rows");

error |= AddMemberToObject<Json_null>(obj, "actual_loops");

}

}

return error;

std::unique_ptr<Json_object> ret_obj, const AccessPath *path,

const AccessPath *materialized_path, JOIN *join,

vector<ExplainChild> *children) {

bool error = false;

string description;

// The obj to be returned might get changed when processing some of the

// paths. So keep a handle to the original object, in case we later add any

// more fields.

Json_object *obj = ret_obj.get();

/* Get path-specific info, including the description string */

switch (path->type) {

case AccessPath::TABLE_SCAN: {

TABLE *table = path->table_scan().table;

description += string("Table scan on ") + table->alias;

if (table->s->is_secondary_engine()) {

error |= AddMemberToObject<Json_string>(obj, "secondary_engine",

table->file->table_type());

description +=

string(" in secondary engine ") + table->file->table_type();

}

description += table->file->explain_extra();

error |= AddMemberToObject<Json_string>(obj, "table_name", table->alias);

error |= AddMemberToObject<Json_string>(obj, "access_type", "table");

if (!table->file->explain_extra().empty())

error |= AddMemberToObject<Json_string>(obj, "message",

table->file->explain_extra());

error |= AddChildrenFromPushedCondition(table, children);

break;

}

case AccessPath::INDEX_SCAN: {

TABLE *table = path->index_scan().table;

assert(table->file->pushed_idx_cond == nullptr);

const KEY *key = &table->key_info[path->index_scan().idx];

error |= SetIndexInfoInObject(&description, "index_scan", nullptr, table,

key, "scan",

/*lookup condition*/ "", /*range*/ nullptr,

nullptr, path->index_scan().reverse,

/*push_condition*/ nullptr, obj);

error |= AddChildrenFromPushedCondition(table, children);

break;

}

case AccessPath::REF: {

TABLE *table = path->ref().table;

const KEY *key = &table->key_info[path->ref().ref->key];

error |= SetIndexInfoInObject(

&description, "index_lookup", nullptr, table, key, "lookup",

RefToString(*path->ref().ref, key, /*include_nulls=*/false),

/*ranges=*/nullptr, nullptr, path->ref().reverse,

table->file->pushed_idx_cond, obj);

error |= AddChildrenFromPushedCondition(table, children);

break;

}

case AccessPath::REF_OR_NULL: {

TABLE *table = path->ref_or_null().table;

const KEY *key = &table->key_info[path->ref_or_null().ref->key];

error |= SetIndexInfoInObject(

&description, "index_lookup", nullptr, table, key, "lookup",

RefToString(*path->ref_or_null().ref, key, /*include_nulls=*/true),

/*ranges=*/nullptr, nullptr, false, table->file->pushed_idx_cond,

obj);

error |= AddChildrenFromPushedCondition(table, children);

break;