Имеется Materialized база, данные реплицируюся нормально, в базе данные есть

Если выполнить запрос

```
SELECT 
    DISTINCT P.id, 
    P.name, 
    P.catalog_id
FROM products P 
WHERE 
    P.name ILIKE '%Легкие%'
```

То получим результат:

`   |name                                                                                                |catalog_id|brand_id|
---|----------------------------------------------------------------------------------------------------|----------|--------|
915|Подвеска "Легкие"                                                                                   |      5287|   15837|
990|Кроссовки/Кроссовки текстильные/Кроссовки женские летние/кроссовки легкие/Кроссовки спортивные      |      1053|   24390|
781|Брюки женские / Брюки прямые / Легкие брюки на резинке                                              |      1041|    1176|`

Но если в запрос добавить AND catalog_id = N

```
SELECT 
    DISTINCT P.id, 
    P.name, 
    P.catalog_id
FROM products P 
WHERE 
    P.name ILIKE '%Легкие%' AND P.catalog_id = 5287;
```

Или же так:

```
SELECT 
    DISTINCT P.id, 
    P.name, 
    P.catalog_id,
    P.brand_id 
FROM products P 
WHERE 
    P.catalog_id = 5287 AND P.brand_id = 15837;
```

То получаю ошибки

```
SQL Error [10]: ClickHouse exception, code: 10, Code: 10, e.displayText() = DB::Exception: Not found column equals(catalog_id, 5287) in block: while executing 'INPUT : 1 -> equals(catalog_id, 5287) UInt8 : 1' (version 21.3.4.25 (official build))
```

```
SQL Error [10]: ClickHouse exception, code: 10, Code: 10, e.displayText() = DB::Exception: Not found column equals(brand_id, 15837) in block: while executing 'INPUT : 0 -> equals(brand_id, 15837) UInt8 : 0' (version 21.3.4.25 (official build))
```

Почему так происходит? как выйти из этой ситуации?

Структура
```
CREATE TABLE analyzer.products
(

    `id` Int32,

    `product_id` Int32,

    `catalog_id` Int32,

    `brand_id` Int32,

    `name` Nullable(String),

    `description` Nullable(String),

    `supplier` Nullable(String),

    `marketplace` String,

    `letter` String,

    `isNew` UInt8,

    `isSoldOut` UInt8,

    `created` DateTime,

    `updated` DateTime,

    `_sign` Int8 MATERIALIZED 1,

    `_version` UInt64 MATERIALIZED 1
)
ENGINE = ReplacingMergeTree(_version)
PARTITION BY intDiv(id,
 4294967)
ORDER BY (product_id,
 catalog_id,
 brand_id,
 letter,
 updated,
 id)
SETTINGS index_granularity = 8192
```
return std::make_shared<DatabaseConnectionMySQL>(
                    context, database_name, metadata_path, engine_define, mysql_database_name, std::move(mysql_database_settings), std::move(mysql_pool));
            }
            const auto & [remote_host_name, remote_port] = parseAddress(host_port, 3306);
            MySQLClient client(remote_host_name, remote_port, mysql_user_name, mysql_user_password);
            auto mysql_pool = mysqlxx::Pool(mysql_database_name, remote_host_name, mysql_user_name, mysql_user_password);
            auto materialize_mode_settings = std::make_unique<MaterializeMySQLSettings>();
            if (engine_define->settings)
                materialize_mode_settings->loadFromQuery(*engine_define);
            if (create.uuid == UUIDHelpers::Nil)
                return std::make_shared<DatabaseMaterializeMySQL<DatabaseOrdinary>>(
                    context, database_name, metadata_path, uuid, mysql_database_name, std::move(mysql_pool), std::move(client)
                    , std::move(materialize_mode_settings));
            else
                return std::make_shared<DatabaseMaterializeMySQL<DatabaseAtomic>>(
                    context, database_name, metadata_path, uuid, mysql_database_name, std::move(mysql_pool), std::move(client)
                    , std::move(materialize_mode_settings));
        }
        catch (...)
        {
            const auto & exception_message = getCurrentExceptionMessage(true);
            throw Exception("Cannot create MySQL database, because " + exception_message, ErrorCodes::CANNOT_CREATE_DATABASE);
        }
    }
#endif
    else if (engine_name == "Lazy")
    {
        const ASTFunction * engine = engine_define->engine;
        if (!engine->arguments || engine->arguments->children.size() != 1)
            throw Exception("Lazy database require cache_expiration_time_seconds argument", ErrorCodes::BAD_ARGUMENTS);