Method tupleContains

src/Functions/FunctionSQLJSON.h:1252–1311

    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName &) const override { return std::make_shared<DataTypeUInt8>(); }

    bool tupleContains(const ColumnsWithTypeAndName & compare_columns) const
    {
        auto target_column = compare_columns[0];
        auto candidate_column = compare_columns[1];

        if (isTuple(target_column.type) && isTuple(candidate_column.type))
        {
            const auto & target_tuple_column = assert_cast<const ColumnTuple &>(*target_column.column);
            const auto & target_tuple_type = assert_cast<const DataTypeTuple &>(*target_column.type);


            const auto & candidate_tuple_column = assert_cast<const ColumnTuple &>(*candidate_column.column);
            const auto & candidate_type_tuple = assert_cast<const DataTypeTuple &>(*candidate_column.type);

            const auto & candidate_tuple_element_names = candidate_type_tuple.getElementNames();
            const auto & candidate_tuple_elements = candidate_type_tuple.getElements();

            const auto & target_tuple_element_names = target_tuple_type.getElementNames();
            const auto & target_tuple_elements = target_tuple_type.getElements();

            bool contains_all = false;
            for (size_t i = 0; i < candidate_tuple_element_names.size(); i++)
            {
                auto candidate_tuple_element_name = candidate_tuple_element_names[i];
                bool contains = false;
                for (size_t j = 0; j < target_tuple_element_names.size(); j++)
                {
                    auto target_tuple_element_name = target_tuple_element_names[j];
                    if (candidate_tuple_element_name == target_tuple_element_name)
                    {
                        contains = tupleContains(
                            {{target_tuple_column.getColumnPtr(j), target_tuple_elements[j], "_dummy"},
                             {candidate_tuple_column.getColumnPtr(i), candidate_tuple_elements[i], "_dummy"}});
                    }
                }

                if (!contains)
                {
                    contains_all = false;
                    break;
                }
                else
                {
                    contains_all = true;
                }
            }

            return contains_all;
        }
        else if (
            (isArray(target_column.type) && isArray(candidate_column.type))
            || (isNumberOrString(target_column.type) && isNumberOrString(candidate_column.type)))
        {
            auto compare_result_column
                = func_compare->build(compare_columns)->execute(compare_columns, std::make_shared<DataTypeUInt8>(), 1);
            return compare_result_column->getBool(0);
        }