**If we use nested case when expression, it may store data with wrong data type.**

> How to reproduce

- release version: 21.13.1.1 
- execute following sql with clickhouse client:

```sql
 SELECT "number", CASE "number"
          WHEN 3 THEN 55
          WHEN 6 THEN 77
          WHEN 9 THEN 95
          ELSE CASE
          WHEN "number"=1 THEN 10
          WHEN "number"=10 THEN 100
          ELSE 555555
          END
          END AS "LONG_COL_0"
         FROM `system`.numbers
         LIMIT 20;
```

- it will get wrong result. (35 should be 555555)

```shell
SELECT
    number,
    caseWithExpression(number, 3, 55, 6, 77, 9, 95, multiIf(number = 1, 10, number = 10, 100, 555555)) AS LONG_COL_0
FROM system.numbers
LIMIT 20

Query id: a713aa47-68d0-4a22-abd8-256fbcdcb073

┌─number─┬─LONG_COL_0─┐
│      0 │         35 │
│      1 │         10 │
│      2 │         35 │
│      3 │         55 │
│      4 │         35 │
│      5 │         35 │
│      6 │         77 │
│      7 │         35 │
│      8 │         35 │
│      9 │         95 │
│     10 │        100 │
│     11 │         35 │
│     12 │         35 │
│     13 │         35 │
│     14 │         35 │
│     15 │         35 │
│     16 │         35 │
│     17 │         35 │
│     18 │         35 │
│     19 │         35 │
└────────┴────────────┘
```

It seems use **UInt8** data type to store number 555555.
But if we use nested **multiIf** expression, result will be correct.
Can u help to resolve **case when expression** problem?
{
public:
    static constexpr auto name = "caseWithExpression";
    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionCaseWithExpression>(context_); }
    explicit FunctionCaseWithExpression(ContextPtr context_) : context(context_) {}
    bool isVariadic() const override { return true; }
    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & ) const override { return false; }
    size_t getNumberOfArguments() const override { return 0; }
    String getName() const override { return name; }
    DataTypePtr getReturnTypeImpl(const DataTypes & args) const override
    {
        if (args.empty())
            throw Exception{"Function " + getName() + " expects at least 1 arguments",
                ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION};
        
        
        
        DataTypes dst_array_types;
        for (size_t i = 2; i < args.size() - 1; i += 2)
            dst_array_types.push_back(args[i]);
        return getLeastSupertype(dst_array_types);
    }
    ColumnPtr executeImpl(const ColumnsWithTypeAndName & args, const DataTypePtr & result_type, size_t input_rows_count) const override