Method visitInFunction

src/Optimizer/ExpressionInterpreter.cpp:702–799

}

InterpretIMResult ExpressionInterpreter::visitInFunction(const ASTFunction & function, const ConstASTPtr &) const
{
    const auto & left_arg = function.arguments->children[0];
    const auto & right_arg = function.arguments->children[1];
    auto left_arg_result = visit(left_arg);
    auto rewritten_left_arg = left_arg_result.convertToAST(context);
    auto rewritten_in_func = makeASTFunction(function.name, rewritten_left_arg, right_arg);

    if (left_arg_result.isAST() && !setting.enable_function_simplify)
        return {getType(rewritten_in_func), rewritten_in_func};

    if (const auto * ast_prepared_param = right_arg->as<ASTPreparedParameter>())
    {
        auto riget_arg_result = visitASTPreparedParameter(*ast_prepared_param, right_arg);
        ColumnsWithTypeAndName columns_with_types;
        columns_with_types.emplace_back(left_arg_result.value, left_arg_result.type, "");
        columns_with_types.emplace_back(riget_arg_result.value, riget_arg_result.type, "");
        auto overload_resolver = FunctionFactory::instance().tryGet(function.name, context);
        return {overload_resolver->getReturnType(columns_with_types), rewritten_in_func};
    }

    // build set for IN statement(see also ActionsVisitor)
    SetPtr set;
    {
        auto & left_arg_type = left_arg_result.type;
        DataTypes set_element_types = {left_arg_type};
        const auto * left_tuple_type = typeid_cast<const DataTypeTuple *>(left_arg_type.get());
        if (left_tuple_type && left_tuple_type->getElements().size() != 1)
            set_element_types = left_tuple_type->getElements();

        for (auto & element_type : set_element_types)
            if (const auto * low_cardinality_type = typeid_cast<const DataTypeLowCardinality *>(element_type.get()))
                element_type = low_cardinality_type->getDictionaryType();

        Block block;
        auto right_arg_function = std::dynamic_pointer_cast<ASTFunction>(right_arg);
        if (right_arg_function && (right_arg_function->name == "tuple" || right_arg_function->name == "array"))
            block = createBlockForSet(left_arg_type, right_arg_function, set_element_types, context);
        else
            block = createBlockForSet(left_arg_type, right_arg, set_element_types, context);

        const auto & settings = context->getSettingsRef();
        SizeLimits size_limits{settings.max_rows_in_set, settings.max_bytes_in_set, settings.set_overflow_mode};
        set = std::make_shared<Set>(size_limits, true, settings.transform_null_in);
        set->setHeader(block.cloneEmpty());
        set->insertFromBlock(block);
        set->finishInsert();
    }

    // constant folding
    if (left_arg_result.isValue())
    {
        auto column_set = ColumnSet::create(1, set);
        ColumnPtr const_column_set = ColumnConst::create(std::move(column_set), 1);
        ColumnsWithTypeAndName columns_with_types;
        columns_with_types.emplace_back(left_arg_result.value, left_arg_result.type, "");
        columns_with_types.emplace_back(const_column_set, std::make_shared<DataTypeSet>(), "");
        auto result = FunctionInvoker::execute(function.name, columns_with_types, context);