Имеется 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
```
const Names & column_names,
    const StorageMetadataPtr & ,
    SelectQueryInfo & query_info,
    ContextPtr context,
    QueryProcessingStage::Enum processed_stage,
    size_t max_block_size,
    unsigned int num_streams)
{
    
    rethrowSyncExceptionIfNeed(database);
    NameSet column_names_set = NameSet(column_names.begin(), column_names.end());
    auto lock = nested_storage->lockForShare(context->getCurrentQueryId(), context->getSettingsRef().lock_acquire_timeout);
    const StorageMetadataPtr & nested_metadata = nested_storage->getInMemoryMetadataPtr();
    Block nested_header = nested_metadata->getSampleBlock();
    ColumnWithTypeAndName & sign_column = nested_header.getByPosition(nested_header.columns() - 2);
    ColumnWithTypeAndName & version_column = nested_header.getByPosition(nested_header.columns() - 1);
    if (ASTSelectQuery * select_query = query_info.query->as<ASTSelectQuery>(); select_query && !column_names_set.count(version_column.name))
    {
        auto & tables_in_select_query = select_query->tables()->as<ASTTablesInSelectQuery &>();
        if (!tables_in_select_query.children.empty())
        {
            auto & tables_element = tables_in_select_query.children[0]->as<ASTTablesInSelectQueryElement &>();
            if (tables_element.table_expression)
                tables_element.table_expression->as<ASTTableExpression &>().final = true;