Updating a Nullable column value by using alter .... where ... causes to set another value!

ClickHouse version: 20.6.3.28
Engine: MergeTree
OS: Ubuntu 18.04.3 LTS

Steps to reproduce:
```sql
CREATE TABLE table1(
	id int,
	price Nullable(Int32)
)
ENGINE = MergeTree()
PARTITION BY id
ORDER BY (id);
INSERT INTO table1 (id, price) VALUES (1, 100);
ALTER TABLE table1  update price = 150 where id=1;
SELECT * FROM table1;
```
We expect the price to be `150`, but it's `93148480`:

```
┌─id─┬────price─┐
│  1 │ 93148480 │
└────┴──────────┘
```
Using `Decimal(9,2)` field instead of `Int32` would set the value  `932342.88` always. It seems there's a fixed value for each data type.

If we don't use such a `where` clause, it works correctly:
```sql
ALTER TABLE db1.table1  update price = 150 where 1=1;
┌─id─┬─price─┐
│  1 │   150 │
└────┴───────┘
```
{
        if constexpr (is_POD)
            data.protect();
    }
    void insertValue(const T value)
    {
        data.push_back(value);
    }
    template <class U>
    constexpr int compareAtOther(size_t n, size_t m, const ColumnVector<U> & rhs, int nan_direction_hint) const
    {
        return CompareHelper<T, U>::compare(data[n], rhs.data[m], nan_direction_hint);
    }
    
    int compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_direction_hint) const override
    {
        return CompareHelper<T>::compare(data[n], static_cast<const Self &>(rhs_).data[m], nan_direction_hint);
    }
    void compareColumn(const IColumn & rhs, size_t rhs_row_num,
                       PaddedPODArray<UInt64> * row_indexes, PaddedPODArray<Int8> & compare_results,
                       int direction, int nan_direction_hint) const override
    {
        return this->template doCompareColumn<Self>(static_cast<const Self &>(rhs), rhs_row_num, row_indexes,
                                                    compare_results, direction, nan_direction_hint);
    }
    void getPermutation(bool reverse, size_t limit, int nan_direction_hint, IColumn::Permutation & res) const override;
    void getSpecialPermutation(bool reverse, size_t limit, int nan_direction_hint, IColumn::Permutation & res,
                               IColumn::SpecialSort) const override;
    void updatePermutation(bool reverse, size_t limit, int nan_direction_hint, IColumn::Permutation & res, EqualRanges& equal_range) const override;
    void reserve(size_t n) override