Method getQueryTreeData

src/Storages/ConstraintsDescription.cpp:187–255

}

ConstraintsDescription::QueryTreeData ConstraintsDescription::getQueryTreeData(const ContextPtr & context, const QueryTreeNodePtr & table_node) const
{
    QueryTreeData data;
    std::vector<Analyzer::CNFAtomicFormula> atomic_constraints_data;

    QueryAnalysisPass pass(table_node);

    for (const auto & constraint : filterConstraints(ConstraintsDescription::ConstraintType::ALWAYS_TRUE))
    {
        auto expr = constraint->as<ASTConstraintDeclaration>()->expr->ptr();
        // Wrap the scalar expression with a function call "equals(SELECT..., 1)".
        if (dynamic_cast<ASTSubquery *>(expr.get()))
        {
            auto func = make_intrusive<ASTFunction>();
            func ->name = "equals";
            func->children.push_back(make_intrusive<ASTExpressionList>());
            auto args = make_intrusive<ASTExpressionList>();
            args->children.push_back(expr);
            args->children.push_back(make_intrusive<ASTLiteral>(Field{static_cast<UInt8>(1)}));
            func->arguments = args;
            expr = func;
        }
        auto query_tree = buildQueryTree(expr, context);
        pass.run(query_tree, context);

        const auto cnf = Analyzer::CNF::toCNF(query_tree, context)
            .pullNotOutFunctions(context);
        for (const auto & group : cnf.getStatements())
        {
            data.cnf_constraints.emplace_back(group.begin(), group.end());

            if (group.size() == 1)
                atomic_constraints_data.emplace_back(*group.begin());
        }

        data.constraints.push_back(std::move(query_tree));
    }

    for (size_t i = 0; i < data.cnf_constraints.size(); ++i)
        for (size_t j = 0; j < data.cnf_constraints[i].size(); ++j)
            data.query_node_to_atom_ids[data.cnf_constraints[i][j].node_with_hash].push_back({i, j});

    /// build graph
    if (constraints.empty())
    {
        data.graph = std::make_unique<ComparisonGraph<QueryTreeNodePtr>>(QueryTreeNodes(), context);
    }
    else
    {
        static const NameSet relations = { "equals", "less", "lessOrEquals", "greaterOrEquals", "greater" };

        QueryTreeNodes constraints_for_graph;
        for (const auto & atomic_formula : atomic_constraints_data)
        {
            Analyzer::CNFAtomicFormula atom{atomic_formula.negative, atomic_formula.node_with_hash.node->clone()};
            atom = Analyzer::CNF::pushNotIntoFunction(atom, context);

            auto * function_node = atom.node_with_hash.node->as<FunctionNode>();