Hello,

so I'm working to integrate CatBoost model with our ClickHouse cluster. It appears that, whenever we create a new XML model file in the configured path, the **first** call to the new model never returns (this is true both of the HTTP interface as well as via clickhouse-client).

Independently from whether the locked statement gets cancelled, subsequent calls succeed immediately.

```
16e8bdb5bbb9 :) select version();

SELECT version()

┌─version()─┐
│ 20.6.3.28 │
└───────────┘

1 rows in set. Elapsed: 0.006 sec.
```

Is this known behavior? If it helps, my models look like this:

```
<models>
    <model>
        <type>catboost</type>
        <name>ctr_predictor</name>
        <path>/catboost/my_predictor</path>
        <lifetime>0</lifetime>
    </model>
</models>
```
auto it = should_update_map.find(info.object);
                        if (it == should_update_map.end())
                            continue; 
                        bool should_update_flag = it->second;
                        if (!should_update_flag)
                        {
                            info.next_update_time = calculateNextUpdateTime(info.object, info.error_count);
                            LOG_TRACE(log, "Object '{}' not modified, will not reload. Next update at {}", info.name, ext::to_string(info.next_update_time));
                            continue;
                        }
                        
                        startLoading(info);
                    }
                    else if (info.failed())
                    {
                        
                        startLoading(info);
                    }
                    LOG_TRACE(log, "Object '{}' is neither loaded nor failed, so it will not be reloaded as outdated.", info.name);
                }
            }
        }
    }
private:
    struct Info
    {
        Info(const String & name_, const std::shared_ptr<const ObjectConfig> & config_) : name(name_), config(config_) {}
        bool loaded() const { return object != nullptr; }
        bool failed() const { return !object && exception; }
        bool loadedOrFailed() const { return loaded() || failed(); }