Hi! We have replication mysql to clickhouse configured with materialized-mysql driver.

sometimes strange behavior happens 

and in the clickhouse there are values that are not in this mysql database

for example: 

mysql revenue value is 0.292, but in clickhouse - 2147483648.292

mysql table ddl:
```
CREATE TABLE `adsense` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `date` date NOT NULL,
  `sub1` varchar(40) DEFAULT NULL,
  `sub2` varchar(255) DEFAULT NULL,
  `lead_id` int DEFAULT NULL,
  `revenue` decimal(10,3) unsigned NOT NULL,
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `idx_adsense_sub1` (`sub1`),
  KEY `idx_adsense_lead_id` (`lead_id`),
  KEY `adsense_sub2_index` (`sub2`),
  KEY `adsense_date_index` (`date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
```

clickhouse table ddl:
```
create table adsense
(
    id              UInt64,
    date            Date,
    sub1            Nullable(String),
    sub2            Nullable(String),
    lead_id         Nullable(Int32),
    clicks          Int32,
    revenue         Decimal(10, 3),
    created_at      DateTime,
    _sign           Int8 materialized 1,
    _version        UInt64 materialized 1
)
    engine = MaterializeMySQL(_version)
        PARTITION BY intDiv(id, 18446744073709551)
        ORDER BY (date, assumeNotNull(sub2), assumeNotNull(sub1),
                  assumeNotNull(lead_id), id)
        SETTINGS index_granularity = 8192;
```


static constexpr size_t digits_per_integer = 9;
                            static const size_t compressed_bytes_map[] = {0, 1, 1, 2, 2, 3, 3, 4, 4, 4};
                            static const size_t compressed_integer_align_numbers[] = {
                                0x0, 0xFF, 0xFF, 0xFFFF, 0xFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
                            UInt32 mask = 0;
                            DecimalType res(0);
                            if ((*payload.position() & 0x80) == 0)
                                mask = UInt32(-1);
                            *payload.position() ^= 0x80;
                            {
                                size_t integral = (precision - scale);
                                size_t uncompressed_integers = integral / digits_per_integer;
                                size_t compressed_integers = integral - (uncompressed_integers * digits_per_integer);
                                
                                if (compressed_integers != 0)
                                {
                                    UInt32 val = 0;
                                    size_t to_read = compressed_bytes_map[compressed_integers];
                                    readBigEndianStrict(payload, reinterpret_cast<char *>(&val), to_read);
                                    res += (val ^ (mask & compressed_integer_align_numbers[compressed_integers]));
                                }
                                for (auto k = 0U; k < uncompressed_integers; k++)
                                {
                                    UInt32 val = 0;
                                    readBigEndianStrict(payload, reinterpret_cast<char *>(&val), 4);
                                    res *= intExp10OfSize<DecimalType>(digits_per_integer);
                                    res += (val ^ mask);
                                }
                            }
                            {