#include "sql/join_optimizer/make_join_hypergraph.h"

#include <assert.h>

#include <stddef.h>

#include <algorithm>

#include <array>

#include <iterator>

#include <numeric>

#include <string>

#include <utility>

#include <vector>

#include "limits.h"

#include "mem_root_deque.h"

#include "my_alloc.h"

#include "my_bit.h"

#include "my_inttypes.h"

#include "my_sys.h"

#include "my_table_map.h"

#include "mysqld_error.h"

#include "sql/current_thd.h"

#include "sql/item.h"

#include "sql/item_cmpfunc.h"

#include "sql/item_func.h"

#include "sql/join_optimizer/access_path.h"

#include "sql/join_optimizer/bit_utils.h"

#include "sql/join_optimizer/common_subexpression_elimination.h"

#include "sql/join_optimizer/cost_model.h"

#include "sql/join_optimizer/estimate_selectivity.h"

#include "sql/join_optimizer/find_contained_subqueries.h"

#include "sql/join_optimizer/hypergraph.h"

#include "sql/join_optimizer/print_utils.h"

#include "sql/join_optimizer/relational_expression.h"

#include "sql/join_optimizer/subgraph_enumeration.h"

#include "sql/nested_join.h"

#include "sql/sql_class.h"

#include "sql/sql_const.h"

#include "sql/sql_executor.h"

#include "sql/sql_lex.h"

#include "sql/sql_optimizer.h"

#include "sql/table.h"

#include "template_utils.h"

using hypergraph::Hyperedge;

using hypergraph::Hypergraph;

using hypergraph::NodeMap;

using std::array;

using std::max;

using std::min;

using std::string;

using std::swap;

using std::vector;

namespace {

RelationalExpression *MakeRelationalExpressionFromJoinList(

THD *thd, const mem_root_deque<Table_ref *> &join_list);

bool EarlyNormalizeConditions(THD *thd, RelationalExpression *join,

Mem_root_array<Item *> *conditions,

bool *always_false);

inline bool IsMultipleEquals(Item *cond) {

return cond->type() == Item::FUNC_ITEM &&

down_cast<Item_func *>(cond)->functype() == Item_func::MULT_EQUAL_FUNC;

}

Item_func_eq *MakeEqItem(Item *a, Item *b,

Item_equal *source_multiple_equality) {

Item_func_eq *eq_item = new Item_func_eq(a, b);

eq_item->set_cmp_func();

eq_item->update_used_tables();

eq_item->quick_fix_field();

eq_item->source_multiple_equality = source_multiple_equality;

return eq_item;

}

int CountTablesInEquiJoinCondition(Item *cond) {

}

void ReorderConditions(Mem_root_array<Item *> *condition_parts) {

}

void ExpandSameTableFromMultipleEquals(Item_equal *equal,

}

Item *EarlyExpandMultipleEquals(Item *condition, table_map tables_in_subtree) {

return CompileItem(

condition, [](Item *) { return true; },

[tables_in_subtree](Item *item) -> Item * {

if (!IsMultipleEquals(item)) {

return item;

}

Item_equal *equal = down_cast<Item_equal *>(item);

List<Item> eq_items;

// If this condition is a constant, do the evaluation

// and add a "false" condition if needed.

// This cannot be skipped as optimize_cond() expects

// the value stored in "cond_false" to be checked for

// Item_equal before creating equalities from it.

// We do not need to check for the const item evaluating

// to be "true", as that could happen only when const table

// optimization is used (It is currently not done for

// hypergraph).

if (equal->const_item() && !equal->val_int()) {

eq_items.push_back(new Item_func_false);

} else if (equal->const_arg() != nullptr) {

// If there is a constant element, do a simple expansion.

for (Item_field &field : equal->get_fields()) {

if (IsSubset(field.used_tables(), tables_in_subtree)) {

eq_items.push_back(MakeEqItem(&field, equal->const_arg(), equal));

}

}

} else if (my_count_bits(equal->used_tables() & tables_in_subtree) >

2) {

// Only look at partial expansion.

ExpandSameTableFromMultipleEquals(equal, tables_in_subtree,

&eq_items);

eq_items.push_back(equal);

} else {

// Prioritize expanding equalities from the same table if possible;

// e.g., if we have t1.a = t2.a = t2.b, we want to have t2.a = t2.b

// included (ie., not t1.a = t2.a AND t1.a = t2.b). The primary reason

// for this is that such single-table equalities will be pushable

// as table filters, and not left on the joins. This means we avoid an

// issue where we have a hypergraph cycle where the edge we do not

// follow (and thus ignore) has more join conditions than we skip,

// causing us to wrongly “forget” constraining one degree of freedom.

//

// Thus, we first pick out every equality that touches only one table,

// and then link one equality from each table into an arbitrary one.

//

// It's not given that this will always give us the fastest possible

// plan; e.g. if there's a composite index on (t1.a, t1.b), it could

// be faster to use it for lookups against (t2.a, t2.b) instead of

// pushing t1.a = t1.b. But it doesn't seem worth it to try to keep

// multiple such variations around.

ExpandSameTableFromMultipleEquals(equal, tables_in_subtree,

&eq_items);

table_map included_tables = 0;

Item_field *base_item = nullptr;

for (Item_field &field : equal->get_fields()) {

assert(IsSingleBitSet(field.used_tables()));

if (!IsSubset(field.used_tables(), tables_in_subtree) ||

Overlaps(field.used_tables(), included_tables)) {

continue;

}

included_tables |= field.used_tables();

if (base_item == nullptr) {

base_item = &field;

continue;

}

eq_items.push_back(MakeEqItem(base_item, &field, equal));

// Since we have at most two tables, we can have only one link.

break;

}

}

assert(!eq_items.is_empty());

return CreateConjunction(&eq_items);

});

}

RelationalExpression *MakeRelationalExpression(THD *thd, const Table_ref *tl) {

if (tl->nested_join == nullptr) {

// A single table.

RelationalExpression *ret = new (thd->mem_root) RelationalExpression(thd);

ret->type = RelationalExpression::TABLE;

ret->table = tl;

ret->tables_in_subtree = tl->map();

ret->join_conditions_pushable_to_this.init(thd->mem_root);

return ret;

} else {

// A join or multijoin.

return MakeRelationalExpressionFromJoinList(thd, tl->nested_join->m_tables);

}

}

RelationalExpression *MakeRelationalExpressionFromJoinList(

THD *thd, const mem_root_deque<Table_ref *> &join_list) {

assert(!join_list.empty());

RelationalExpression *ret = nullptr;

for (auto it = join_list.rbegin(); it != join_list.rend();

++it) { // The list goes backwards.

const Table_ref *tl = *it;

if (ret == nullptr) {

// The first table in the list.

ret = MakeRelationalExpression(thd, tl);

continue;

}

RelationalExpression *join = new (thd->mem_root) RelationalExpression(thd);

join->left = ret;

if (tl->is_sj_or_aj_nest()) {

join->right =

MakeRelationalExpressionFromJoinList(thd, tl->nested_join->m_tables);

join->type = tl->is_sj_nest() ? RelationalExpression::SEMIJOIN

: RelationalExpression::ANTIJOIN;

} else {

join->right = MakeRelationalExpression(thd, tl);

if (tl->outer_join) {

join->type = RelationalExpression::LEFT_JOIN;

} else if (tl->straight) {

join->type = RelationalExpression::STRAIGHT_INNER_JOIN;

} else {

join->type = RelationalExpression::INNER_JOIN;

}

}

join->tables_in_subtree =

join->left->tables_in_subtree | join->right->tables_in_subtree;

if (tl->is_aj_nest()) {

assert(tl->join_cond_optim() != nullptr);

}

if (tl->join_cond_optim() != nullptr) {

Item *join_cond = EarlyExpandMultipleEquals(tl->join_cond_optim(),

join->tables_in_subtree);

ExtractConditions(join_cond, &join->join_conditions);

bool always_false = false;

EarlyNormalizeConditions(thd, join, &join->join_conditions,

&always_false);

ReorderConditions(&join->join_conditions);

}

ret = join;

}

return ret;

}

void ComputeCompanionSets(RelationalExpression *expr, int current_set,

}

void CreateInnerJoinFromChildList(

}

void FlattenInnerJoins(RelationalExpression *expr) {

}

void UnflattenInnerJoins(RelationalExpression *expr) {

}

RelationalExpression *PartiallyUnflattenJoinForCondition(

table_map used_tables, RelationalExpression *expr) {

Mem_root_array<RelationalExpression *> affected_children(

current_thd->mem_root);

for (RelationalExpression *child : expr->multi_children) {

if (Overlaps(used_tables, child->tables_in_subtree) ||

Overlaps(used_tables, RAND_TABLE_BIT)) {

affected_children.push_back(child);

}

}

assert(affected_children.size() > 1);

if (affected_children.size() == expr->multi_children.size()) {

// We need all of the nodes, so replace ourself entirely.

CreateInnerJoinFromChildList(std::move(affected_children), expr);

return expr;

}

RelationalExpression *new_expr =

new (current_thd->mem_root) RelationalExpression(current_thd);

new_expr->companion_set = expr->companion_set;

CreateInnerJoinFromChildList(std::move(affected_children), new_expr);

// Insert the new node as one of the children, and take out

// the ones we've moved down into it.

auto new_end =

std::remove_if(expr->multi_children.begin(), expr->multi_children.end(),

[used_tables](const RelationalExpression *child) {

return Overlaps(used_tables, child->tables_in_subtree) ||

Overlaps(used_tables, RAND_TABLE_BIT);

});

expr->multi_children.erase(new_end, expr->multi_children.end());

expr->multi_children.push_back(new_expr);

return new_expr;

}

string PrintRelationalExpression(RelationalExpression *expr, int level) {

}

bool IsNullRejecting(const RelationalExpression &expr, table_map tables) {

}

bool IsInnerJoin(RelationalExpression::Type type) {

}

bool OperatorsAreAssociative(const RelationalExpression &a,

}

bool OperatorsAreLeftAsscom(const RelationalExpression &a,

}

bool OperatorsAreRightAsscom(const RelationalExpression &a,

}

enum class AssociativeRewritesAllowed { ANY, RIGHT_ONLY, LEFT_ONLY };

table_map UsedTablesForCondition(const RelationalExpression &expr) {

}

table_map CertainlyUsedTablesForCondition(const RelationalExpression &expr) {

}

int CompanionSetUsedByCondition(

}

bool IsCandidateForCycle(RelationalExpression *expr, Item *cond,

}

bool ComesFromMultipleEquality(Item *item, Item_equal *equal) {

return is_function_of_type(item, Item_func::EQ_FUNC) &&

down_cast<Item_func_eq *>(item)->source_multiple_equality == equal;

}

int FindSourceMultipleEquality(Item *item,

}

bool MultipleEqualityAlreadyExistsOnJoin(Item_equal *equal,

}

bool AlreadyExistsOnJoin(Item *cond, const RelationalExpression &expr) {