Method executeImpl

src/Functions/FunctionSQLJSON.h:1428–1578

    }

    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
    {
        //Only support Object JSON
        bool has_nothing_argument = false;
        for (const auto & arg : arguments)
            has_nothing_argument |= isNothing(arg.type);

        if (arguments.empty())
            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Function {} requires at least one argument", Name::name);

        // TODO: add logic to handle single argument
        if (arguments.size() < 2)
        {
            throw Exception{"JSONPath functions require at least 2 arguments", ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION};
        }

        const auto & json_column = arguments[0];
        auto first_type_base = removeNullable(removeLowCardinality(json_column.type));

        bool is_string = isString(first_type_base);
        bool is_object = isObject(first_type_base);
        bool is_tuple = isTuple(first_type_base);

        if (!is_string && !is_object && !is_tuple)
            throw Exception(
                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
                "The first argument of function {} should be a string containing Object or Tuple or JSON, illegal type: {}",
                Name::name,
                json_column.type->getName());

        const auto & candidate = arguments[1];
        if (!isColumnConst(*candidate.column))
            throw Exception("Second argument (Candidate) must be constant", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);

        MutableColumnPtr to{result_type->createColumn()};
        to->reserve(input_rows_count);

        ASTPtr res;
        if (arguments.size() == 3)
        {
            const auto & json_path_column = arguments[2];

            if (!isString(json_path_column.type))
            {
                throw Exception(
                    "JSONPath functions require third argument to be JSONPath of type string, illegal type: "
                        + json_path_column.type->getName(),
                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
            }

            if (!isColumnConst(*json_path_column.column))
            {
                throw Exception("Third argument (JSONPath) must be constant string", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
            }

            const ColumnPtr & arg_jsonpath = json_path_column.column;
            const auto * arg_jsonpath_const = typeid_cast<const ColumnConst *>(arg_jsonpath.get());
            const auto * arg_jsonpath_string = typeid_cast<const ColumnString *>(arg_jsonpath_const->getDataColumnPtr().get());