Pros:
- it is convenient to type and read numbers this way;
- Ada, Perl, C++, Go and Rust already support that;
- can support thousands as well as lakhs and crores;

Cons:
- standard SQL does not have this support;
- PostgreSQL treat `SELECT 1_000_000` as number one with `_000_000` alias: http://sqlfiddle.com/#!17/0a28f/400
- C++ has `1'000'000` instead of `1_000_000`;

What do you think?

throw Exception(ErrorCodes::SYNTAX_ERROR, "lambda requires two arguments");
                const auto * lambda_args_tuple = func->arguments->children.at(0)->as<ASTFunction>();
                if (!lambda_args_tuple || lambda_args_tuple->name != "tuple")
                    throw Exception(ErrorCodes::SYNTAX_ERROR, "First argument of lambda must be a tuple");
                const ASTs & lambda_arg_asts = lambda_args_tuple->arguments->children;
                if (lambda_arg_asts.size() != 1)
                    throw Exception(ErrorCodes::SYNTAX_ERROR, "APPLY column transformer can only accept lambda with one argument");
                if (auto opt_arg_name = tryGetIdentifierName(lambda_arg_asts[0]); opt_arg_name)
                    lambda_arg = *opt_arg_name;
                else
                    throw Exception(ErrorCodes::SYNTAX_ERROR, "lambda argument declarations must be identifiers");
            }
            else
            {
                lambda = nullptr;
                pos = opos;
            }
        }
        if (!lambda)
        {
            if (!ParserIdentifier().parse(pos, func_name, expected))
                return false;
            if (pos->type == TokenType::OpeningRoundBracket)
            {
                ++pos;
                if (!ParserExpressionList(false).parse(pos, expr_list_args, expected))
                    return false;
                if (pos->type != TokenType::ClosingRoundBracket)
                    return false;
                ++pos;